Safe Browsing: CheckApiBlacklist request implementation

components/safe_browsing_db/database_manager.cc

 // Copyright 2015 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 "components/safe_browsing_db/database_manager.h"
 
 #include "components/safe_browsing_db/v4_get_hash_protocol_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 
 namespace safe_browsing {
 
 SafeBrowsingDatabaseManager::SafeBrowsingDatabaseManager()
     : v4_get_hash_protocol_manager_(NULL) {
 }
 
 SafeBrowsingDatabaseManager::~SafeBrowsingDatabaseManager() {
   DCHECK(v4_get_hash_protocol_manager_ == NULL);
 }
 
 void SafeBrowsingDatabaseManager::StartOnIOThread(
     net::URLRequestContextGetter* request_context_getter,
     const V4ProtocolConfig& config) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (request_context_getter) {
-    // Instantiate a V4GetHashProtocolManager.
-    v4_get_hash_protocol_manager_ = V4GetHashProtocolManager::Create(
-        request_context_getter, config);
-  }
+
+  v4_get_hash_protocol_manager_ = V4GetHashProtocolManager::Create(
+      request_context_getter, config);
 }
 
 // |shutdown| not used. Destroys the v4 protocol managers. This may be called
 // multiple times during the life of the DatabaseManager.
 // Must be called on IO thread.
 void SafeBrowsingDatabaseManager::StopOnIOThread(bool shutdown) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // This cancels all in-flight GetHash requests.
   if (v4_get_hash_protocol_manager_) {
     delete v4_get_hash_protocol_manager_;
     v4_get_hash_protocol_manager_ = NULL;
   }
+  // TODO(kcarattini): Call back clients with pending requests.
 }
 
-void SafeBrowsingDatabaseManager::CheckApiBlacklistUrl(const GURL& url,
+bool SafeBrowsingDatabaseManager::CheckApiBlacklistUrl(const GURL& url,
                                                        Client* client) {
-  // TODO(kcarattini): Implement this.
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(v4_get_hash_protocol_manager_);
+
+  // Make sure we can check this url.
+  if (!(url.SchemeIs(url::kHttpScheme) || url.SchemeIs(url::kHttpsScheme))) {
+    return true;
+  }
+
+  // Compute a list of hashes for this url.
+  std::vector<SBFullHash> full_hashes;
+  UrlToFullHashes(url, false, &full_hashes);
+  if (full_hashes.empty())
+    return true;
+
+  // Copy to prefixes.
+  std::vector<SBPrefix> prefixes;
+  for (const SBFullHash& full_hash : full_hashes) {
+    prefixes.push_back(full_hash.prefix);
+  }
+  // Multiple full hashes could share a prefix, remove duplicates.
+  std::sort(prefixes.begin(), prefixes.end());
+  prefixes.erase(std::unique(prefixes.begin(), prefixes.end()), prefixes.end());
+  DCHECK(!prefixes.empty());
+
+  // TODO(kcarattini): Track checks in a map.

[Nathan Parker, 2016/04/11 16:28:50]

Related to my CancelClient question... Should we keep these in the same
structure that tracks regular checks?  I guess that exists only in the Local* or
Remote* implementation. Hmm.

[kcarattini, 2016/04/12 01:27:02]

The SafeBorwsingCheck seems overly complicated for this API check. Also, since
here we're using the V4 server, I think they should be tracked separately frpm
the V3 serve checks.  When the old checks use the V4 server, we can look into
merging then. How does that sound?

[Nathan Parker, 2016/04/12 04:35:48]

Sounds like a plan!

+  SafeBrowsingApiCheck* check = new

[Nathan Parker, 2016/04/11 16:28:50]

Maybe a std::unique_ptr<>?

[kcarattini, 2016/04/12 01:27:02]

I need this to live past the end of this function so it is available in the
callback, I think a unique_ptr would delete the memory at the end of this
function.

[Nathan Parker, 2016/04/12 04:35:48]

Yes, but I think you can pass it into Bind() and have it pass it into another
unique_ptr... maybe with std::move()?  (I forgot the name of that and made the
mistake of googling std::pass.  That's not it.)

[kcarattini, 2016/04/12 07:47:49]

Since I plan to track this also in a map, I don't think unique_ptr is the right
thing to use (there will be multiple references to the same memory). I could
make it a shared ptr perhaps? I'm not sure how that works as a function
argument.

[kcarattini, 2016/04/13 06:13:30]

Updated to use shared_ptr. Let me know if you think that's not the right way to
handle this.

+      SafeBrowsingApiCheck(url, full_hashes, client);
+
+  // TODO(kcarattini): Implement cache compliance.
+  v4_get_hash_protocol_manager_->GetFullHashesWithApis(prefixes,
+      base::Bind(&SafeBrowsingDatabaseManager::HandleGetHashesWithApisResults,
+                 base::Unretained(this), check));
+
+  return false;
+}
+
+void SafeBrowsingDatabaseManager::HandleGetHashesWithApisResults(
+    SafeBrowsingApiCheck* check,
+    const std::vector<SBFullHashResult>& full_hash_results,
+    const base::TimeDelta& negative_cache_duration) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (check)
+    delete check;
+  // TODO(kcarattini): Implement response handler.
+}
+
+SafeBrowsingDatabaseManager::SafeBrowsingApiCheck::SafeBrowsingApiCheck(
+    const GURL& url, const std::vector<SBFullHash>& full_hashes, Client* client)
+        : url(url), full_hashes(full_hashes), client(client) {
+}
+
+SafeBrowsingDatabaseManager::SafeBrowsingApiCheck::~SafeBrowsingApiCheck() {
 }
 
 }  // namespace safe_browsing