Store list information in ListInfo (was: StoreIdAndFIleName)

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"
@@ skipping 12 matching lines @@
 // 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;
 
 // Maps the ListIdentifiers to their corresponding in-memory stores, which
 // contain the hash prefixes for that ListIdentifier as well as manage their
 // storage on disk.
 typedef base::hash_map<ListIdentifier, std::unique_ptr<V4Store>> StoreMap;
 
-// TODO(vakh): Find the canonical place where these are defined and update the
-// comment to point to that place.
-struct StoreIdAndFileName {
-  // The list being read from/written to the disk.
-  ListIdentifier list_id;
+// Associates metadata for a list with its ListIdentifier.
+struct ListInfo {
+  ListInfo(const bool fetch_updates,
+           const std::string& filename,
+           const ListIdentifier& list_id,
+           const SBThreatType sb_threat_type);
+  ~ListInfo();
+
+  ListIdentifier list_id() const { return list_id_; }
+  std::string filename() const { return filename_; }
+  SBThreatType sb_threat_type() const { return sb_threat_type_; }
+  bool fetch_updates() const { return fetch_updates_; }
+
+ private:
+  // Whether to fetch and store updates for this list.
+  bool fetch_updates_;
 
   // The ASCII name of the file on disk. This file is created inside the
   // user-data directory. For instance, the ListIdentifier could be for URL
   // expressions for UwS on Windows platform, and the corresponding file on disk
   // could be named: "UrlUws.store"
-  std::string filename;
+  std::string filename_;
 
-  StoreIdAndFileName(const ListIdentifier& list_id,
-                     const std::string& filename);
-  ~StoreIdAndFileName();
+  // The list being read from/written to the disk.
+  ListIdentifier list_id_;
 
- private:
-  StoreIdAndFileName();
+  // The threat type enum value for this store.
+  SBThreatType sb_threat_type_;
+
+  ListInfo();
 };
 
-using StoreIdAndFileNames = std::vector<StoreIdAndFileName>;
+typedef std::vector<ListInfo> ListInfos;
 
 // 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 StoreIdAndFileNames& store_id_file_names) = 0;
+      const ListInfos& list_infos) = 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 StoreIdAndFileNames& store_id_file_names,
+      const ListInfos& list_infos,
       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.
@@ skipping 33 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 StoreIdAndFileNames& store_id_file_names,
+      const ListInfos& list_infos,
       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(ListIdentifier 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_