Each DatabaseManager gets to decide which stores to track

components/safe_browsing_db/v4_database.h

 // 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.
 
 #ifndef COMPONENTS_SAFE_BROWSING_DB_V4_DATABASE_H_
 #define COMPONENTS_SAFE_BROWSING_DB_V4_DATABASE_H_
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "components/safe_browsing_db/v4_protocol_manager_util.h"
 #include "components/safe_browsing_db/v4_store.h"
 
 namespace safe_browsing {
 
 class V4Database;
 
 typedef base::Callback<void(std::unique_ptr<V4Database>)>
     NewDatabaseReadyCallback;
 
 // This callback is scheduled once the database has finished processing the
 // update requests for all stores and is ready to process the next set of update
 // requests.
 typedef base::Callback<void()> DatabaseUpdatedCallback;
 
-// The set of interesting lists and ASCII filenames for their hash prefix
-// stores. The stores are created inside the user-data directory.
-// For instance, the UpdateListIdentifier could be for URL expressions for UwS
-// on Windows platform, and the corresponding file on disk could be named:
-// "uws_win_url.store"
+// Maps the UpdateListIdentifiers to their corresponding in-memory stores, which
+// contain the hash prefixes for that UpdateListIdentifier as well as manage
+// their storage on disk.
+typedef base::hash_map<UpdateListIdentifier, std::unique_ptr<V4Store>> StoreMap;
+
 // TODO(vakh): Find the canonical place where these are defined and update the
 // comment to point to that place.
-typedef base::hash_map<UpdateListIdentifier, std::string> StoreFileNameMap;
+struct StoreIdAndFileName {
+  // The list being read from/written to the disk.
+  UpdateListIdentifier list_id;
 
-// This hash_map maps the UpdateListIdentifiers to their corresponding in-memory
-// stores, which contain the hash prefixes for that UpdateListIdentifier as well
-// as manage their storage on disk.
-typedef base::hash_map<UpdateListIdentifier, std::unique_ptr<V4Store>> StoreMap;
+  // The ASCII name of the file on disk. This file is created inside the
+  // user-data directory. For instance, the UpdateListIdentifier could be for
+  // URL expressions for UwS on Windows platform, and the corresponding file on
+  // disk could be named: "UrlUws.store"
+  std::string filename;
+
+  StoreIdAndFileName(const UpdateListIdentifier& list_id,
+                     const std::string& filename);
+  ~StoreIdAndFileName();
+
+ private:
+  StoreIdAndFileName();
+};
+
+using StoreIdAndFileNames = std::vector<StoreIdAndFileName>;
 
 // Factory for creating V4Database. Tests implement this factory to create fake
 // databases for testing.
 class V4DatabaseFactory {
  public:
   virtual ~V4DatabaseFactory() {}
   virtual V4Database* CreateV4Database(
       const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
       const base::FilePath& base_dir_path,
-      const StoreFileNameMap& store_file_name_map) = 0;
+      const StoreIdAndFileNames& store_id_file_names) = 0;
 };
 
 // The on-disk databases are shared among all profiles, as it doesn't contain
 // user-specific data. This object is not thread-safe, i.e. all its methods
 // should be used on the same thread that it was created on, unless specified
 // otherwise.
 // The hash-prefixes of each type are managed by a V4Store (including saving to
 // and reading from disk).
 // The V4Database serves as a single place to manage all the V4Stores.
 class V4Database {
  public:
   // Factory method to create a V4Database. It creates the database on the
   // provided |db_task_runner| containing stores in |store_file_name_map|. When
   // the database creation is complete, it runs the NewDatabaseReadyCallback on
   // the same thread as it was called.
   static void Create(
       const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
       const base::FilePath& base_path,
-      const StoreFileNameMap& store_file_name_map,
+      const StoreIdAndFileNames& store_id_file_names,
       NewDatabaseReadyCallback callback);
 
   // Destroys the provided v4_database on its task_runner since this may be a
   // long operation.
   static void Destroy(std::unique_ptr<V4Database> v4_database);
 
   virtual ~V4Database();
 
   // Updates the stores with the response received from the SafeBrowsing service
   // and calls the db_updated_callback when done.
   void ApplyUpdate(std::unique_ptr<ParsedServerResponse> parsed_server_response,
                    DatabaseUpdatedCallback db_updated_callback);
 
   // Returns the current state of each of the stores being managed.
   std::unique_ptr<StoreStateMap> GetStoreStateMap();
 
   // Searches for a hash prefix matching the |full_hash| in stores in the
   // database, filtered by |stores_to_look|, and returns the identifier of the
   // store along with the matching hash prefix in |matched_hash_prefix_map|.
   virtual void GetStoresMatchingFullHash(
       const FullHash& full_hash,
-      const base::hash_set<UpdateListIdentifier>& stores_to_look,
+      const std::unordered_set<UpdateListIdentifier>& stores_to_look,
       StoreAndHashPrefixes* matched_store_and_full_hashes);
 
   // Deletes the current database and creates a new one.
   virtual bool ResetDatabase();
 
  protected:
   V4Database(const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
              std::unique_ptr<StoreMap> store_map);
 
  private:
@@ skipping 11 matching lines @@
   // for tests.
   static void RegisterStoreFactoryForTest(V4StoreFactory* factory) {
     factory_ = factory;
   }
 
   // Factory method to create a V4Database. When the database creation is
   // complete, it calls the NewDatabaseReadyCallback on |callback_task_runner|.
   static void CreateOnTaskRunner(
       const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
       const base::FilePath& base_path,
-      const StoreFileNameMap& store_file_name_map,
+      const StoreIdAndFileNames& store_id_file_names,
       const scoped_refptr<base::SingleThreadTaskRunner>& callback_task_runner,
       NewDatabaseReadyCallback callback);
 
   // Callback called when a new store has been created and is ready to be used.
   // This method updates the store_map_ to point to the new store, which causes
   // the old store to get deleted.
   void UpdatedStoreReady(UpdateListIdentifier identifier,
                          std::unique_ptr<V4Store> store);
 
   const scoped_refptr<base::SequencedTaskRunner> db_task_runner_;
@@ skipping 11 matching lines @@
   // that needed updating and is ready for the next update. It should only be
   // accessed on the IO thread.
   int pending_store_updates_;
 
   DISALLOW_COPY_AND_ASSIGN(V4Database);
 };
 
 }  // namespace safe_browsing
 
 #endif  // COMPONENTS_SAFE_BROWSING_DB_V4_DATABASE_H_