Safebrowsing: Honor the metadata from malware fullhash results in SB API 3.0.

chrome/browser/safe_browsing/database_manager.cc

 // 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.
 
 #include "chrome/browser/safe_browsing/database_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 54 matching lines @@
     const std::vector<SBThreatType>& expected_threats) {
   return expected_threats.end() != std::find(expected_threats.begin(),
                                              expected_threats.end(),
                                              threat_type);
 }
 
 // Return the list id from the first result in |full_hashes| which matches
 // |hash|, or INVALID if none match.
 safe_browsing_util::ListType GetHashThreatListType(
     const SBFullHash& hash,
-    const std::vector<SBFullHashResult>& full_hashes) {
+    const std::vector<SBFullHashResult>& full_hashes,
+    size_t* index) {
   for (size_t i = 0; i < full_hashes.size(); ++i) {
-    if (SBFullHashEqual(hash, full_hashes[i].hash))
+    if (SBFullHashEqual(hash, full_hashes[i].hash)) {
+      if (index)
+        *index = i;
       return static_cast<safe_browsing_util::ListType>(full_hashes[i].list_id);
+    }
   }
   return safe_browsing_util::INVALID;
 }
 
 // Given a URL, compare all the possible host + path full hashes to the set of
 // provided full hashes.  Returns the list id of the a matching result from
 // |full_hashes|, or INVALID if none match.
 safe_browsing_util::ListType GetUrlThreatListType(
     const GURL& url,
-    const std::vector<SBFullHashResult>& full_hashes) {
+    const std::vector<SBFullHashResult>& full_hashes,
+    size_t* index) {
   if (full_hashes.empty())
     return safe_browsing_util::INVALID;
 
   std::vector<std::string> patterns;
   safe_browsing_util::GeneratePatternsToCheck(url, &patterns);
 
   for (size_t i = 0; i < patterns.size(); ++i) {
-    safe_browsing_util::ListType threat =
-        GetHashThreatListType(SBFullHashForString(patterns[i]), full_hashes);
+    safe_browsing_util::ListType threat = GetHashThreatListType(
+        SBFullHashForString(patterns[i]), full_hashes, index);
     if (threat != safe_browsing_util::INVALID)
       return threat;
   }
   return safe_browsing_util::INVALID;
 }
 
 SBThreatType GetThreatTypeFromListType(safe_browsing_util::ListType list_type) {
   switch (list_type) {
     case safe_browsing_util::PHISH:
       return SB_THREAT_TYPE_URL_PHISHING;
     case safe_browsing_util::MALWARE:
       return SB_THREAT_TYPE_URL_MALWARE;
     case safe_browsing_util::BINURL:
       return SB_THREAT_TYPE_BINARY_MALWARE_URL;
     case safe_browsing_util::EXTENSIONBLACKLIST:
       return SB_THREAT_TYPE_EXTENSION;
     default:
       DVLOG(1) << "Unknown safe browsing list id " << list_type;
       return SB_THREAT_TYPE_SAFE;
   }
 }
 
 }  // namespace
 
 // static
 SBThreatType SafeBrowsingDatabaseManager::GetHashThreatType(
     const SBFullHash& hash,
     const std::vector<SBFullHashResult>& full_hashes) {
-  return GetThreatTypeFromListType(GetHashThreatListType(hash, full_hashes));
+  return GetThreatTypeFromListType(
+      GetHashThreatListType(hash, full_hashes, NULL));
 }
 
 // static
 SBThreatType SafeBrowsingDatabaseManager::GetUrlThreatType(
     const GURL& url,
-    const std::vector<SBFullHashResult>& full_hashes) {
-  return GetThreatTypeFromListType(GetUrlThreatListType(url, full_hashes));
+    const std::vector<SBFullHashResult>& full_hashes,
+    size_t* index) {
+  return GetThreatTypeFromListType(
+      GetUrlThreatListType(url, full_hashes, index));
 }
 
 SafeBrowsingDatabaseManager::SafeBrowsingCheck::SafeBrowsingCheck(
     const std::vector<GURL>& urls,
     const std::vector<SBFullHash>& full_hashes,
     Client* client,
     safe_browsing_util::ListType check_type,
     const std::vector<SBThreatType>& expected_threats)
     : urls(urls),
       url_results(urls.size(), SB_THREAT_TYPE_SAFE),
+      url_metadata(urls.size()),
       full_hashes(full_hashes),
       full_hash_results(full_hashes.size(), SB_THREAT_TYPE_SAFE),
       client(client),
       need_get_hash(false),
       check_type(check_type),
       expected_threats(expected_threats) {
   DCHECK_EQ(urls.empty(), !full_hashes.empty())
       << "Exactly one of urls and full_hashes must be set";
 }
 
 SafeBrowsingDatabaseManager::SafeBrowsingCheck::~SafeBrowsingCheck() {}
 
 void SafeBrowsingDatabaseManager::Client::OnSafeBrowsingResult(
     const SafeBrowsingCheck& check) {
   DCHECK_EQ(check.urls.size(), check.url_results.size());
   DCHECK_EQ(check.full_hashes.size(), check.full_hash_results.size());
   if (!check.urls.empty()) {
     DCHECK(check.full_hashes.empty());
     switch (check.check_type) {
       case safe_browsing_util::MALWARE:
       case safe_browsing_util::PHISH:
         DCHECK_EQ(1u, check.urls.size());
-        OnCheckBrowseUrlResult(check.urls[0], check.url_results[0]);
+        OnCheckBrowseUrlResult(
+            check.urls[0], check.url_results[0], check.url_metadata[0]);
         break;
       case safe_browsing_util::BINURL:
         DCHECK_EQ(check.urls.size(), check.url_results.size());
         OnCheckDownloadUrlResult(
             check.urls,
             *std::max_element(check.url_results.begin(),
                               check.url_results.end()));
         break;
       default:
         NOTREACHED();
@@ skipping 758 matching lines @@
   // here concerns me.  It is likely that SAFE is an expected outcome, which
   // means all of those loops run to completion.  Refactoring this to generate a
   // set of sorted items to compare in sequence would probably improve things.
   //
   // Additionally, the set of patterns generated from the urls is very similar
   // to the patterns generated in ContainsBrowseUrl() and other database checks,
   // which are called from this code.  Refactoring that across the checks could
   // interact well with batching the checks here.
 
   for (size_t i = 0; i < check->urls.size(); ++i) {
-    SBThreatType threat = GetUrlThreatType(check->urls[i], full_hashes);
+    size_t threat_index;
+    SBThreatType threat =
+        GetUrlThreatType(check->urls[i], full_hashes, &threat_index);
     if (threat != SB_THREAT_TYPE_SAFE &&
         IsExpectedThreat(threat, check->expected_threats)) {
       check->url_results[i] = threat;
+      check->url_metadata[i] = full_hashes[threat_index].metadata;
       is_threat = true;
     }
   }
 
   for (size_t i = 0; i < check->full_hashes.size(); ++i) {
     SBThreatType threat = GetHashThreatType(check->full_hashes[i], full_hashes);
     if (threat != SB_THREAT_TYPE_SAFE &&
         IsExpectedThreat(threat, check->expected_threats)) {
       check->full_hash_results[i] = threat;
       is_threat = true;
@@ skipping 102 matching lines @@
       new base::WeakPtrFactory<SafeBrowsingDatabaseManager>(this));
   checks_.insert(check);
 
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, task);
 
   base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManager::TimeoutCallback,
                  check->timeout_factory_->GetWeakPtr(), check),
       check_timeout_);
 }