Browser tests for using the new SafeBrowsing protocol (v4)

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 60 matching lines @@
   ListInfo();
 };
 
 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(
+  virtual std::unique_ptr<V4Database> Create(
       const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
-      const base::FilePath& base_dir_path,
-      const ListInfos& list_infos) = 0;
+      std::unique_ptr<StoreMap> store_map);
 };
 
 // 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 ListInfos& list_infos,
-      NewDatabaseReadyCallback callback);
+      NewDatabaseReadyCallback new_db_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);
 
+  // Makes the passed |factory| the factory used to instantiate a V4Database.
+  // Only for tests.
+  static void RegisterFactory(std::unique_ptr<V4DatabaseFactory> factory) {
+    db_factory_ = std::move(factory);
+  }
+
   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();
 
@@ skipping 26 matching lines @@
 
   // Records the size of each of the stores managed by this database, along
   // with the combined size of all the stores.
   void RecordFileSizeHistograms();
 
  protected:
   V4Database(const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
              std::unique_ptr<StoreMap> store_map);
 
  private:
+  friend class V4DatabaseFactory;
   friend class V4DatabaseTest;
   FRIEND_TEST_ALL_PREFIXES(V4DatabaseTest, TestSetupDatabaseWithFakeStores);
   FRIEND_TEST_ALL_PREFIXES(V4DatabaseTest,
                            TestSetupDatabaseWithFakeStoresFailsReset);
   FRIEND_TEST_ALL_PREFIXES(V4DatabaseTest, TestApplyUpdateWithNewStates);
   FRIEND_TEST_ALL_PREFIXES(V4DatabaseTest, TestApplyUpdateWithNoNewState);
   FRIEND_TEST_ALL_PREFIXES(V4DatabaseTest, TestApplyUpdateWithEmptyUpdate);
   FRIEND_TEST_ALL_PREFIXES(V4DatabaseTest, TestApplyUpdateWithInvalidUpdate);
   FRIEND_TEST_ALL_PREFIXES(V4DatabaseTest, TestSomeStoresMatchFullHash);
 
   // Makes the passed |factory| the factory used to instantiate a V4Store. Only
   // for tests.
-  static void RegisterStoreFactoryForTest(V4StoreFactory* factory) {
-    factory_ = factory;
+  static void RegisterStoreFactoryForTest(
+      std::unique_ptr<V4StoreFactory> factory) {
+    store_factory_ = std::move(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 ListInfos& list_infos,
       const scoped_refptr<base::SingleThreadTaskRunner>& callback_task_runner,
       NewDatabaseReadyCallback callback,
       const base::TimeTicks create_start_time);
 
   // 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);
 
   // See |VerifyChecksum|.
   void VerifyChecksumOnTaskRunner(
       const scoped_refptr<base::SingleThreadTaskRunner>& callback_task_runner,
       DatabaseReadyForUpdatesCallback db_ready_for_updates_callback);
 
-  const scoped_refptr<base::SequencedTaskRunner> db_task_runner_;
-
+ protected:
   // Map of ListIdentifier to the V4Store.
   const std::unique_ptr<StoreMap> store_map_;
 
+ private:
+  const scoped_refptr<base::SequencedTaskRunner> db_task_runner_;
+
   DatabaseUpdatedCallback db_updated_callback_;
 
+  // The factory that controls the creation of the V4Database object.
+  static std::unique_ptr<V4DatabaseFactory> db_factory_;

[Nathan Parker, 2017/02/10 00:52:37]

(I'm not sure if this ever gets deleted... but I think it makes sense to have
unique_ptr since then the ownership is clear.)

[vakh (use Gerrit instead), 2017/02/10 01:08:15]

Acknowledged.

+
   // The factory that controls the creation of V4Store objects.
-  static V4StoreFactory* factory_;
+  static std::unique_ptr<V4StoreFactory> store_factory_;
 
   // The number of stores for which the update request is pending. When this
   // goes down to 0, that indicates that the database has updated all the stores
   // that needed updating and is ready for the next update. It should only be
   // accessed on the IO thread.
   int pending_store_updates_;
 
   // Only meant to be dereferenced and invalidated on the IO thread and hence
   // named. For details, see the comment at the top of weak_ptr.h
   base::WeakPtrFactory<V4Database> weak_factory_on_io_;
 
   DISALLOW_COPY_AND_ASSIGN(V4Database);
 };
 
 }  // namespace safe_browsing
 
 #endif  // COMPONENTS_SAFE_BROWSING_DB_V4_DATABASE_H_