Add the missing callback to client for CheckResourceUrl.

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 221 matching lines @@
     return true;
   }
 
   std::unique_ptr<PendingCheck> check = base::MakeUnique<PendingCheck>(
       client, ClientCallbackType::CHECK_EXTENSION_IDS,
       StoresToCheck({GetChromeExtMalwareId()}), extension_ids);
 
   return HandleCheck(std::move(check));
 }
 
 bool V4LocalDatabaseManager::CheckResourceUrl(const GURL& url, Client* client) {

[Nathan Parker, 2017/01/11 00:13:35]

How about a unit test for this?

[vakh (use Gerrit instead), 2017/01/11 20:54:34]

Done.

   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   StoresToCheck stores_to_check({GetChromeUrlClientIncidentId()});
 
   if (!CanCheckUrl(url) || !AreStoresAvailableNow(stores_to_check)) {
     // Fail open: Mark resource as safe immediately.
     // TODO(nparker): This should queue the request if the DB isn't yet
     // loaded, and later decide if this store is available.
     // Currently this is the only store that requires full-hash-checks
     // AND isn't supported on Chromium, so it's unique.
@@ skipping 230 matching lines @@
   UMA_HISTOGRAM_TIMES("SB2.FilterCheck", diff);
   UMA_HISTOGRAM_CUSTOM_TIMES("SafeBrowsing.V4GetPrefixMatches.Time", diff,
                              base::TimeDelta::FromMicroseconds(20),
                              base::TimeDelta::FromSeconds(1), 50);
   return !full_hash_to_store_and_hash_prefixes->empty();
 }
 
 void V4LocalDatabaseManager::GetSeverestThreatTypeAndMetadata(
     SBThreatType* result_threat_type,
     ThreatMetadata* metadata,
+    FullHash* matching_full_hash,
     const std::vector<FullHashInfo>& full_hash_infos) {
   DCHECK(result_threat_type);
   DCHECK(metadata);
+  DCHECK(matching_full_hash);
 
   ThreatSeverity most_severe_yet = kLeastSeverity;
   for (const FullHashInfo& fhi : full_hash_infos) {
     ThreatSeverity severity = GetThreatSeverity(fhi.list_id);
     if (severity < most_severe_yet) {
       most_severe_yet = severity;
       *result_threat_type = GetSBThreatTypeForList(fhi.list_id);
       *metadata = fhi.metadata;
+      *matching_full_hash = fhi.full_hash;
     }
   }
 }
 
 StoresToCheck V4LocalDatabaseManager::GetStoresForFullHashRequests() {
   StoresToCheck stores_for_full_hash;
   for (auto it : list_infos_) {
     stores_for_full_hash.insert(it.list_id());
   }
   return stores_for_full_hash;
@@ skipping 74 matching lines @@
   }
 
   const auto it = pending_checks_.find(check.get());
   if (it == pending_checks_.end()) {
     // The check has since been cancelled.
     return;
   }
 
   // Find out the most severe threat, if any, to report to the client.
   GetSeverestThreatTypeAndMetadata(&check->result_threat_type,
-                                   &check->url_metadata, full_hash_infos);
+                                   &check->url_metadata,
+                                   &check->matching_full_hash, full_hash_infos);
   pending_checks_.erase(it);
   RespondToClient(std::move(check));
 }
 
 void V4LocalDatabaseManager::PerformFullHashCheck(
     std::unique_ptr<PendingCheck> check,
     const FullHashToStoreAndHashPrefixesMap&
         full_hash_to_store_and_hash_prefixes) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ skipping 46 matching lines @@
         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 if (check->client_callback_type ==
              ClientCallbackType::CHECK_EXTENSION_IDS) {
     const std::set<FullHash> extension_ids(check->full_hashes.begin(),
                                            check->full_hashes.end());
     check->client->OnCheckExtensionsResult(extension_ids);
+  } else if (check->client_callback_type ==
+             ClientCallbackType::CHECK_RESOURCE_URL) {
+    DCHECK_EQ(1u, check->urls.size());
+    check->client->OnCheckResourceUrlResult(
+        check->urls[0], check->result_threat_type, check->matching_full_hash);
   } else {
     NOTREACHED() << "Unexpected client_callback_type encountered";
   }
 }
 
 void V4LocalDatabaseManager::SetupDatabase() {
   DCHECK(!base_path_.empty());
   DCHECK(!list_infos_.empty());
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ skipping 32 matching lines @@
                             db_updated_callback_);
 }
 
 bool V4LocalDatabaseManager::AreStoresAvailableNow(
     const StoresToCheck& stores_to_check) const {
   return enabled_ && v4_database_ &&
          v4_database_->AreStoresAvailable(stores_to_check);
 }
 
 }  // namespace safe_browsing