Turn off safebrowsing for PREFETCH requests

chrome/browser/renderer_host/safe_browsing_resource_handler.cc

 // Copyright (c) 2011 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 "chrome/browser/renderer_host/safe_browsing_resource_handler.h"
 
 #include "base/logging.h"
 #include "chrome/browser/renderer_host/global_request_id.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 #include "chrome/browser/renderer_host/resource_message_filter.h"
 #include "chrome/common/resource_response.h"
+#include "net/base/io_buffer.h"
+#include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
-#include "net/base/io_buffer.h"
 
 // Maximum time in milliseconds to wait for the safe browsing service to
 // verify a URL. After this amount of time the outstanding check will be
 // aborted, and the URL will be treated as if it were safe.
 static const int kCheckUrlTimeoutMs = 5000;
 
 // TODO(eroman): Downgrade these CHECK()s to DCHECKs once there is more
 //               unit test coverage.
 
 SafeBrowsingResourceHandler::SafeBrowsingResourceHandler(
@@ skipping 127 matching lines @@
 
   if (result == SafeBrowsingService::SAFE) {
     // Log how much time the safe browsing check cost us.
     base::TimeDelta pause_delta;
     pause_delta = base::TimeTicks::Now() - url_check_start_time_;
     safe_browsing_->LogPauseDelay(pause_delta);
 
     // Continue the request.
     ResumeRequest();
   } else {
+    const net::URLRequest* request = rdh_->GetURLRequest(
+        GlobalRequestID(render_process_host_id_, deferred_request_id_));
+    if (request->load_flags() & net::LOAD_PREFETCH) {
+      // Don't prefetch resources that fail safe browsing, disallow
+      // them.
+      rdh_->CancelRequest(render_process_host_id_, deferred_request_id_, false);
+      // TODO(gavinp): reevaluate fixing this if bug 73778.
+      next_handler_->OnResponseCompleted(

[lzheng, 2011/02/23 02:19:12]

I read your reply to Chris's question, but I still feel this looks a little
uncommon since (I believe) the OnResponseCompleted should be called from the
resource handler level instead of here.
I chatted with Ricardo and he believe CancelRequest should work too. Should we
dig a little deeper and see why it is not? (I am adding Ricardo here to provide
more knowledge).

[rvargas (doing something else), 2011/02/23 03:49:51]

I see what's going on here. The problem is that URLRequest::Cancel is meant to
cancel a pending operation, and it triggers an asynchronous action (the job
completes whatever it is doing and invokes the callback). If the request has not
started yet, the job is not killed and no callback is performed, so RDH doesn't
get the OnResponseCompleted signal, and the handlers are not notified about it.

So... the RDH should verify if the request will trigger a callback or not, and
inform the handlers about the request being cancelled regardless of the state of
the request (the same check is performed on other RDH methods).

[gavinp, 2011/03/07 23:26:40]

OMG, Thanks for setting my head straight.

I've now added a fix in resource_dispatcher_host which I think does it, but I'd
very much like your option.

+          deferred_request_id_,
+          net::URLRequestStatus(net::URLRequestStatus::FAILED, net::ERR_ABORTED),

[lzheng, 2011/02/23 02:19:12]

80 chars.

[gavinp, 2011/03/07 23:26:40]

Done.

+          std::string());
+      return;

[lzheng, 2011/02/23 02:19:12]

Can't return here without calling Release. How about use else to wrap
StartDisplayingBlockingPage() below so Release will always be the last
statement?

[gavinp, 2011/03/07 23:26:40]

Done.

+    }
     StartDisplayingBlockingPage(url, result);
   }
 
   Release();  // Balances the AddRef() in CheckingUrl().
 }
 
 void SafeBrowsingResourceHandler::StartDisplayingBlockingPage(
     const GURL& url,
     SafeBrowsingService::UrlCheckResult result) {
   CHECK(state_ == STATE_NONE);
@@ skipping 126 matching lines @@
     rdh_->FollowDeferredRedirect(render_process_host_id_, request_id,
                                  false, GURL());
   }
 }
 
 void SafeBrowsingResourceHandler::ClearDeferredRequestInfo() {
   deferred_request_id_ = -1;
   deferred_url_ = GURL();
   deferred_redirect_response_ = NULL;
 }