[safe browsing] Remove stale BINHASH code.

chrome/browser/safe_browsing/database_manager.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 "chrome/browser/safe_browsing/database_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 38 matching lines @@
     safe_browsing_util::ListType check_type,
     const std::vector<SBFullHashResult>& full_hashes) {
   SafeBrowsingProtocolManager::ResultType result;
   if (full_hashes.empty()) {
     result = SafeBrowsingProtocolManager::GET_HASH_FULL_HASH_EMPTY;
   } else if (hit) {
     result = SafeBrowsingProtocolManager::GET_HASH_FULL_HASH_HIT;
   } else {
     result = SafeBrowsingProtocolManager::GET_HASH_FULL_HASH_MISS;
   }
-  bool is_download = check_type == safe_browsing_util::BINURL ||
-                     check_type == safe_browsing_util::BINHASH;
+  bool is_download = check_type == safe_browsing_util::BINURL;
   SafeBrowsingProtocolManager::RecordGetHashResult(is_download, result);
 }
 
 bool IsExpectedThreat(
     const SBThreatType threat_type,
     const std::vector<SBThreatType>& expected_threats) {
   return expected_threats.end() != std::find(expected_threats.begin(),
                                              expected_threats.end(),
                                              threat_type);
 }
@@ skipping 37 matching lines @@
         OnCheckDownloadUrlResult(
             check.urls,
             *std::max_element(check.url_results.begin(),
                               check.url_results.end()));
         break;
       default:
         NOTREACHED();
     }
   } else if (!check.full_hashes.empty()) {
     switch (check.check_type) {
-      case safe_browsing_util::BINHASH:
-        DCHECK_EQ(1u, check.full_hashes.size());
-        OnCheckDownloadHashResult(
-            safe_browsing_util::SBFullHashToString(check.full_hashes[0]),
-            check.full_hash_results[0]);
-        break;
       case safe_browsing_util::EXTENSIONBLACKLIST: {
         std::set<std::string> unsafe_extension_ids;
         for (size_t i = 0; i < check.full_hashes.size(); ++i) {
           std::string extension_id =
               safe_browsing_util::SBFullHashToString(check.full_hashes[i]);
           if (check.full_hash_results[i] == SB_THREAT_TYPE_EXTENSION)
             unsafe_extension_ids.insert(extension_id);
         }
         OnCheckExtensionsResult(unsafe_extension_ids);
         break;
@@ skipping 93 matching lines @@
                             safe_browsing_util::BINURL,
                             std::vector<SBThreatType>(1,
                                 SB_THREAT_TYPE_BINARY_MALWARE_URL));
   StartSafeBrowsingCheck(
       check,
       base::Bind(&SafeBrowsingDatabaseManager::CheckDownloadUrlOnSBThread, this,
                  check));
   return false;
 }
 
-bool SafeBrowsingDatabaseManager::CheckDownloadHash(
-    const std::string& full_hash,
-    Client* client) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(!full_hash.empty());
-  if (!enabled_ || !enable_download_protection_ || full_hash.empty())
-    return true;
-
-  // We need to check the database for url prefix, and later may fetch the url
-  // from the safebrowsing backends. These need to be asynchronous.
-  std::vector<SBFullHash> full_hashes(
-      1, safe_browsing_util::StringToSBFullHash(full_hash));
-  SafeBrowsingCheck* check =
-      new SafeBrowsingCheck(std::vector<GURL>(),
-                            full_hashes,
-                            client,
-                            safe_browsing_util::BINHASH,
-                            std::vector<SBThreatType>(1,
-                                SB_THREAT_TYPE_BINARY_MALWARE_HASH));
-  StartSafeBrowsingCheck(
-      check,
-      base::Bind(&SafeBrowsingDatabaseManager::CheckDownloadHashOnSBThread,this,
-                 check));
-  return false;
-}
-
 bool SafeBrowsingDatabaseManager::CheckExtensionIDs(
     const std::set<std::string>& extension_ids,
     Client* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!enabled_ || !enable_extension_blacklist_)
     return true;
 
   std::vector<SBFullHash> extension_id_hashes;
   std::transform(extension_ids.begin(), extension_ids.end(),
@@ skipping 455 matching lines @@
       GetHashRequestors requestors;
       requestors.push_back(check);
       gethash_requests_[prefix] = requestors;
     }
 
     // Reset the start time so that we can measure the network time without the
     // database time.
     check->start = base::TimeTicks::Now();
     // Note: If |this| is deleted or stopped, the protocol_manager will
     // be destroyed as well - hence it's OK to do unretained in this case.
