[safe browsing] Remove stale BINHASH code.

chrome/browser/safe_browsing/database_manager.h

 // 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.
 //
 // The Safe Browsing service is responsible for downloading anti-phishing and
 // anti-malware tables and checking urls against them.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_DATABASE_MANAGER_H_
 #define CHROME_BROWSER_SAFE_BROWSING_DATABASE_MANAGER_H_
 
@@ skipping 88 matching lines @@
     virtual ~Client() {}
 
     // Called when the result of checking a browse URL is known.
     virtual void OnCheckBrowseUrlResult(const GURL& url,
                                         SBThreatType threat_type) {}
 
     // Called when the result of checking a download URL is known.
     virtual void OnCheckDownloadUrlResult(const std::vector<GURL>& url_chain,
                                           SBThreatType threat_type) {}
 
-    // Called when the result of checking a download binary hash is known.
-    virtual void OnCheckDownloadHashResult(const std::string& hash,
-                                           SBThreatType threat_type) {}
-
     // Called when the result of checking a set of extensions is known.
     virtual void OnCheckExtensionsResult(
         const std::set<std::string>& threats) {}
   };
 
   // Creates the safe browsing service.  Need to initialize before using.
   explicit SafeBrowsingDatabaseManager(
       const scoped_refptr<SafeBrowsingService>& service);
 
   // Returns true if the url's scheme can be checked.
   bool CanCheckUrl(const GURL& url) const;
 
   // Returns whether download protection is enabled.
   bool download_protection_enabled() const {
     return enable_download_protection_;
   }
 
   // Called on the IO thread to check if the given url is safe or not.  If we
   // can synchronously determine that the url is safe, CheckUrl returns true.
   // Otherwise it returns false, and "client" is called asynchronously with the
   // result when it is ready.
   virtual bool CheckBrowseUrl(const GURL& url, Client* client);
 
   // Check if the prefix for |url| is in safebrowsing download add lists.
   // Result will be passed to callback in |client|.
   virtual bool CheckDownloadUrl(const std::vector<GURL>& url_chain,
                                 Client* client);
 
-  // Check if the prefix for |full_hash| is in safebrowsing binhash add lists.
-  // Result will be passed to callback in |client|.
-  virtual bool CheckDownloadHash(const std::string& full_hash, Client* client);
-
   // Check which prefixes in |extension_ids| are in the safebrowsing blacklist.
   // Returns true if not, false if further checks need to be made in which case
   // the result will be passed to |client|.
   virtual bool CheckExtensionIDs(const std::set<std::string>& extension_ids,
                                  Client* client);
 
   // Check if the given url is on the side-effect free whitelist.
   // Can be called on any thread. Returns false if the check cannot be performed
   // (e.g. because we are disabled or because of an invalid scheme in the URL).
   // Otherwise, returns true if the URL is on the whitelist based on matching
@@ skipping 160 matching lines @@
 
   // Internal worker function for processing full hashes.
   void OnHandleGetHashResults(SafeBrowsingCheck* check,
                               const std::vector<SBFullHashResult>& full_hashes);
 
   // Run one check against |full_hashes|.  Returns |true| if the check
   // finds a match in |full_hashes|.
   bool HandleOneCheck(SafeBrowsingCheck* check,
                       const std::vector<SBFullHashResult>& full_hashes);
 
-  // Checks the download hash on safe_browsing_thread_.
-  void CheckDownloadHashOnSBThread(SafeBrowsingCheck* check);
-
   // Invoked by CheckDownloadUrl. It checks the download URL on
   // safe_browsing_thread_.
   void CheckDownloadUrlOnSBThread(SafeBrowsingCheck* check);
 
   // The callback function when a safebrowsing check is timed out. Client will
   // be notified that the safebrowsing check is SAFE when this happens.
   void TimeoutCallback(SafeBrowsingCheck* check);
 
   // Calls the Client's callback on IO thread after CheckDownloadUrl finishes.
   void CheckDownloadUrlDone(SafeBrowsingCheck* check);
 
-  // Calls the Client's callback on IO thread after CheckDownloadHash finishes.
-  void CheckDownloadHashDone(SafeBrowsingCheck* check);
-
   // Checks all extension ID hashes on safe_browsing_thread_.
   void CheckExtensionIDsOnSBThread(SafeBrowsingCheck* check);
 
   // Helper function that calls safe browsing client and cleans up |checks_|.
   void SafeBrowsingCheckDone(SafeBrowsingCheck* check);
 
   // Helper function to set |check| with default values and start a safe
   // browsing check with timeout of |timeout|. |task| will be called on
   // success, otherwise TimeoutCallback will be called.
   void StartSafeBrowsingCheck(SafeBrowsingCheck* check,
@@ skipping 67 matching lines @@
 
   std::deque<QueuedCheck> queued_checks_;
 
   // Timeout to use for safe browsing checks.
   base::TimeDelta check_timeout_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingDatabaseManager);
 };
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_DATABASE_MANAGER_H_