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 69 matching lines @@
     net::URLRequest* request,
     ResourceDispatcherHostImpl* rdh)
     : ResourceMessageDelegate(request),
       request_(request),
       rdh_(rdh),
       pending_data_count_(0),
       allocation_size_(0),
       did_defer_(false),
       has_checked_for_sufficient_resources_(false),
       sent_received_response_msg_(false),
-      sent_first_data_msg_(false) {
+      sent_first_data_msg_(false),
+      detached_reads_(false) {
   InitializeResourceBufferConstants();
 }
 
 AsyncResourceHandler::~AsyncResourceHandler() {
   if (has_checked_for_sufficient_resources_)
     rdh_->FinishedWithResourcesForRequest(request_);
 }
 
 bool AsyncResourceHandler::OnMessageReceived(const IPC::Message& message,
                                              bool* message_was_ok) {
@@ skipping 70 matching lines @@
                                              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;

[mmenke, 2013/10/08 14:50:54]

So we still cancel prefetches if the renderer is destroyed before the response
is started, though we only do it once we start receiving a response?  And the
same thing for redirects?

I'm not hugely concerned about this, just want to make sure we understand what
this patch does and doesn't do.

[jkarlin2, 2013/10/09 14:44:33]

Are you saying that the 'return false' above will cause a cancel?  The
ResourceLoader seems to ignore the result of this, so it shouldn't cancel the
prefetch.  

[mmenke, 2013/10/09 14:59:08]

The return false should indeed result in a cancel.

https://code.google.com/p/chromium/codesearch#chromium/src/content/browser/lo...

Now that I think about it more, I'm not sure if info->filter() is NULL in that
case, just assumed it would be.

[jkarlin2, 2013/10/09 17:28:29]

Right, not sure how I didn't see that.  It seems reasonable to expect the filter
to be gone if the renderer is gone, but we don't want these prefetches (and
potentially <a ping>'s later) to be canceled.

It seems somewhat icky to hack in a guard at the beginning of each function and
ignore the setup that say OnResponseStarted goes through.  I think a new
ResourceHandler, say, DetachedResourceHandler, is required that only signals
close and error signals to the renderer, and loads regardless of the filter's
existence.

 
   if (rdh_->delegate()) {
     rdh_->delegate()->OnResponseStarted(
         request_, info->GetContext(), response, info->filter());
   }
 
   DevToolsNetLogObserver::PopulateResponseInfo(request_, response);
 
   HostZoomMap* host_zoom_map =
       GetHostZoomMapForResourceContext(info->GetContext());
@@ skipping 48 matching lines @@
       "Net.AsyncResourceHandler_SharedIOBuffer_Alloc",
       *buf_size, 0, kMaxAllocationSize, 100);
   return true;
 }
 
 bool AsyncResourceHandler::OnReadCompleted(int request_id, int bytes_read,
                                            bool* defer) {
   if (!bytes_read)
     return true;
 
+  if (detached_reads_) {
+    buffer_->RecycleLeastRecentlyAllocated();
+    return true;
+  }
+
   const ResourceRequestInfoImpl* info =
       ResourceRequestInfoImpl::ForRequest(request_);
   if (!info->filter())
     return false;
 
   buffer_->ShrinkLastAllocation(bytes_read);
 
   UMA_HISTOGRAM_CUSTOM_COUNTS(
       "Net.AsyncResourceHandler_SharedIOBuffer_Used",
       bytes_read, 0, kMaxAllocationSize, 100);
@@ skipping 117 matching lines @@
                              kMaxAllocationSize);
 }
 
 void AsyncResourceHandler::ResumeIfDeferred() {
   if (did_defer_) {
     did_defer_ = false;
     controller()->Resume();
   }
 }
 
+void AsyncResourceHandler::DetachReads() {
+  detached_reads_ = true;
+}
+
 }  // namespace content