If we show a SafeBrowsing warning we always send the client-side detection

chrome/browser/safe_browsing/safe_browsing_service_browsertest.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.
 //
 // 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/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "crypto/sha2.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/in_process_browser_test.h"
 #include "chrome/test/ui_test_utils.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
+#include "testing/gmock/include/gmock/gmock.h"
 
 using base::Histogram;
 using base::StatisticsRecorder;
 
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::StrictMock;
+
 // A SafeBrowingDatabase class that allows us to inject the malicious URLs.
 class TestSafeBrowsingDatabase :  public SafeBrowsingDatabase {
  public:
   TestSafeBrowsingDatabase() {}
 
   virtual ~TestSafeBrowsingDatabase() {}
 
   // Initializes the database with the given filename.
   virtual void Init(const FilePath& filename) {}
 
@@ skipping 203 matching lines @@
     return pm_;
   }
   TestProtocolManager* GetProtocolManager() {
     return pm_;
   }
  private:
   // Owned by the SafebrowsingService.
   TestProtocolManager* pm_;
 };
 
+class MockObserver : public SafeBrowsingService::Observer {
+ public:
+  MockObserver() {}
+  virtual ~MockObserver() {}
+  MOCK_METHOD1(OnSafeBrowsingHit,
+               void(const SafeBrowsingService::UnsafeResource&));
+};
+
+MATCHER_P(IsUnsafeResourceFor, url, "") {
+  return (arg.url.spec() == url.spec() &&
+          arg.threat_type != SafeBrowsingService::SAFE);
+}
+
 // Tests the safe browsing blocking page in a browser.
 class SafeBrowsingServiceTest : public InProcessBrowserTest {
  public:
   SafeBrowsingServiceTest() {
   }
 
   static void GenUrlFullhashResult(const GURL& url,
                                    const std::string& list_name,
                                    int add_chunk_id,
                                    SBFullHashResult* full_hash) {
@@ skipping 91 matching lines @@
   }
 
   void SetDownloadUrlCheckTimeout(SafeBrowsingService* sb_service, int64 ms) {
     sb_service->download_urlcheck_timeout_ms_ = ms;
   }
 
   void SetDownloadHashCheckTimeout(SafeBrowsingService* sb_service, int64 ms) {
     sb_service->download_hashcheck_timeout_ms_ = ms;
   }
 
+ protected:
+  StrictMock<MockObserver> observer_;
+
  private:
   TestSafeBrowsingDatabaseFactory db_factory_;
   TestSBProtocolManagerFactory pm_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServiceTest);
 };
 
 namespace {
 
 const char kEmptyPage[] = "files/empty.html";
 const char kMalwareFile[] = "files/downloads/dangerous/dangerous.exe";
 const char kMalwareIframe[] = "files/safe_browsing/malware_iframe.html";
 const char kMalwarePage[] = "files/safe_browsing/malware.html";
 
 // This test goes through DownloadResourceHandler.
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, Malware) {
   GURL url = test_server()->GetURL(kEmptyPage);
+  g_browser_process->safe_browsing_service()->AddObserver(&observer_);
 
   // After adding the url to safebrowsing database and getfullhash result,
   // 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);
+  EXPECT_CALL(observer_, OnSafeBrowsingHit(IsUnsafeResourceFor(url))).Times(1);
   SetupResponseForUrl(url, malware_full_hash);
   ui_test_utils::NavigateToURL(browser(), url);
   EXPECT_TRUE(ShowingInterstitialPage());
+  g_browser_process->safe_browsing_service()->RemoveObserver(&observer_);
 }
 
 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);
+  g_browser_process->safe_browsing_service()->AddObserver(&observer_);
 
   class SetPrefetchForTest {
    public:
     explicit SetPrefetchForTest(bool prefetch)
         : old_prefetch_state_(ResourceDispatcherHost::is_prefetch_enabled()),
           old_prerender_mode_(prerender::PrerenderManager::GetMode()) {
       ResourceDispatcherHost::set_is_prefetch_enabled(prefetch);
       prerender::PrerenderManager::SetMode(
           prerender::PrerenderManager::PRERENDER_MODE_DISABLED);
     }
 
     ~SetPrefetchForTest() {
       ResourceDispatcherHost::set_is_prefetch_enabled(old_prefetch_state_);
       prerender::PrerenderManager::SetMode(old_prerender_mode_);
     }
    private:
     bool old_prefetch_state_;
     prerender::PrerenderManager::PrerenderManagerMode old_prerender_mode_;
   } 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);
+  EXPECT_CALL(observer_, OnSafeBrowsingHit(_)).Times(0);

[mattm, 2011/07/19 21:25:55]

Is this unnecessary due to using StrictMock?

[noelutz, 2011/07/19 22:28:08]

Done.

   ui_test_utils::NavigateToURL(browser(), url);
   EXPECT_FALSE(ShowingInterstitialPage());
+  Mock::VerifyAndClear(&observer_);
 
   // However, when we navigate to the malware page, we should still get
   // the interstitial.
+  EXPECT_CALL(observer_, OnSafeBrowsingHit(IsUnsafeResourceFor(malware_url)))
+      .Times(1);
   ui_test_utils::NavigateToURL(browser(), malware_url);
   EXPECT_TRUE(ShowingInterstitialPage());
+  Mock::VerifyAndClear(&observer_);
+  g_browser_process->safe_browsing_service()->RemoveObserver(&observer_);
 }
 
 }  // namespace
 
 class TestSBClient
     : public base::RefCountedThreadSafe<TestSBClient>,
       public SafeBrowsingService::Client {
  public:
   TestSBClient() : result_(SafeBrowsingService::SAFE),
                    safe_browsing_service_(g_browser_process->
@@ skipping 190 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