Revert r143458 (which re-applies r143341 and r142979).

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 81 matching lines @@
 
 namespace content {
 
 namespace {
 
 static ResourceDispatcherHostImpl* g_resource_dispatcher_host;
 
 // The interval for calls to ResourceDispatcherHostImpl::UpdateLoadStates
 const int kUpdateLoadStatesIntervalMsec = 100;
 
-// Maximum number of pending data messages sent to the renderer at any
-// given time for a given request.
-const int kMaxPendingDataMessages = 20;
-
 // Maximum byte "cost" of all the outstanding requests for a renderer.
 // See delcaration of |max_outstanding_requests_cost_per_process_| for details.
 // This bound is 25MB, which allows for around 6000 outstanding requests.
 const int kMaxOutstandingRequestsCostPerProcess = 26214400;
 
 // The number of milliseconds after noting a user gesture that we will
 // tag newly-created URLRequest objects with the
 // net::LOAD_MAYBE_USER_GESTURE load flag. This is a fairly arbitrary
 // guess at how long to expect direct impact from a user gesture, but
 // this should be OK as the load flag is a best-effort thing only,
@@ skipping 807 matching lines @@
                                                   route_id,
                                                   request_data.method,
                                                   request_data.url,
                                                   request_data.resource_type,
                                                   resource_context,
                                                   referrer)) {
     AbortRequestBeforeItStarts(filter_, sync_result, route_id, request_id);
     return;
   }
 
