Turn off safebrowsing for PREFETCH requests

chrome/browser/safe_browsing/safe_browsing_service_browsertest.cc

 // Copyright (c) 2010 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.
 //
 // This test creates a safebrowsing service using test safebrowsing database
 // and a test protocol manager. It is used to test logics in safebrowsing
 // service.
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
@@ skipping 363 matching lines @@
   // we should see the interstitial page.
   SBFullHashResult malware_full_hash;
   int chunk_id = 0;
   GenUrlFullhashResult(url, safe_browsing_util::kMalwareList, chunk_id,
                        &malware_full_hash);
   SetupResponseForUrl(url, malware_full_hash);
   ui_test_utils::NavigateToURL(browser(), url);
   EXPECT_TRUE(ShowingInterstitialPage());
 }
 
+const char kPrefetchMalwarePage[] = "files/safe_browsing/prefetch_malware.html";
+
+// This test confirms that prefetches don't themselves get the
+// interstitial treatment.
+IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, Prefetch) {
+  GURL url = test_server()->GetURL(kPrefetchMalwarePage);
+  GURL malware_url = test_server()->GetURL(kMalwarePage);
+
+  class SetPrefetchForTest {
+   public:
+    explicit SetPrefetchForTest(bool prefetch)
+        : old_prefetch_state_(ResourceDispatcherHost::is_prefetch_enabled()) {
+      ResourceDispatcherHost::set_is_prefetch_enabled(prefetch);
+    }
+
+    ~SetPrefetchForTest() {
+      ResourceDispatcherHost::set_is_prefetch_enabled(old_prefetch_state_);
+    }
+   private:
+    bool old_prefetch_state_;
+  } set_prefetch_for_test(true);
+
+  // Even though we have added this uri to the safebrowsing database and
+  // getfullhash result, we should not see the interstitial page since the
+  // only malware was a prefetch target.
+  SBFullHashResult malware_full_hash;
+  int chunk_id = 0;
+  GenUrlFullhashResult(malware_url, safe_browsing_util::kMalwareList,
+                       chunk_id, &malware_full_hash);
+  SetupResponseForUrl(malware_url, malware_full_hash);
+  ui_test_utils::NavigateToURL(browser(), url);
+  EXPECT_FALSE(ShowingInterstitialPage());
+
+  // However, when we navigate to the malware page, we should still get
+  // the interstitial.
+  ui_test_utils::WindowedNotificationObserver signal(
+      NotificationType::LOAD_STOP,
+      Source<NavigationController>(
+          &browser()->GetSelectedTabContents()->controller()));
+  browser()->OpenURL(malware_url, GURL(), CURRENT_TAB, PageTransition::TYPED);
+  signal.Wait();

[gavinp, 2011/03/08 22:33:04]

I use the WindowedNotificationObserver here, instead of calling
ui_test_utils::NavigateToURL to avoid a race in ui_test_utils::NavigateToURL, I
was reliably hitting here.  I don't want to land this issue until I fix
ui_test_utils::NavigateToURL, but I did want to show this new aspect to this
test.

+
+  EXPECT_TRUE(ShowingInterstitialPage());
+}
+
 }  // namespace
 
 class TestSBClient
     : public base::RefCountedThreadSafe<TestSBClient>,
       public SafeBrowsingService::Client {
  public:
   TestSBClient() : result_(SafeBrowsingService::SAFE),
                    safe_browsing_service_(g_browser_process->
                                           resource_dispatcher_host()->
                                           safe_browsing_service()) {
@@ skipping 162 matching lines @@
   client->CheckDownloadHash(full_hash);
 
   // There should be a timeout and the hash would be considered as safe.
   EXPECT_EQ(SafeBrowsingService::SAFE, client->GetResult());
 
   // Need to set the timeout back to the default value.
   SetDownloadHashCheckTimeout(sb_service, default_hashcheck_timeout);
 }
 
 }  // namespace