Allows prefetch requests to live beyond the renderer by delaying

content/browser/loader/async_resource_handler.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.
 
 #include "content/browser/loader/async_resource_handler.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 120 matching lines @@
       ResumeIfDeferred();
   }
 }
 
 bool AsyncResourceHandler::OnUploadProgress(int request_id,
                                             uint64 position,
                                             uint64 size) {
   const ResourceRequestInfoImpl* info =
       ResourceRequestInfoImpl::ForRequest(request_);
   if (!info->filter())
     return false;

[asanka, 2013/10/16 20:42:37]

Should this also return info->is_detachable()?

<a ping> uses POST, right?

[mmenke, 2013/10/17 18:33:48]

Yea, <a ping>'s are POSTs with 4-character bodies.

[jkarlin2, 2013/10/24 15:33:11]

Done.

[jkarlin2, 2013/10/24 15:33:11]

Done.

   return info->filter()->Send(
       new ResourceMsg_UploadProgress(request_id, position, size));
 }
 
 bool AsyncResourceHandler::OnRequestRedirected(int request_id,
                                                const GURL& new_url,
                                                ResourceResponse* response,
                                                bool* defer) {
   const ResourceRequestInfoImpl* info =
       ResourceRequestInfoImpl::ForRequest(request_);
   if (!info->filter())
-    return false;
+    return info->is_detachable();

[mmenke, 2013/10/17 18:33:48]

I think all of these need a comment along the lines of "If detachable, just
continue with the request.  Otherwise, cancel it."

[jkarlin2, 2013/10/24 15:33:11]

Done.

 
   *defer = did_defer_ = true;
 
   if (rdh_->delegate()) {
     rdh_->delegate()->OnRequestRedirected(
         new_url, request_, info->GetContext(), response);
   }
 
   DevToolsNetLogObserver::PopulateResponseInfo(request_, response);
   response->head.request_start = request_->creation_time();
   response->head.response_start = TimeTicks::Now();
   return info->filter()->Send(new ResourceMsg_ReceivedRedirect(
       request_id, new_url, response->head));
 }
 
 bool AsyncResourceHandler::OnResponseStarted(int request_id,
                                              ResourceResponse* response,
                                              bool* defer) {
   // For changes to the main frame, inform the renderer of the new URL's
   // per-host settings before the request actually commits.  This way the
   // renderer will be able to set these precisely at the time the
   // request commits, avoiding the possibility of e.g. zooming the old content
   // or of having to layout the new content twice.
 
   const ResourceRequestInfoImpl* info =
       ResourceRequestInfoImpl::ForRequest(request_);
   if (!info->filter())
-    return false;
+    return info->is_detachable();
 
   if (rdh_->delegate()) {
     rdh_->delegate()->OnResponseStarted(
         request_, info->GetContext(), response, info->filter());
   }
 
   DevToolsNetLogObserver::PopulateResponseInfo(request_, response);
 
   HostZoomMap* host_zoom_map =
       GetHostZoomMapForResourceContext(info->GetContext());
@@ skipping 50 matching lines @@
   return true;
 }
 
 bool AsyncResourceHandler::OnReadCompleted(int request_id, int bytes_read,
                                            bool* defer) {
   if (!bytes_read)
     return true;
 
   const ResourceRequestInfoImpl* info =
       ResourceRequestInfoImpl::ForRequest(request_);
+  if (info->is_detachable()) {

[mmenke, 2013/10/17 18:33:48]

Again, comment that renderers don't care about reads from detachable requests
(Does devtools care?)

[jkarlin2, 2013/10/24 15:33:11]

Done.

+    buffer_->RecycleLeastRecentlyAllocated();
+    return true;
+  }
   if (!info->filter())
     return false;
 
   buffer_->ShrinkLastAllocation(bytes_read);
 
   UMA_HISTOGRAM_CUSTOM_COUNTS(
       "Net.AsyncResourceHandler_SharedIOBuffer_Used",
       bytes_read, 0, kMaxAllocationSize, 100);
   UMA_HISTOGRAM_PERCENTAGE(
       "Net.AsyncResourceHandler_SharedIOBuffer_UsedPercentage",
@@ skipping 43 matching lines @@
   }
 }
 
 bool AsyncResourceHandler::OnResponseCompleted(
     int request_id,
     const net::URLRequestStatus& status,
     const std::string& security_info) {
   const ResourceRequestInfoImpl* info =
       ResourceRequestInfoImpl::ForRequest(request_);
   if (!info->filter())
-    return false;
+    return info->is_detachable();

[mmenke, 2013/10/17 18:33:48]

Hmm....Wonder about returning false in this case in the first place.

[jkarlin2, 2013/10/24 15:33:11]

Noted. It's unclear to me.  The loader seems to interpret false as a need to 
jump into a DEFERRED_FINISH state.  I want to change as little existing behavior
as possible in this CL though so will leave the same.

 
   // If we crash here, figure out what URL the renderer was requesting.
   // http://crbug.com/107692
   char url_buf[128];
   base::strlcpy(url_buf, request_->url().spec().c_str(), arraysize(url_buf));
   base::debug::Alias(url_buf);
 
   // TODO(gavinp): Remove this CHECK when we figure out the cause of
   // http://crbug.com/124680 . This check mirrors closely check in
   // WebURLLoaderImpl::OnCompletedRequest that routes this message to a WebCore
@@ skipping 52 matching lines @@
 }
 
 void AsyncResourceHandler::ResumeIfDeferred() {
   if (did_defer_) {
     did_defer_ = false;
     controller()->Resume();
   }
 }
 
 }  // namespace content