-  // Construct the event handler.
-  scoped_ptr<ResourceHandler> handler;
-  if (sync_result) {
-    handler.reset(new SyncResourceHandler(
-        filter_, request_data.url, sync_result, this));
-  } else {
-    handler.reset(new AsyncResourceHandler(
-        filter_, route_id, request_data.url, this));
-  }
-
-  // The RedirectToFileResourceHandler depends on being next in the chain.
-  if (request_data.download_to_file) {
-    handler.reset(
-        new RedirectToFileResourceHandler(handler.Pass(), child_id, this));
-  }
-
   int load_flags =
       BuildLoadFlagsForRequest(request_data, child_id, sync_result != NULL);
 
   // Construct the request.
   scoped_ptr<net::URLRequest> new_request;
   net::URLRequest* request;
   if (deferred_loader.get()) {
     request = deferred_loader->request();
   } else {
     new_request.reset(new net::URLRequest(
@@ skipping 21 matching lines @@
 
   // Set upload data.
   uint64 upload_size = 0;
   if (request_data.upload_data) {
     request->set_upload(request_data.upload_data);
     // This results in performing file IO. crbug.com/112607.
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     upload_size = request_data.upload_data->GetContentLengthSync();
   }
 
+  bool allow_download = request_data.allow_download &&
+      ResourceType::IsFrame(request_data.resource_type);
+
+  // Make extra info and read footer (contains request ID).
+  ResourceRequestInfoImpl* extra_info =
+      new ResourceRequestInfoImpl(
+          process_type,
+          child_id,
+          route_id,
+          request_data.origin_pid,
+          request_id,
+          request_data.is_main_frame,
+          request_data.frame_id,
+          request_data.parent_is_main_frame,
+          request_data.parent_frame_id,
+          request_data.resource_type,
+          request_data.transition_type,
+          upload_size,
+          false,  // is download
+          allow_download,
+          request_data.has_user_gesture,
+          request_data.referrer_policy,
+          resource_context);
+  extra_info->AssociateWithRequest(request);  // Request takes ownership.
+
+  if (request->url().SchemeIs(chrome::kBlobScheme)) {
+    // Hang on to a reference to ensure the blob is not released prior
+    // to the job being started.
+    webkit_blob::BlobStorageController* controller =
+        GetBlobStorageControllerForResourceContext(resource_context);
+    extra_info->set_requested_blob_data(
+        controller->GetBlobDataFromUrl(request->url()));
+  }
+
+  // Have the appcache associate its extra info with the request.
+  appcache::AppCacheInterceptor::SetExtraRequestInfo(
+      request, ResourceContext::GetAppCacheService(resource_context), child_id,
+      request_data.appcache_host_id, request_data.resource_type);
+
+  // Construct the IPC resource handler.
+  scoped_ptr<ResourceHandler> handler;

[darin (slow to review), 2012/06/22 19:56:03]

btw, the point of this code move is to just ensure that the
ResourceRequestInfoImpl has been associated with the URLRequest before we build
the ResourceHandlers.  it enables the AsyncResourceHandler constructor to reach
out and modify the ResourceRequestInfoImpl.

+  if (sync_result) {
+    handler.reset(new SyncResourceHandler(
+        filter_, request, sync_result, this));
+  } else {
+    handler.reset(new AsyncResourceHandler(
+        filter_, route_id, request, this));
+  }
+
+  // The RedirectToFileResourceHandler depends on being next in the chain.
+  if (request_data.download_to_file) {
+    handler.reset(
+        new RedirectToFileResourceHandler(handler.Pass(), child_id, this));
+  }
+
   // Install a CrossSiteResourceHandler if this request is coming from a
   // RenderViewHost with a pending cross-site request.  We only check this for
   // MAIN_FRAME requests. Unblock requests only come from a blocked page, do
   // not count as cross-site, otherwise it gets blocked indefinitely.
   if (request_data.resource_type == ResourceType::MAIN_FRAME &&
       process_type == PROCESS_TYPE_RENDERER &&
       CrossSiteRequestManager::GetInstance()->
           HasPendingCrossSiteRequest(child_id, route_id)) {
     // Wrap the event handler to be sure the current page's onunload handler
     // has a chance to run before we render the new page.
-    handler.reset(
-        new CrossSiteResourceHandler(handler.Pass(), child_id, route_id, this));
+    handler.reset(new CrossSiteResourceHandler(handler.Pass(), child_id,
+                                               route_id, request));
   }
 
   // Insert a buffered event handler before the actual one.
   handler.reset(
       new BufferedResourceHandler(handler.Pass(), this, request));
 
   ScopedVector<ResourceThrottle> throttles;
   if (delegate_) {
     bool is_continuation_of_transferred_request =
         (deferred_loader.get() != NULL);
@@ skipping 12 matching lines @@
         throttles.begin(),
         new TransferNavigationResourceThrottle(request));
   }
 
   if (!throttles.empty()) {
     handler.reset(
         new ThrottlingResourceHandler(handler.Pass(), child_id, request_id,
                                       throttles.Pass()));
   }
 
-  bool allow_download = request_data.allow_download &&
-      ResourceType::IsFrame(request_data.resource_type);
-  // Make extra info and read footer (contains request ID).
-  ResourceRequestInfoImpl* extra_info =
-      new ResourceRequestInfoImpl(
-          process_type,
-          child_id,
-          route_id,
-          request_data.origin_pid,
-          request_id,
-          request_data.is_main_frame,
-          request_data.frame_id,
-          request_data.parent_is_main_frame,
-          request_data.parent_frame_id,
-          request_data.resource_type,
-          request_data.transition_type,
-          upload_size,
-          false,  // is download
-          allow_download,
-          request_data.has_user_gesture,
-          request_data.referrer_policy,
-          resource_context);
-  extra_info->AssociateWithRequest(request);  // Request takes ownership.
-
-  if (request->url().SchemeIs(chrome::kBlobScheme)) {
-    // Hang on to a reference to ensure the blob is not released prior
-    // to the job being started.
-    webkit_blob::BlobStorageController* controller =
-        GetBlobStorageControllerForResourceContext(resource_context);
-    extra_info->set_requested_blob_data(
-        controller->GetBlobDataFromUrl(request->url()));
-  }
-
-  // Have the appcache associate its extra info with the request.
-  appcache::AppCacheInterceptor::SetExtraRequestInfo(
-      request, ResourceContext::GetAppCacheService(resource_context), child_id,
-      request_data.appcache_host_id, request_data.resource_type);
-
   if (deferred_loader.get()) {
     pending_loaders_[extra_info->GetGlobalRequestID()] = 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);
 }
 
 void ResourceDispatcherHostImpl::OnDataReceivedACK(int request_id) {
-  DataReceivedACK(filter_->child_id(), request_id);
-}
-
-void ResourceDispatcherHostImpl::DataReceivedACK(int child_id,
-                                                 int request_id) {
-  ResourceLoader* loader = GetLoader(child_id, request_id);
+  ResourceLoader* loader = GetLoader(filter_->child_id(), request_id);
   if (!loader)
     return;
 
   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
-
-  // Decrement the number of pending data messages.
-  info->DecrementPendingDataCount();
-
-  // If the pending data count was higher than the max, resume the request.
-  if (info->pending_data_count() == kMaxPendingDataMessages) {
-    // Decrement the pending data count one more time because we also
-    // incremented it before pausing the request.
-    info->DecrementPendingDataCount();
-
-    // Resume the request.
-    //
-    // TODO(darin): Make the AsyncResourceHandler be responsible for resuming
-    // via its controller().  This static_cast is here as a temporary measure.
-    //
-    static_cast<ResourceController*>(loader)->Resume();
-  }
+  if (info->async_handler())
+    info->async_handler()->OnDataReceivedACK();
 }
 
 void ResourceDispatcherHostImpl::OnDataDownloadedACK(int request_id) {
   // TODO(michaeln): maybe throttle DataDownloaded messages
 }
 
 void ResourceDispatcherHostImpl::RegisterDownloadedTempFile(
     int child_id, int request_id, ShareableFileReference* reference) {
   registered_temp_files_[child_id][request_id] = reference;
   ChildProcessSecurityPolicyImpl::GetInstance()->GrantReadFile(
@@ skipping 43 matching lines @@
 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);
   if (!loader) {
     DVLOG(1) << "OnFollowRedirect for invalid request";
     return;
   }
 
-  loader->OnFollowRedirect(has_new_first_party_for_cookies,
-                           new_first_party_for_cookies);
+  ResourceRequestInfoImpl* info = loader->GetRequestInfo();
+  if (info->async_handler()) {
+    info->async_handler()->OnFollowRedirect(
+        has_new_first_party_for_cookies,
+        new_first_party_for_cookies);
+  }
 }
 
 ResourceRequestInfoImpl* ResourceDispatcherHostImpl::CreateRequestInfo(
     int child_id,
     int route_id,
     bool download,
     ResourceContext* context) {
   return new ResourceRequestInfoImpl(
       PROCESS_TYPE_RENDERER,
       child_id,
@@ skipping 94 matching lines @@
   request->set_load_flags(net::LOAD_PREFERRING_CACHE);
 
   // Since we're just saving some resources we need, disallow downloading.
   ResourceRequestInfoImpl* extra_info =
       CreateRequestInfo(child_id, route_id, false, context);
   extra_info->AssociateWithRequest(request.get());  // Request takes ownership.
 
   BeginRequestInternal(request.Pass(), handler.Pass());
 }
 
-bool ResourceDispatcherHostImpl::WillSendData(int child_id, int request_id,
-                                              bool* defer) {
-  ResourceLoader* loader = GetLoader(child_id, request_id);
-  if (!loader) {
-    NOTREACHED() << "WillSendData for invalid request";
-    return false;
-  }
-
-  ResourceRequestInfoImpl* info = loader->GetRequestInfo();
-
-  info->IncrementPendingDataCount();
-  if (info->pending_data_count() > kMaxPendingDataMessages) {
-    // We reached the max number of data messages that can be sent to
-    // the renderer for a given request. Pause the request and wait for
-    // the renderer to start processing them before resuming it.
-    *defer = true;
-    return false;
-  }
-
-  return true;
-}
-
 void ResourceDispatcherHostImpl::MarkAsTransferredNavigation(
     const GlobalRequestID& id) {
   GetLoader(id)->MarkAsTransferring();
 }
 
 int ResourceDispatcherHostImpl::GetOutstandingRequestsMemoryCost(
     int child_id) const {
   OutstandingRequestsMemoryCostMap::const_iterator entry =
       outstanding_requests_memory_cost_map_.find(child_id);
   return (entry == outstanding_requests_memory_cost_map_.end()) ?
@@ skipping 188 matching lines @@
     request->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
 
     if (!handler->OnResponseCompleted(info->GetRequestID(), request->status(),
                                       std::string())) {
       // TODO(darin): The handler is not ready for us to kill the request. Oops!
       NOTREACHED();
     }
 
     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));
 
   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.
@@ skipping 223 matching lines @@
 
   return i->second.get();
 }
 
 ResourceLoader* ResourceDispatcherHostImpl::GetLoader(int child_id,
                                                       int request_id) const {
   return GetLoader(GlobalRequestID(child_id, request_id));
 }
 
 }  // namespace content