Allows prefetch requests to live beyond the renderer by delaying

content/browser/loader/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/loader/resource_dispatcher_host_impl.h"
 
 #include <set>
 #include <vector>
@@ skipping 389 matching lines @@
       delete loaders;
     } else {
       ++i;
     }
   }
 
 #ifndef NDEBUG
   for (LoaderList::iterator i = loaders_to_cancel.begin();
        i != loaders_to_cancel.end(); ++i) {
     // There is no strict requirement that this be the case, but currently
-    // downloads, streams  and transferred requests are the only requests that
-    // aren't cancelled when the associated processes go away. It may be OK for
-    // this invariant to change in the future, but if this assertion fires
-    // without the invariant changing, then it's indicative of a leak.
+    // downloads, streams, prefetches, and transferred requests are the only
+    // requests that aren't cancelled when the associated processes go away. It
+    // may be OK for this invariant to change in the future, but if this
+    // assertion fires without the invariant changing, then it's indicative of a
+    // leak.
     DCHECK((*i)->GetRequestInfo()->is_download() ||
            (*i)->GetRequestInfo()->is_stream() ||
+           (*i)->GetRequestInfo()->GetResourceType() ==
+               ResourceType::PREFETCH ||
            (*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
@@ skipping 665 matching lines @@
   // Have the appcache associate its extra info with the request.
   appcache::AppCacheInterceptor::SetExtraRequestInfo(
       request, filter_->appcache_service(), child_id,
       request_data.appcache_host_id, request_data.resource_type);
 
   // Construct the IPC resource handler.
   scoped_ptr<ResourceHandler> handler;
   if (sync_result) {
     handler.reset(new SyncResourceHandler(request, sync_result, this));
   } else {
-    handler.reset(new AsyncResourceHandler(request, this));
+    AsyncResourceHandler* async_handler =
+        new AsyncResourceHandler(request, this);
+    if (request_data.resource_type == ResourceType::PREFETCH) {
+      // The renderer doesn't need prefetch data notifications and the prefetch
+      // request might live longer than the renderer, so detach reads.
+      async_handler->DetachReads();
+    }
+    handler.reset(async_handler);
   }
 
   // The RedirectToFileResourceHandler depends on being next in the chain.
   if (request_data.download_to_file) {
     handler.reset(
         new RedirectToFileResourceHandler(handler.Pass(), request, this));
   }
 
   // Install a CrossSiteResourceHandler if this request is coming from a
   // RenderViewHost with a pending cross-site request.  We only check this for
@@ skipping 205 matching lines @@
   ResourceLoader* loader = GetLoader(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();
   }
 }
 
 // The object died, so cancel and detach all requests associated with it except
-// for downloads, which belong to the browser process even if initiated via a
-// renderer.
+// for downloads and prefetches, which belong to the browser process even if
+// initiated via a renderer.
 void ResourceDispatcherHostImpl::CancelRequestsForProcess(int child_id) {
   CancelRequestsForRoute(child_id, -1 /* cancel all */);
   registered_temp_files_.erase(child_id);
 }
 
 void ResourceDispatcherHostImpl::CancelRequestsForRoute(int child_id,
                                                         int route_id) {
   // Since pending_requests_ is a map, we first build up a list of all of the
   // matching requests to be cancelled, and then we cancel them.  Since there
   // 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.
   bool any_requests_transferring = false;
   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();
 
     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 (IsTransferredNavigation(id))
       any_requests_transferring = true;
     if (!info->is_download() && !info->is_stream() &&
+        info->GetResourceType() != ResourceType::PREFETCH &&
         !IsTransferredNavigation(id) &&
         (route_id == -1 || route_id == info->GetRouteID())) {
       matching_requests.push_back(id);
     }
   }
 
   // Remove matches.
   for (size_t i = 0; i < matching_requests.size(); ++i) {
     LoaderMap::iterator iter = pending_loaders_.find(matching_requests[i]);
     // Although every matching request was in pending_requests_ when we built
@@ skipping 552 matching lines @@
   if ((load_flags & net::LOAD_REPORT_RAW_HEADERS)
       && !policy->CanReadRawCookies(child_id)) {
     VLOG(1) << "Denied unauthorized request for raw headers";
     load_flags &= ~net::LOAD_REPORT_RAW_HEADERS;
   }
 
   return load_flags;
 }
 
 }  // namespace content