Small: Implement CheckDownloadUrls -- not called yet.

components/safe_browsing_db/v4_local_database_manager.cc

 // Copyright 2016 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 file should not be build on Android but is currently getting built.
 // TODO(vakh): Fix that: http://crbug.com/621647
 
 #include "components/safe_browsing_db/v4_local_database_manager.h"
 
 #include <vector>
@@ skipping 45 matching lines @@
       return kLeastSeverity;
   }
 }
 
 }  // namespace
 
 V4LocalDatabaseManager::PendingCheck::PendingCheck(
     Client* client,
     ClientCallbackType client_callback_type,
     const StoresToCheck& stores_to_check,
-    const GURL& url)
+    const std::vector<GURL>& urls)
     : client(client),
       client_callback_type(client_callback_type),
       result_threat_type(SB_THREAT_TYPE_SAFE),
       stores_to_check(stores_to_check),
-      url(url) {
-  DCHECK_GT(ClientCallbackType::CHECK_MAX, client_callback_type);
-}
+      urls(urls) {}
 
 V4LocalDatabaseManager::PendingCheck::~PendingCheck() {}
 
 // static
 scoped_refptr<V4LocalDatabaseManager> V4LocalDatabaseManager::Create(
     const base::FilePath& base_path) {
   if (!V4FeatureList::IsLocalDatabaseManagerEnabled()) {
     return nullptr;
   }
 
@@ skipping 56 matching lines @@
 
 bool V4LocalDatabaseManager::CheckBrowseUrl(const GURL& url, Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!enabled_ || !CanCheckUrl(url)) {
     return true;
   }
 
   std::unique_ptr<PendingCheck> check = base::MakeUnique<PendingCheck>(
       client, ClientCallbackType::CHECK_BROWSE_URL,
-      StoresToCheck({GetUrlMalwareId(), GetUrlSocEngId(), GetUrlUwsId()}), url);
-  if (!v4_database_) {
-    queued_checks_.push_back(std::move(check));
-    return false;
-  }
+      StoresToCheck({GetUrlMalwareId(), GetUrlSocEngId(), GetUrlUwsId()}),
+      std::vector<GURL>(1, url));
 
-  FullHashToStoreAndHashPrefixesMap full_hash_to_store_and_hash_prefixes;
-  if (!GetPrefixMatches(check, &full_hash_to_store_and_hash_prefixes)) {
-    return true;
-  }
-
-  // Post the task to check full hashes back on the IO thread to follow the
-  // documented behavior of CheckBrowseUrl.
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&V4LocalDatabaseManager::PerformFullHashCheck, this,
-                 base::Passed(std::move(check)),
-                 full_hash_to_store_and_hash_prefixes));
-  return false;
+  return HandleCheck(std::move(check));
 }
 
 bool V4LocalDatabaseManager::CheckDownloadUrl(
     const std::vector<GURL>& url_chain,
     Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  // TODO(vakh): Implement this skeleton.
-  return true;
+
+  if (!enabled_ || url_chain.empty()) {
+    return true;
+  }
+
+  std::unique_ptr<PendingCheck> check = base::MakeUnique<PendingCheck>(
+      client, ClientCallbackType::CHECK_DOWNLOAD_URLS,
+      StoresToCheck({GetUrlMalBinId()}), url_chain);
+
+  return HandleCheck(std::move(check));
 }
 
 bool V4LocalDatabaseManager::CheckExtensionIDs(
     const std::set<std::string>& extension_ids,
     Client* client) {
   // TODO(vakh): Implement this skeleton.
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return true;
 }
 
@@ skipping 144 matching lines @@
   }
 }
 
 bool V4LocalDatabaseManager::GetPrefixMatches(
     const std::unique_ptr<PendingCheck>& check,
     FullHashToStoreAndHashPrefixesMap* full_hash_to_store_and_hash_prefixes) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   DCHECK(enabled_);
   DCHECK(v4_database_);
-  DCHECK_GT(ClientCallbackType::CHECK_MAX, check->client_callback_type);
   full_hash_to_store_and_hash_prefixes->clear();
 
   const base::TimeTicks before = TimeTicks::Now();
