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 339 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 43 matching lines @@
 
   // 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;
   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);
+    if (i->second->loader()->GetRequestInfo()->GetContext() == context) {
+      loaders_to_cancel.push_back(i->second->loader());
       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()) {
@@ skipping 33 matching lines @@
     DCHECK((*i)->GetRequestInfo()->is_download() || (*i)->is_transferring());
   }
 #endif
 
   loaders_to_cancel.clear();
 
   // Validate that no more requests for this context were added.
   for (LoaderMap::const_iterator i = pending_loaders_.begin();
        i != pending_loaders_.end(); ++i) {
     // http://crbug.com/90971
-    CHECK_NE(i->second->GetRequestInfo()->GetContext(), context);
+    CHECK_NE(i->second->loader()->GetRequestInfo()->GetContext(), context);
   }
 
   for (BlockedLoadersMap::const_iterator i = blocked_loaders_map_.begin();
        i != blocked_loaders_map_.end(); ++i) {
     BlockedLoadersList* loaders = i->second;
     if (!loaders->empty()) {
       ResourceRequestInfoImpl* info = loaders->front()->GetRequestInfo();
       // http://crbug.com/90971
       CHECK_NE(info->GetContext(), context);
     }
@@ skipping 159 matching lines @@
     ResourceLoader* 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(
+    ResourceLoader* 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();
@@ skipping 27 matching lines @@
       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(
+    ResourceLoader* 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())));
@@ skipping 154 matching lines @@
   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;
   {
     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;
+      if (it->second->loader()->is_transferring()) {
+        deferred_loader = it->second->loader();
         pending_loaders_.erase(it);
       } else {
         RecordAction(UserMetricsAction("BadMessageTerminate_RDH"));
         filter_->BadMessageReceived();
         return;
       }
     }
   }
 
   ResourceContext* resource_context = filter_->resource_context();
@@ skipping 155 matching lines @@
         new TransferNavigationResourceThrottle(request));
   }
 
   if (!throttles.empty()) {
     handler.reset(
         new ThrottlingResourceHandler(handler.Pass(), child_id, request_id,
                                       throttles.Pass()));
   }
 
   if (deferred_loader.get()) {
-    pending_loaders_[extra_info->GetGlobalRequestID()] = deferred_loader;
+    pending_loaders_[extra_info->GetGlobalRequestID()] = make_linked_ptr(
+        resource_scheduler_->ScheduleLoad(child_id, route_id, request_id,
+                                          deferred_loader));
     deferred_loader->CompleteTransfer(handler.Pass());
   } else {
     BeginRequestInternal(new_request.Pass(), handler.Pass());
   }
 }
 
 void ResourceDispatcherHostImpl::OnReleaseDownloadedFile(int request_id) {
   UnregisterDownloadedTempFile(filter_->child_id(), request_id);
 }
 
@@ skipping 110 matching lines @@
     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);
+                                         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 97 matching lines @@
   // may be more than one request to cancel, we cannot simply hold onto the map
   // iterators found in the first loop.
 
   // Find the global ID of all matching elements.
   std::vector<GlobalRequestID> matching_requests;
   for (LoaderMap::const_iterator i = pending_loaders_.begin();
        i != pending_loaders_.end(); ++i) {
     if (i->first.child_id != child_id)
       continue;
 
-    ResourceRequestInfoImpl* info = i->second->GetRequestInfo();
+    ResourceRequestInfoImpl* info = i->second->loader()->GetRequestInfo();
 
     GlobalRequestID id(child_id, i->first.request_id);
     DCHECK(id == i->first);
 
     // Don't cancel navigations that are transferring to another process,
     // since they belong to another process now.
     if (!info->is_download() && !IsTransferredNavigation(id) &&
         (route_id == -1 || route_id == info->GetRouteID())) {
       matching_requests.push_back(id);
     }
@@ skipping 46 matching lines @@
       GlobalRequestID(child_id, request_id));
   if (i == pending_loaders_.end()) {
     NOTREACHED() << "Trying to remove a request that's not here";
     return;
   }
   RemovePendingLoader(i);
 }
 
 void ResourceDispatcherHostImpl::RemovePendingLoader(
     const LoaderMap::iterator& iter) {
-  ResourceRequestInfoImpl* info = iter->second->GetRequestInfo();
+  ResourceRequestInfoImpl* info = iter->second->loader()->GetRequestInfo();
 
   // Remove the memory credit that we added when pushing the request onto
   // the pending list.
   IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost(),
                                          info->GetChildID());
 
   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())
