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/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"
@@ skipping 34 matching lines @@
       request,
       &response->head.appcache_id,
       &response->head.appcache_manifest_url);
   // TODO(mmenke):  Figure out if LOAD_ENABLE_LOAD_TIMING is safe to remove.
   if (request->load_flags() & net::LOAD_ENABLE_LOAD_TIMING)
     request->GetLoadTimingInfo(&response->head.load_timing);
 }
 
 }  // namespace
 
+int ResourceLoader::default_delay_prefetch_cancel_ms_ = 60000;
+
 ResourceLoader::ResourceLoader(scoped_ptr<net::URLRequest> request,
                                scoped_ptr<ResourceHandler> handler,
                                ResourceLoaderDelegate* delegate)
     : weak_ptr_factory_(this) {
   scoped_ptr<net::ClientCertStore> client_cert_store;
 #if !defined(USE_OPENSSL)
   client_cert_store.reset(new net::ClientCertStoreImpl());
 #endif
   Init(request.Pass(), handler.Pass(), delegate, client_cert_store.Pass());
 }
@@ skipping 374 matching lines @@
   CancelRequest(false);
 }
 
 void ResourceLoader::StartRequestInternal() {
   DCHECK(!request_->is_pending());
   request_->Start();
 
   delegate_->DidStartRequest(this);
 }
 
+bool ResourceLoader::DelayCancelForPrefetch(const ResourceRequestInfoImpl& info,
+                                            bool from_renderer) {
+  // Delay requests to cancel prefetches
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  if (from_renderer &&
+      command_line.HasSwitch(switches::kDelayPrefetchCancellation) &&
+      info.GetResourceType() == ResourceType::PREFETCH) {

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

Know it doesn't really matter, but seems like checking the resource type should
go before doing a search through the map of command line flags, for performance
reasons.

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

Done.

+    if (prefetch_timer_.get() && prefetch_timer_->IsRunning()) {

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

If something is impossible, should we be checking it?  Seems like we should just
DCHECK(prefetch_timer_->IsRunning()) here instead.

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

Done.

+      // We've already processed a cancel for this prefetch, ignore this cancel.
+      return true;
+    } else if (!prefetch_timer_.get()) {

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

nit:  Here and just above, believe "if (!prefetch_timer_)" is the preferred form
(No get).  Since we support it, may as well use it.

+      // Our first call to cancel this prefetch, start a delay timer.
+      prefetch_timer_.reset(new base::OneShotTimer<ResourceLoader>());
+
+      int delay_ms;
+      if (!base::StringToInt(command_line.GetSwitchValueASCII(
+                                 switches::kDelayPrefetchCancellation),
+                             &delay_ms)) {
+        delay_ms = default_delay_prefetch_cancel_ms_;
+      }
+
+      prefetch_timer_->Start(FROM_HERE, TimeDelta::FromMilliseconds(delay_ms),
+                             this, &ResourceLoader::Cancel);
+      return true;
+    }
+  }
+  return false;
+}
+
 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 (DelayCancelForPrefetch(*info, from_renderer)) {
+    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 168 matching lines @@
     // we resume.
     deferred_stage_ = DEFERRED_FINISH;
   }
 }
 
 void ResourceLoader::CallDidFinishLoading() {
   delegate_->DidFinishLoading(this);
 }
 
 }  // namespace content