-  if (check->client_callback_type == ClientCallbackType::CHECK_BROWSE_URL) {
+  if (check->client_callback_type == ClientCallbackType::CHECK_BROWSE_URL ||
+      check->client_callback_type == ClientCallbackType::CHECK_DOWNLOAD_URLS) {
     std::unordered_set<FullHash> full_hashes;
-    V4ProtocolManagerUtil::UrlToFullHashes(check->url, &full_hashes);
+    for (const auto& url : check->urls) {
+      V4ProtocolManagerUtil::UrlToFullHashes(url, &full_hashes);
+    }
 
     StoreAndHashPrefixes matched_store_and_hash_prefixes;
     for (const auto& full_hash : full_hashes) {
       matched_store_and_hash_prefixes.clear();
       v4_database_->GetStoresMatchingFullHash(full_hash, check->stores_to_check,
                                               &matched_store_and_hash_prefixes);
       if (!matched_store_and_hash_prefixes.empty()) {
         (*full_hash_to_store_and_hash_prefixes)[full_hash] =
             matched_store_and_hash_prefixes;
       }
@@ skipping 45 matching lines @@
 SBThreatType V4LocalDatabaseManager::GetSBThreatTypeForList(
     const ListIdentifier& list_id) {
   auto it = std::find_if(
       std::begin(list_infos_), std::end(list_infos_),
       [&list_id](ListInfo const& li) { return li.list_id() == list_id; });
   DCHECK(list_infos_.end() != it);
   DCHECK_NE(SB_THREAT_TYPE_SAFE, it->sb_threat_type());
   return it->sb_threat_type();
 }
 
+bool V4LocalDatabaseManager::HandleCheck(std::unique_ptr<PendingCheck> check) {
+  if (!v4_database_) {
+    queued_checks_.push_back(std::move(check));
+    return false;
+  }
+
+  FullHashToStoreAndHashPrefixesMap full_hash_to_store_and_hash_prefixes;
+  if (!GetPrefixMatches(check, &full_hash_to_store_and_hash_prefixes)) {
+    return true;
+  }
+
+  // Post on the IO thread to enforce async behavior.
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&V4LocalDatabaseManager::PerformFullHashCheck, this,
+                 base::Passed(std::move(check)),
+                 full_hash_to_store_and_hash_prefixes));
+  return false;
+}
+
 void V4LocalDatabaseManager::OnFullHashResponse(
     std::unique_ptr<PendingCheck> pending_check,
     const std::vector<FullHashInfo>& full_hash_infos) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!enabled_) {
     DCHECK(pending_clients_.empty());
     return;
   }
 
-  auto it = pending_clients_.find(pending_check->client);
+  const auto it = pending_clients_.find(pending_check->client);
   if (it == pending_clients_.end()) {
     // The check has since been cancelled.
     return;
   }
 
   // Find out the most severe threat, if any, to report to the client.
   GetSeverestThreatTypeAndMetadata(&pending_check->result_threat_type,
                                    &pending_check->url_metadata,
                                    full_hash_infos);
   pending_clients_.erase(it);
@@ skipping 34 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (std::unique_ptr<PendingCheck>& it : queued_checks_) {
     RespondToClient(std::move(it));
   }
   queued_checks_.clear();
 }
 
 void V4LocalDatabaseManager::RespondToClient(
     std::unique_ptr<PendingCheck> check) {
   DCHECK(check.get());
-  DCHECK_GT(ClientCallbackType::CHECK_MAX, check->client_callback_type);
 
   if (check->client_callback_type == ClientCallbackType::CHECK_BROWSE_URL) {
-    check->client->OnCheckBrowseUrlResult(check->url, check->result_threat_type,
-                                          check->url_metadata);
+    DCHECK_EQ(1u, check->urls.size());
+    check->client->OnCheckBrowseUrlResult(
+        check->urls[0], check->result_threat_type, check->url_metadata);
+  } else if (check->client_callback_type ==
+             ClientCallbackType::CHECK_DOWNLOAD_URLS) {
+    check->client->OnCheckDownloadUrlResult(check->urls,
+                                            check->result_threat_type);
   } else {
     NOTREACHED() << "Unexpected client_callback_type encountered";
   }
 }
 
 void V4LocalDatabaseManager::SetupDatabase() {
   DCHECK(!base_path_.empty());
   DCHECK(!list_infos_.empty());
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ skipping 26 matching lines @@
 }
 
 void V4LocalDatabaseManager::UpdateRequestCompleted(
     std::unique_ptr<ParsedServerResponse> parsed_server_response) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   v4_database_->ApplyUpdate(std::move(parsed_server_response),
                             db_updated_callback_);
 }
 
 }  // namespace safe_browsing