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 139 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::SetDetachedReads(bool detached_reads) {
+  // We don't support moving from detached to not detached
+  CHECK(!(detached_reads_ && detached_reads));

[mmenke, 2013/10/07 19:16:24]

Unless there's some reason to be particularly concerned about this happening,
this should be a DCHECK.

Also, if we don't support moving from detached to not detached, should we even
be taking in a bool?

[jkarlin2, 2013/10/08 11:53:01]

Done.

+  detached_reads_ = detached_reads;
+}
+
 }  // namespace content