Store list information in ListInfo (was: StoreIdAndFIleName)

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>
 
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace safe_browsing {
 
 namespace {
 
 const ThreatSeverity kLeastSeverity =
     std::numeric_limits<ThreatSeverity>::max();
 
 // TODO(vakh): Implement this to populate the vector appopriately.
 // Filed as http://crbug.com/608075
 // Any stores added/removed to/from here likely need an update in
-// GetSBThreatTypeForList and GetThreatSeverity.
+// GetThreatSeverity.
 // TODO(vakh): Add a compile-time check or DCHECK to enforce this.
 StoreIdAndFileNames GetStoreIdAndFileNames() {
   return StoreIdAndFileNames(
       {StoreIdAndFileName(GetUrlMalwareId(), "UrlMalware.store"),
        StoreIdAndFileName(GetUrlSocEngId(), "UrlSoceng.store")});
 }
 
 // Returns the SBThreatType corresponding to a given SafeBrowsing list.
 SBThreatType GetSBThreatTypeForList(const ListIdentifier& list_id) {
-  if (list_id == GetChromeUrlApiId()) {
-    return SB_THREAT_TYPE_API_ABUSE;
-  } else if (list_id == GetUrlMalwareId()) {
-    return SB_THREAT_TYPE_URL_MALWARE;
-  } else if (list_id == GetUrlSocEngId()) {
-    return SB_THREAT_TYPE_URL_PHISHING;
-  } else {
-    NOTREACHED() << "Unknown list encountered in GetSBThreatTypeForList";
-    return SB_THREAT_TYPE_SAFE;
-  }
+  SBThreatType sb_threat_type = list_id.sb_threat_type();
+  DCHECK_NE(SB_THREAT_TYPE_SAFE, sb_threat_type);
+  return sb_threat_type;
 }
 
 // Returns the severity information about a given SafeBrowsing list. The lowest
 // value is 0, which represents the most severe list.
 ThreatSeverity GetThreatSeverity(const ListIdentifier& list_id) {
-  switch (list_id.threat_type) {
+  switch (list_id.threat_type()) {
     case MALWARE_THREAT:
     case SOCIAL_ENGINEERING_PUBLIC:
       return 0;
     case API_ABUSE:
       return 1;
     default:
       NOTREACHED() << "Unexpected ThreatType encountered in GetThreatSeverity";
       return kLeastSeverity;
   }
 }
@@ skipping 148 matching lines @@
       }
     }
 
     if (full_hash_to_store_and_hash_prefixes.empty()) {
       return true;
     } else {
       std::unique_ptr<PendingCheck> pending_check =
           base::MakeUnique<PendingCheck>(
               client, ClientCallbackType::CHECK_BROWSE_URL, url);
 
+      pending_clients_.insert(client);
+
       v4_get_hash_protocol_manager_->GetFullHashes(
           full_hash_to_store_and_hash_prefixes,
           base::Bind(&V4LocalDatabaseManager::OnFullHashResponse,
                      base::Unretained(this), base::Passed(&pending_check)));
 
-      pending_clients_.insert(client);
-
       return false;
     }
   } else {
     // TODO(vakh): Queue the check and process it when the database becomes
     // ready.
     return false;
   }
 }
 
 // static
@@ skipping 24 matching lines @@
     DCHECK(pending_clients_.empty());
     return;
   }
 
   auto it = pending_clients_.find(pending_check->client);
   if (it == pending_clients_.end()) {
     // The check has since been cancelled.
     return;
   }
 
-  if (full_hash_infos.empty()) {
-    // The resource is not known to be unsafe. Respond right away.
-    RespondToClient(std::move(pending_check));
-    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);
-
   RespondToClient(std::move(pending_check));
   pending_clients_.erase(it);
 }
 
 void V4LocalDatabaseManager::RespondToClient(
     std::unique_ptr<PendingCheck> pending_check) {
   DCHECK(pending_check.get());
   DCHECK_EQ(ClientCallbackType::CHECK_BROWSE_URL,
             pending_check->client_callback_type);
   // TODO(vakh): Implement this skeleton.
@@ skipping 113 matching lines @@
 std::unordered_set<ListIdentifier>
 V4LocalDatabaseManager::GetStoresForFullHashRequests() {
   std::unordered_set<ListIdentifier> stores_for_full_hash;
   for (auto it : store_id_file_names_) {
     stores_for_full_hash.insert(it.list_id);
   }
   return stores_for_full_hash;
 }
 
 }  // namespace safe_browsing