Allows prefetch requests to live beyond the renderer by delaying

content/browser/loader/resource_loader.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/resource_loader.h"
 
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
+#include "base/timer/timer.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/loader/cross_site_resource_handler.h"
 #include "content/browser/loader/resource_loader_delegate.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/browser/ssl/ssl_client_auth_handler.h"
 #include "content/browser/ssl/ssl_manager.h"
 #include "content/common/ssl_status_serialization.h"
 #include "content/public/browser/cert_store.h"
 #include "content/public/browser/resource_dispatcher_host_login_delegate.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/ssl/client_cert_store.h"
 #include "net/ssl/client_cert_store_impl.h"
 #include "webkit/browser/appcache/appcache_interceptor.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace content {
 namespace {
 
+// TODO(jkarlin): The value is high to reduce the chance of the detachable
+// request timing out, forcing a blocked second request to open a new connection
+// and start over. Reduce this value once we have a better idea of what it
+// should be and once we stop blocking multiple simultaneous requests for the
+// same resource (see bugs 46104 and 31014).

[James Simonsen, 2013/10/28 21:16:40]

I think the worst case scenario here is that the other renderer is hung. The
request will stay open, but the buffer will always be full and it'll stop
reading. This request will then hang for the full duration.

The real way out here is fixing the underlying problem and allow the cache entry
to complete even if the renderer isn't reading. It might be a perf win,
especially if the renderer is busy.

[jkarlin2, 2013/10/29 11:48:59]

I agree that the second reader should be able to drive the cache entry if the
first is hung/throttled.  I also think that the second request should be able to
read what's available from the cache and use it if it's cacheable.  davidben and
I are starting work on this problem.

In the meanwhile, do you prefer the 60 second value or a short one (like 3
seconds)?

On 2013/10/28 21:16:40, James Simonsen wrote:

+const int kDefaultDetachableDelayOnCancelMs = 60000;
+
 void PopulateResourceResponse(net::URLRequest* request,
                               ResourceResponse* response) {
   response->head.error_code = request->status().error();
   response->head.request_time = request->request_time();
   response->head.response_time = request->response_time();
   response->head.headers = request->response_headers();
   request->GetCharset(&response->head.charset);
   response->head.content_length = request->GetExpectedContentSize();
   request->GetMimeType(&response->head.mime_type);
   net::HttpResponseInfo response_info = request->response_info();
@@ skipping 154 matching lines @@
                           ResourceLoaderDelegate* delegate,
                           scoped_ptr<net::ClientCertStore> client_cert_store) {
   deferred_stage_ = DEFERRED_NONE;
   request_ = request.Pass();
   handler_ = handler.Pass();
   delegate_ = delegate;
   last_upload_position_ = 0;
   waiting_for_upload_progress_ack_ = false;
   is_transferring_ = false;
   client_cert_store_ = client_cert_store.Pass();
+  detachable_delay_on_cancel_ms_ = kDefaultDetachableDelayOnCancelMs;
 
   request_->set_delegate(this);
   handler_->SetController(this);
 }
 
 void ResourceLoader::OnReceivedRedirect(net::URLRequest* unused,
                                         const GURL& new_url,
                                         bool* defer) {
   DCHECK_EQ(request_.get(), unused);
 
@@ skipping 228 matching lines @@
   CancelRequest(false);
 }
 
 void ResourceLoader::StartRequestInternal() {
   DCHECK(!request_->is_pending());
   request_->Start();
 
   delegate_->DidStartRequest(this);
 }
 
+void ResourceLoader::Detach() {
+  ResourceRequestInfoImpl* info = GetRequestInfo();
+
+  if (info->is_detached())
+    return;
+  info->set_detached();
+  detached_timer_.reset(new base::OneShotTimer<ResourceLoader>());
+  detached_timer_->Start(
+      FROM_HERE, TimeDelta::FromMilliseconds(detachable_delay_on_cancel_ms_),
+      this, &ResourceLoader::Cancel);
+}
+
 void ResourceLoader::CancelRequestInternal(int error, bool from_renderer) {
   VLOG(1) << "CancelRequestInternal: " << request_->url().spec();
 
   ResourceRequestInfoImpl* info = GetRequestInfo();
 
   // WebKit will send us a cancel for downloads since it no longer handles
   // them.  In this case, ignore the cancel since we handle downloads in the
   // browser.
   if (from_renderer && (info->is_download() || info->is_stream()))
     return;
 
+  if (from_renderer && info->is_detachable()) {
+    Detach();
+    return;
+  }
+
   // TODO(darin): Perhaps we should really be looking to see if the status is
   // IO_PENDING?
   bool was_pending = request_->is_pending();
 
   if (login_delegate_.get()) {
     login_delegate_->OnRequestCancelled();
     login_delegate_ = NULL;
   }
   if (ssl_client_auth_handler_.get()) {
     ssl_client_auth_handler_->OnRequestCancelled();
@@ skipping 173 matching lines @@
     // we resume.
     deferred_stage_ = DEFERRED_FINISH;
   }
 }
 
 void ResourceLoader::CallDidFinishLoading() {
   delegate_->DidFinishLoading(this);
 }
 
 }  // namespace content