Each DatabaseManager gets to decide which stores to track

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/callback.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace safe_browsing {
 
 namespace {
 
-// TODO(vakh): Implement this to populate the map appopriately.
+// TODO(vakh): Implement this to populate the vector appopriately.
 // Filed as http://crbug.com/608075
-StoreFileNameMap GetStoreFileNameMap() {
-  return StoreFileNameMap({{GetUrlMalwareId(), "UrlMalware.store"},
-                           {GetUrlSocEngId(), "UrlSoceng.store"}});
+StoreIdAndFileNames GetStoreIdAndFileNames() {
+  return StoreIdAndFileNames(
+      {StoreIdAndFileName(GetUrlMalwareId(), "UrlMalware.store"),
+       StoreIdAndFileName(GetUrlSocEngId(), "UrlSoceng.store")});
 }
 
 }  // namespace
 
 V4LocalDatabaseManager::V4LocalDatabaseManager(const base::FilePath& base_path)
-    : base_path_(base_path), enabled_(false) {
+    : base_path_(base_path),
+      enabled_(false),
+      store_id_file_names_(GetStoreIdAndFileNames()) {
   DCHECK(!base_path_.empty());
+  DCHECK(!store_id_file_names_.empty());
+
   DVLOG(1) << "V4LocalDatabaseManager::V4LocalDatabaseManager: "
            << "base_path_: " << base_path_.AsUTF8Unsafe();
 }
 
 V4LocalDatabaseManager::~V4LocalDatabaseManager() {
   DCHECK(!enabled_);
 }
 
 bool V4LocalDatabaseManager::IsSupported() const {
   return true;
@@ skipping 90 matching lines @@
   return true;
 }
 
 bool V4LocalDatabaseManager::CheckBrowseUrl(const GURL& url, Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_ || !CanCheckUrl(url)) {
     return true;
   }
 
   if (v4_database_) {
-    base::hash_set<FullHash> full_hashes;
+    std::unordered_set<FullHash> full_hashes;
     V4ProtocolManagerUtil::UrlToFullHashes(url, &full_hashes);
 
-    base::hash_set<UpdateListIdentifier> stores_to_look(
+    std::unordered_set<UpdateListIdentifier> stores_to_look(
         {GetUrlMalwareId(), GetUrlSocEngId()});
-    base::hash_set<HashPrefix> matched_hash_prefixes;
-    base::hash_set<UpdateListIdentifier> matched_stores;
+    std::unordered_set<HashPrefix> matched_hash_prefixes;
+    std::unordered_set<UpdateListIdentifier> matched_stores;
     StoreAndHashPrefixes matched_store_and_full_hashes;
     FullHashToStoreAndHashPrefixesMap full_hash_to_store_and_hash_prefixes;
     for (const auto& full_hash : full_hashes) {
       matched_store_and_full_hashes.clear();
       v4_database_->GetStoresMatchingFullHash(full_hash, stores_to_look,
                                               &matched_store_and_full_hashes);
       if (!matched_store_and_full_hashes.empty()) {
         full_hash_to_store_and_hash_prefixes[full_hash] =
             matched_store_and_full_hashes;
       }
@@ skipping 30 matching lines @@
 
 void V4LocalDatabaseManager::StartOnIOThread(
     net::URLRequestContextGetter* request_context_getter,
     const V4ProtocolConfig& config) {
   SafeBrowsingDatabaseManager::StartOnIOThread(request_context_getter, config);
 
   db_updated_callback_ = base::Bind(&V4LocalDatabaseManager::DatabaseUpdated,
                                     base::Unretained(this));
 
   SetupUpdateProtocolManager(request_context_getter, config);
-
   SetupDatabase();
 
   enabled_ = true;
 }
 
 void V4LocalDatabaseManager::SetupUpdateProtocolManager(
     net::URLRequestContextGetter* request_context_getter,
     const V4ProtocolConfig& config) {
   V4UpdateCallback callback = base::Bind(
       &V4LocalDatabaseManager::UpdateRequestCompleted, base::Unretained(this));
 
   v4_update_protocol_manager_ =
       V4UpdateProtocolManager::Create(request_context_getter, config, callback);
 }
 
 void V4LocalDatabaseManager::SetupDatabase() {
   DCHECK(!base_path_.empty());
+  DCHECK(!store_id_file_names_.empty());

[kcarattini, 2016/09/18 12:20:46]

Just checking that this list includes API checks as well?

[vakh (use Gerrit instead), 2016/09/19 17:03:05]

SafeBrowsingDatabaseManager includes API checks. V4LocalDatabaseManager doesn't
include API checks *yet*,  but it's straightforward to add it by adding a store
for it in GetStoreIdAndFileNames()

[kcarattini, 2016/09/26 00:23:34]

So that means that until it's added to V$, API checks will still Use the V3
LocalDatabaseManager and RemoteDatabaseManager. Is that ok? Are other things
still using the v3 database manager?

[vakh (use Gerrit instead), 2016/09/26 06:09:55]

That's OK. Other things are sill using PVer3 but I am going to additionally
enable V4 for Malware and Phishing this week.

   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Only get a new task runner if there isn't one already. If the service has
   // previously been started and stopped, a task runner could already exist.
   if (!task_runner_) {
     base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
     task_runner_ = pool->GetSequencedTaskRunnerWithShutdownBehavior(
         pool->GetSequenceToken(), base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
   }
 
   // Do not create the database on the IO thread since this may be an expensive
   // operation. Instead, do that on the task_runner and when the new database
   // has been created, swap it out on the IO thread.
-  StoreFileNameMap store_file_name_map = GetStoreFileNameMap();
-  DCHECK(!store_file_name_map.empty());
   NewDatabaseReadyCallback db_ready_callback = base::Bind(
       &V4LocalDatabaseManager::DatabaseReady, base::Unretained(this));
-  V4Database::Create(task_runner_, base_path_, store_file_name_map,
+  V4Database::Create(task_runner_, base_path_, store_id_file_names_,
                      db_ready_callback);
 }
 
 void V4LocalDatabaseManager::DatabaseReady(
     std::unique_ptr<V4Database> v4_database) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // The following check is needed because it is possible that by the time the
   // database is ready, StopOnIOThread has been called.
   if (enabled_) {
@@ skipping 34 matching lines @@
                             db_updated_callback_);
 }
 
 void V4LocalDatabaseManager::DatabaseUpdated() {
   if (enabled_) {
     v4_update_protocol_manager_->ScheduleNextUpdate(
         v4_database_->GetStoreStateMap());
   }
 }
 
+std::unordered_set<UpdateListIdentifier>
+V4LocalDatabaseManager::GetStoresForFullHashRequests() {
+  std::unordered_set<UpdateListIdentifier> 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