-    bool is_download = check->check_type == safe_browsing_util::BINURL ||
-                       check->check_type == safe_browsing_util::BINHASH;
+    bool is_download = check->check_type == safe_browsing_util::BINURL;
     sb_service_->protocol_manager()->GetFullHash(
         check->prefix_hits,
         base::Bind(&SafeBrowsingDatabaseManager::HandleGetHashResults,
                    base::Unretained(this),
                    check),
         is_download);
   } else {
     // We may have cached results for previous GetHash queries.  Since
     // this data comes from cache, don't histogram hits.
     HandleOneCheck(check, check->full_hits);
@@ skipping 100 matching lines @@
   }
 
   if (safe_browsing_util::IsMalwareList(list_name)) {
     return SB_THREAT_TYPE_URL_MALWARE;
   }
 
   if (safe_browsing_util::IsBadbinurlList(list_name)) {
     return SB_THREAT_TYPE_BINARY_MALWARE_URL;
   }
 
-  if (safe_browsing_util::IsBadbinhashList(list_name)) {
-    return SB_THREAT_TYPE_BINARY_MALWARE_HASH;
-  }
-
   if (safe_browsing_util::IsExtensionList(list_name)) {
     return SB_THREAT_TYPE_EXTENSION;
   }
 
   DVLOG(1) << "Unknown safe browsing list " << list_name;
   return SB_THREAT_TYPE_SAFE;
 }
 
 void SafeBrowsingDatabaseManager::DatabaseUpdateFinished(
     bool update_succeeded) {
@@ skipping 99 matching lines @@
         IsExpectedThreat(threat, check->expected_threats)) {
       check->full_hash_results[i] = threat;
       is_threat = true;
     }
   }
 
   SafeBrowsingCheckDone(check);
   return is_threat;
 }
 
-void SafeBrowsingDatabaseManager::CheckDownloadHashOnSBThread(
-    SafeBrowsingCheck* check) {
-  DCHECK_EQ(base::MessageLoop::current(),
-            safe_browsing_thread_->message_loop());
-  DCHECK(enable_download_protection_);
-
-  DCHECK_EQ(1u, check->full_hashes.size());
-  SBFullHash full_hash = check->full_hashes[0];
-
-  if (!database_->ContainsDownloadHashPrefix(full_hash.prefix)) {
-    // Good, we don't have hash for this url prefix.
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&SafeBrowsingDatabaseManager::CheckDownloadHashDone, this,
-                   check));
-    return;
-  }
-
-  check->need_get_hash = true;
-  check->prefix_hits.push_back(full_hash.prefix);
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&SafeBrowsingDatabaseManager::OnCheckDone, this, check));
-}
-
 void SafeBrowsingDatabaseManager::CheckDownloadUrlOnSBThread(
     SafeBrowsingCheck* check) {
   DCHECK_EQ(base::MessageLoop::current(),
             safe_browsing_thread_->message_loop());
   DCHECK(enable_download_protection_);
 
   std::vector<SBPrefix> prefix_hits;
 
   if (!database_->ContainsDownloadUrl(check->urls, &prefix_hits)) {
     // Good, we don't have hash for this url prefix.
@@ skipping 54 matching lines @@
     check->client = NULL;
   }
 }
 
 void SafeBrowsingDatabaseManager::CheckDownloadUrlDone(
     SafeBrowsingCheck* check) {
   DCHECK(enable_download_protection_);
   SafeBrowsingCheckDone(check);
 }
 
-void SafeBrowsingDatabaseManager::CheckDownloadHashDone(
-    SafeBrowsingCheck* check) {
-  DCHECK(enable_download_protection_);
-  SafeBrowsingCheckDone(check);
-}
-
 void SafeBrowsingDatabaseManager::SafeBrowsingCheckDone(
     SafeBrowsingCheck* check) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(check);
 
   if (!enabled_)
     return;
 
   VLOG(1) << "SafeBrowsingCheckDone";
   DCHECK(checks_.find(check) != checks_.end());
@@ skipping 11 matching lines @@
       new base::WeakPtrFactory<SafeBrowsingDatabaseManager>(this));
   checks_.insert(check);
 
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, task);
 
   base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManager::TimeoutCallback,
                  check->timeout_factory_->GetWeakPtr(), check),
       check_timeout_);
 }