[safe browsing] Remove stale BINHASH code.

chrome/browser/safe_browsing/safe_browsing_service_browsertest.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.
 //
 // 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 <algorithm>
 
@@ skipping 81 matching lines @@
     std::vector<GURL> urls(1, url);
     return ContainsUrl(safe_browsing_util::kMalwareList,
                        safe_browsing_util::kPhishingList,
                        urls, prefix_hits, full_hits);
   }
   virtual bool ContainsDownloadUrl(
       const std::vector<GURL>& urls,
       std::vector<SBPrefix>* prefix_hits) OVERRIDE {
     std::vector<SBFullHashResult> full_hits;
     bool found = ContainsUrl(safe_browsing_util::kBinUrlList,
-                             safe_browsing_util::kBinHashList,
+                             safe_browsing_util::kBinUrlList,
                              urls, prefix_hits, &full_hits);
     if (!found)
       return false;
     DCHECK_LE(1U, prefix_hits->size());
     return true;
   }
-  virtual bool ContainsDownloadHashPrefix(const SBPrefix& prefix) OVERRIDE {
-    return download_digest_prefix_.count(prefix) > 0;
-  }
   virtual bool ContainsCsdWhitelistedUrl(const GURL& url) OVERRIDE {
     return true;
   }
   virtual bool ContainsDownloadWhitelistedString(
       const std::string& str) OVERRIDE {
     return true;
   }
   virtual bool ContainsDownloadWhitelistedUrl(const GURL& url) OVERRIDE {
     return true;
   }
@@ skipping 492 matching lines @@
   }
 
   void CheckDownloadUrl(const std::vector<GURL>& url_chain) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&TestSBClient::CheckDownloadUrlOnIOThread,
                    this, url_chain));
     content::RunMessageLoop();  // Will stop in OnCheckDownloadUrlResult.
   }
 
-  void CheckDownloadHash(const std::string& full_hash) {
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&TestSBClient::CheckDownloadHashOnIOThread,
-                   this, full_hash));
-    content::RunMessageLoop();  // Will stop in OnCheckDownloadHashResult.
-  }
-
  private:
   friend class base::RefCountedThreadSafe<TestSBClient>;
   virtual ~TestSBClient() {}
 
   void CheckDownloadUrlOnIOThread(const std::vector<GURL>& url_chain) {
     safe_browsing_service_->database_manager()->
         CheckDownloadUrl(url_chain, this);
   }
 
-  void CheckDownloadHashOnIOThread(const std::string& full_hash) {
-    safe_browsing_service_->database_manager()->
-        CheckDownloadHash(full_hash, this);
-  }
-
   // Called when the result of checking a download URL is known.
   virtual void OnCheckDownloadUrlResult(const std::vector<GURL>& url_chain,
                                         SBThreatType threat_type) OVERRIDE {
     threat_type_ = threat_type;
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(&TestSBClient::DownloadCheckDone, this));
   }
 
-  // Called when the result of checking a download hash is known.
-  virtual void OnCheckDownloadHashResult(const std::string& hash,
-                                         SBThreatType threat_type) OVERRIDE {
-    threat_type_ = threat_type;
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                            base::Bind(&TestSBClient::DownloadCheckDone, this));
-  }
-
   void DownloadCheckDone() {
     base::MessageLoopForUI::current()->Quit();
   }
 
   SBThreatType threat_type_;
   SafeBrowsingService* safe_browsing_service_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSBClient);
 };
 
@@ skipping 43 matching lines @@
   GenUrlFullhashResult(badbin_url, safe_browsing_util::kBinUrlList,
                        chunk_id, &full_hash_result);
   SetupResponseForUrl(badbin_url, full_hash_result);
 
   client->CheckDownloadUrl(badbin_urls);
 
   // Now, the badbin_url is not safe since it is added to download database.
   EXPECT_EQ(SB_THREAT_TYPE_BINARY_MALWARE_URL, client->GetThreatType());
 }
 
-IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, CheckDownloadHash) {
-  const std::string full_hash = "12345678902234567890323456789012";
-
-  scoped_refptr<TestSBClient> client(new TestSBClient);
-  client->CheckDownloadHash(full_hash);
-
-  // Since badbin_url is not in database, it is considered to be safe.
-  EXPECT_EQ(SB_THREAT_TYPE_SAFE, client->GetThreatType());
-
-  SBFullHashResult full_hash_result;
-  int chunk_id = 0;
-  GenDigestFullhashResult(full_hash, safe_browsing_util::kBinHashList,
-                          chunk_id, &full_hash_result);
-  SetupResponseForDigest(full_hash, full_hash_result);
-
-  client->CheckDownloadHash(full_hash);
-
-  // Now, the badbin_url is not safe since it is added to download database.
-  EXPECT_EQ(SB_THREAT_TYPE_BINARY_MALWARE_HASH, client->GetThreatType());
-}
-
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, CheckDownloadUrlTimedOut) {
   GURL badbin_url = test_server()->GetURL(kMalwareFile);
   std::vector<GURL> badbin_urls(1, badbin_url);
 
   scoped_refptr<TestSBClient> client(new TestSBClient);
   SBFullHashResult full_hash_result;
   int chunk_id = 0;
   GenUrlFullhashResult(badbin_url, safe_browsing_util::kBinUrlList,
                        chunk_id, &full_hash_result);
   SetupResponseForUrl(badbin_url, full_hash_result);
@@ skipping 12 matching lines @@
   SetCheckTimeout(sb_service, base::TimeDelta::FromMilliseconds(1));
   client->CheckDownloadUrl(badbin_urls);
 
   // There should be a timeout and the hash would be considered as safe.
   EXPECT_EQ(SB_THREAT_TYPE_SAFE, client->GetThreatType());
 
   // Need to set the timeout back to the default value.
   SetCheckTimeout(sb_service, default_urlcheck_timeout);
 }
 
-IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, CheckDownloadHashTimedOut) {
-  const std::string full_hash = "12345678902234567890323456789012";
-
-  scoped_refptr<TestSBClient> client(new TestSBClient);
-  SBFullHashResult full_hash_result;
-  int chunk_id = 0;
-  GenDigestFullhashResult(full_hash, safe_browsing_util::kBinHashList,
-                          chunk_id, &full_hash_result);
-  SetupResponseForDigest(full_hash, full_hash_result);
-  client->CheckDownloadHash(full_hash);
-
-  // The badbin_url is not safe since it is added to download database.
-  EXPECT_EQ(SB_THREAT_TYPE_BINARY_MALWARE_HASH, client->GetThreatType());
-
-  //
-  // Now introducing delays and we should hit timeout.
-  //
-  SafeBrowsingService* sb_service = g_browser_process->safe_browsing_service();
-  base::TimeDelta default_hashcheck_timeout =
-      GetCheckTimeout(sb_service);
-  IntroduceGetHashDelay(base::TimeDelta::FromSeconds(1));
-  SetCheckTimeout(sb_service, base::TimeDelta::FromMilliseconds(1));
-  client->CheckDownloadHash(full_hash);
-
-  // There should be a timeout and the hash would be considered as safe.
-  EXPECT_EQ(SB_THREAT_TYPE_SAFE, client->GetThreatType());
-
-  // Need to set the timeout back to the default value.
-  SetCheckTimeout(sb_service, default_hashcheck_timeout);
-}
-
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, StartAndStop) {
   CreateCSDService();
   SafeBrowsingService* sb_service = g_browser_process->safe_browsing_service();
   safe_browsing::ClientSideDetectionService* csd_service =
       sb_service->safe_browsing_detection_service();
   PrefService* pref_service = browser()->profile()->GetPrefs();
 
   ASSERT_TRUE(sb_service != NULL);
   ASSERT_TRUE(csd_service != NULL);
   ASSERT_TRUE(pref_service != NULL);
@@ skipping 232 matching lines @@
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
       content::Source<SafeBrowsingDatabaseManager>(
           sb_service_->database_manager().get()));
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManagerCookieTest::ForceUpdate, this));
   observer.Wait();
 }