@@ skipping 108 matching lines @@
     iter->second->push_back(loader);
     return;
   }
 
   StartLoading(info, loader);
 }
 
 void ResourceDispatcherHostImpl::StartLoading(
     ResourceRequestInfoImpl* info,
     const linked_ptr<ResourceLoader>& loader) {
-  pending_loaders_[info->GetGlobalRequestID()] = loader;
-
-  loader->StartRequest();
+  pending_loaders_[info->GetGlobalRequestID()] = make_linked_ptr(
+      resource_scheduler_->ScheduleLoad(info->GetChildID(), info->GetRouteID(),
+                                        info->GetRequestID(), loader));
 }
 
 void ResourceDispatcherHostImpl::OnUserGesture(WebContentsImpl* contents) {
   last_user_gesture_time_ = TimeTicks::Now();
 }
 
 net::URLRequest* ResourceDispatcherHostImpl::GetURLRequest(
     const GlobalRequestID& id) {
   ResourceLoader* loader = GetLoader(id);
   if (!loader)
@@ skipping 56 matching lines @@
   // Populate this map with load state changes, and then send them on to the UI
   // thread where they can be passed along to the respective RVHs.
   LoadInfoMap info_map;
 
   LoaderMap::const_iterator i;
 
   // Determine the largest upload size of all requests
   // in each View (good chance it's zero).
   std::map<std::pair<int, int>, uint64> largest_upload_size;
   for (i = pending_loaders_.begin(); i != pending_loaders_.end(); ++i) {
-    net::URLRequest* request = i->second->request();
-    ResourceRequestInfoImpl* info = i->second->GetRequestInfo();
+    net::URLRequest* request = i->second->loader()->request();
+    ResourceRequestInfoImpl* info = i->second->loader()->GetRequestInfo();
     uint64 upload_size = request->GetUploadProgress().size();
     if (request->GetLoadState().state != net::LOAD_STATE_SENDING_REQUEST)
       upload_size = 0;
     std::pair<int, int> key(info->GetChildID(), info->GetRouteID());
     if (upload_size && largest_upload_size[key] < upload_size)
       largest_upload_size[key] = upload_size;
   }
 
   for (i = pending_loaders_.begin(); i != pending_loaders_.end(); ++i) {
-    net::URLRequest* request = i->second->request();
-    ResourceRequestInfoImpl* info = i->second->GetRequestInfo();
+    net::URLRequest* request = i->second->loader()->request();
+    ResourceRequestInfoImpl* info = i->second->loader()->GetRequestInfo();
     net::LoadStateWithParam load_state = request->GetLoadState();
     net::UploadProgress progress = request->GetUploadProgress();
 
     // We also poll for upload progress on this timer and send upload
     // progress ipc messages to the plugin process.
-    i->second->ReportUploadProgress();
+    i->second->loader()->ReportUploadProgress();
 
     std::pair<int, int> key(info->GetChildID(), info->GetRouteID());
 
     // If a request is uploading data, ignore all other requests so that the
     // upload progress takes priority for being shown in the status bar.
     if (largest_upload_size.find(key) != largest_upload_size.end() &&
         progress.size() < largest_upload_size[key])
       continue;
 
     net::LoadStateWithParam to_insert = load_state;
@@ skipping 98 matching lines @@
 }
 
 ResourceLoader* 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();
+  return i->second->loader().get();
 }
 
-ResourceLoader* ResourceDispatcherHostImpl::GetLoader(int child_id,
-                                                      int request_id) const {
+ResourceLoader* ResourceDispatcherHostImpl::GetLoader(
+    int child_id, int request_id) const {
   return GetLoader(GlobalRequestID(child_id, request_id));
 }
 
 }  // namespace content