Implement ResourceQueue, an object that makes it easy to delay starting

chrome/browser/renderer_host/resource_dispatcher_host.cc

 // Copyright (c) 2009 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 "chrome/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <vector>
 
@@ skipping 16 matching lines @@
 #include "chrome/browser/login_prompt.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/net/url_request_tracking.h"
 #include "chrome/browser/plugin_service.h"
 #include "chrome/browser/privacy_blacklist/blacklist.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/async_resource_handler.h"
 #include "chrome/browser/renderer_host/buffered_resource_handler.h"
 #include "chrome/browser/renderer_host/cross_site_resource_handler.h"
 #include "chrome/browser/renderer_host/download_resource_handler.h"
+#include "chrome/browser/renderer_host/global_request_id.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_view_host_delegate.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host_request_info.h"
+#include "chrome/browser/renderer_host/resource_queue.h"
 #include "chrome/browser/renderer_host/resource_request_details.h"
 #include "chrome/browser/renderer_host/safe_browsing_resource_handler.h"
 #include "chrome/browser/renderer_host/save_file_resource_handler.h"
 #include "chrome/browser/renderer_host/socket_stream_dispatcher_host.h"
 #include "chrome/browser/renderer_host/sync_resource_handler.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/ssl/ssl_client_auth_handler.h"
 #include "chrome/browser/ssl/ssl_manager.h"
 #include "chrome/browser/worker_host/worker_service.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 190 matching lines @@
 }
 
 }  // namespace
 
 ResourceDispatcherHost::ResourceDispatcherHost()
     : ALLOW_THIS_IN_INITIALIZER_LIST(
           download_file_manager_(new DownloadFileManager(this))),
       download_request_manager_(new DownloadRequestManager()),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           save_file_manager_(new SaveFileManager(this))),
-      ALLOW_THIS_IN_INITIALIZER_LIST(user_script_listener_(
-          new UserScriptListener(this))),
+      user_script_listener_(new UserScriptListener(&resource_queue_)),
       safe_browsing_(new SafeBrowsingService),
       socket_stream_dispatcher_host_(new SocketStreamDispatcherHost),
       webkit_thread_(new WebKitThread),
       request_id_(-1),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_runner_(this)),
       is_shutdown_(false),
       max_outstanding_requests_cost_per_process_(
           kMaxOutstandingRequestsCostPerProcess),
       receiver_(NULL) {
+  ResourceQueue::DelegateSet resource_queue_delegates;
+  resource_queue_delegates.insert(user_script_listener_.get());
+  resource_queue_.Initialize(resource_queue_delegates);
 }
 
 ResourceDispatcherHost::~ResourceDispatcherHost() {
   AsyncResourceHandler::GlobalCleanup();
   STLDeleteValues(&pending_requests_);
 
   // Clear blocked requests if any left.
   // Note that we have to do this in 2 passes as we cannot call
   // CancelBlockedRequestsForRoute while iterating over
   // blocked_requests_map_, as it modifies it.
   std::set<ProcessRouteIDs> ids;
   for (BlockedRequestMap::const_iterator iter = blocked_requests_map_.begin();
        iter != blocked_requests_map_.end(); ++iter) {
     std::pair<std::set<ProcessRouteIDs>::iterator, bool> result =
         ids.insert(iter->first);
     // We should not have duplicates.
     DCHECK(result.second);
   }
   for (std::set<ProcessRouteIDs>::const_iterator iter = ids.begin();
        iter != ids.end(); ++iter) {
     CancelBlockedRequestsForRoute(iter->first, iter->second);
   }
-
-  user_script_listener_->OnResourceDispatcherHostGone();
 }
 
 void ResourceDispatcherHost::Initialize() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   webkit_thread_->Initialize();
   safe_browsing_->Initialize();
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
       NewRunnableFunction(&appcache::AppCacheInterceptor::EnsureRegistered));
 }
 
 void ResourceDispatcherHost::Shutdown() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   ChromeThread::PostTask(ChromeThread::IO, FROM_HERE, new ShutdownTask(this));
 }
 
 void ResourceDispatcherHost::SetRequestInfo(
     URLRequest* request,
     ResourceDispatcherHostRequestInfo* info) {
   request->SetUserData(NULL, info);
 }
 
 void ResourceDispatcherHost::OnShutdown() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   is_shutdown_ = true;
+  resource_queue_.Shutdown();
   STLDeleteValues(&pending_requests_);
   // Make sure we shutdown the timer now, otherwise by the time our destructor
   // runs if the timer is still running the Task is deleted twice (once by
   // the MessageLoop and the second time by RepeatingTimer).
   update_load_states_timer_.Stop();
 }
 
 bool ResourceDispatcherHost::HandleExternalProtocol(int request_id,
                                                     int child_id,
                                                     int route_id,
@@ skipping 675 matching lines @@
 
 void ResourceDispatcherHost::RemovePendingRequest(
     const PendingRequestList::iterator& iter) {
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(iter->second);
 
   // Remove the memory credit that we added when pushing the request onto
   // the pending list.
   IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost(),
                                          info->child_id());
 
-  // Notify the login handler that this request object is going away.
+  // Notify interested parties that the request object is going away.
   if (info && info->login_handler())
     info->login_handler()->OnRequestCancelled();
+  resource_queue_.RemoveRequest(iter->first);
 
   delete iter->second;
   pending_requests_.erase(iter);
 
   // If we have no more pending requests, then stop the load state monitor
   if (pending_requests_.empty())
     update_load_states_timer_.Stop();
 }
 
 // URLRequest::Delegate -------------------------------------------------------
@@ skipping 282 matching lines @@
   std::pair<int, int> pair_id(info->child_id(), info->route_id());
   BlockedRequestMap::const_iterator iter = blocked_requests_map_.find(pair_id);
   if (iter != blocked_requests_map_.end()) {
     // The request should be blocked.
     iter->second->push_back(request);
     return;
   }
 
   GlobalRequestID global_id(info->child_id(), info->request_id());
   pending_requests_[global_id] = request;
-  if (!user_script_listener_->ShouldStartRequest(request)) {
-    // This request depends on some user scripts that haven't loaded yet.  The
-    // UserScriptListener will resume the request when they're ready.
-    return;
-  }
-  request->Start();
+  resource_queue_.AddRequest(request, *info);
 
   // Make sure we have the load state monitor running
   if (!update_load_states_timer_.IsRunning()) {
     update_load_states_timer_.Start(
         TimeDelta::FromMilliseconds(kUpdateLoadStatesIntervalMsec),
         this, &ResourceDispatcherHost::UpdateLoadStates);
   }
 }
 
 bool ResourceDispatcherHost::PauseRequestIfNeeded(
@@ skipping 202 matching lines @@
 
 void ResourceDispatcherHost::AddObserver(Observer* obs) {
   observer_list_.AddObserver(obs);
 }
 
 void ResourceDispatcherHost::RemoveObserver(Observer* obs) {
   observer_list_.RemoveObserver(obs);
 }
 
 URLRequest* ResourceDispatcherHost::GetURLRequest(
-    GlobalRequestID request_id) const {
+    const GlobalRequestID& request_id) const {
   // This should be running in the IO loop.
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   PendingRequestList::const_iterator i = pending_requests_.find(request_id);
   if (i == pending_requests_.end())
     return NULL;
 
   return i->second;
 }
 
@@ skipping 272 matching lines @@
     case ViewHostMsg_UploadProgress_ACK::ID:
     case ViewHostMsg_SyncLoad::ID:
       return true;
 
     default:
       break;
   }
 
   return false;
 }