Add the ability to check the CSD Whitelist asynchronously, for PhishGuard.

components/safe_browsing_db/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 COMPONENTS_SAFE_BROWSING_DB_DATABASE_MANAGER_H_
 #define COMPONENTS_SAFE_BROWSING_DB_DATABASE_MANAGER_H_
 
 #include <set>
 #include <string>
 #include <unordered_set>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "components/safe_browsing_db/hit_report.h"
 #include "components/safe_browsing_db/util.h"
 #include "content/public/common/resource_type.h"
 #include "url/gurl.h"
 
 namespace net {
 class URLRequestContextGetter;
 }  // namespace net
 
 namespace safe_browsing {
 
+// Value returned by some Check*Whitelist() calls that may or may not have an
+// immediate answer.
+enum class AsyncMatch {
+  ASYNC,     // No answer yet -- Client will get a callback
+  MATCH,     // URL matches the list.  No callback.
+  NO_MATCH,  // URL doesn't match. No callback.
+};
+
 struct V4ProtocolConfig;
 class V4GetHashProtocolManager;
 
 // Base class to either the locally-managed or a remotely-managed database.
 class SafeBrowsingDatabaseManager
     : public base::RefCountedThreadSafe<SafeBrowsingDatabaseManager> {
  public:
   // Callers requesting a result should derive from this class.
   // The destructor should call db_manager->CancelCheck(client) if a
   // request is still pending.
@@ skipping 17 matching lines @@
                                           SBThreatType threat_type) {}
 
     // Called when the result of checking a set of extensions is known.
     virtual void OnCheckExtensionsResult(
         const std::set<std::string>& threats) {}
 
     // Called when the result of checking the resource blacklist is known.
     virtual void OnCheckResourceUrlResult(const GURL& url,
                                           SBThreatType threat_type,
                                           const std::string& threat_hash) {}
+
+    // Called when the result of checking the CSD whitelist is known.
+    virtual void OnCheckWhitelistUrlResult(bool is_whitelisted) {}

[vakh (use Gerrit instead), 2017/05/24 16:01:17]

The comment is CSD specific but the method name is not. It'd be better to make
them consistent.

[Nathan Parker, 2017/05/31 23:40:11]

Done.

   };
 
   //
   // Methods called by the client to cancel pending checks.
   //
 
   // Called on the IO thread to cancel a pending API check if the result is no
   // longer needed. Returns true if the client was found and the check
   // successfully cancelled.
   virtual bool CancelApiCheck(Client* client);
@@ skipping 68 matching lines @@
 
   //
   // Methods to synchronously check whether a URL, or full hash, or IP address
   // or a DLL file is safe.
   //
 
   // Check if the |url| matches any of the full-length hashes from the client-
   // side phishing detection whitelist.  Returns true if there was a match and
   // false otherwise.  To make sure we are conservative we will return true if
   // an error occurs.  This method must be called on the IO thread.
+  //
+  // DEPRECATED. ref: http://crbug.com/714300
   virtual bool MatchCsdWhitelistUrl(const GURL& url) = 0;
 
+  // Check if the |url| matches any of the full-length hashes from the client-
+  // side phishing detection whitelist. The 3-state return value indicates
+  // the result or that the Client will get a callback later with the result.
+  virtual AsyncMatch CheckCsdWhitelistUrl(const GURL& url, Client* client) = 0;

[vakh (use Gerrit instead), 2017/05/24 16:01:16]

Please move this declaration above to keep it sorted among the Check* method
declarations.

[Nathan Parker, 2017/05/31 23:40:11]

Done.

+
   // Check if |str| matches any of the full-length hashes from the download
   // whitelist.  Returns true if there was a match and false otherwise. To make
   // sure we are conservative we will return true if an error occurs.  This
   // method must be called on the IO thread.
   virtual bool MatchDownloadWhitelistString(const std::string& str) = 0;
 
   // Check if the |url| matches any of the full-length hashes from the download
   // whitelist.  Returns true if there was a match and false otherwise. To make
   // sure we are conservative we will return true if an error occurs.  This
   // method must be called on the IO thread.
@@ skipping 117 matching lines @@
   std::unique_ptr<V4GetHashProtocolManager> v4_get_hash_protocol_manager_;
 
  private:
   // Returns an iterator to the pending API check with the given |client|.
   ApiCheckSet::iterator FindClientApiCheck(Client* client);
 };  // class SafeBrowsingDatabaseManager
 
 }  // namespace safe_browsing
 
 #endif  // COMPONENTS_SAFE_BROWSING_DB_DATABASE_MANAGER_H_