Store list information in ListInfo (was: StoreIdAndFIleName)

components/safe_browsing_db/v4_database_unittest.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.
 
 #include "base/bind.h"
 #include "base/debug/leak_annotations.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
@@ skipping 87 matching lines @@
   }
 
   void RegisterFactory(bool fails_first_reset,
                        bool hash_prefix_matches = true) {
     factory_.reset(
         new FakeV4StoreFactory(fails_first_reset, hash_prefix_matches));
     V4Database::RegisterStoreFactoryForTest(factory_.get());
   }
 
   void SetupInfoMapAndExpectedState() {
-    store_id_file_names_.emplace_back(win_malware_id_, "win_url_malware");
+    list_infos_.emplace_back(win_malware_id_, "win_url_malware",
+                             SB_THREAT_TYPE_URL_MALWARE, true);
     expected_identifiers_.push_back(win_malware_id_);
     expected_store_paths_.push_back(
         database_dirname_.AppendASCII("win_url_malware.fake"));
 
-    store_id_file_names_.emplace_back(linux_malware_id_, "linux_url_malware");
+    list_infos_.emplace_back(linux_malware_id_, "linux_url_malware",
+                             SB_THREAT_TYPE_URL_MALWARE, true);
     expected_identifiers_.push_back(linux_malware_id_);
     expected_store_paths_.push_back(
         database_dirname_.AppendASCII("linux_url_malware.fake"));
   }
 
   void DatabaseUpdated() {}
   void NewDatabaseReadyWithExpectedStorePathsAndIds(
       std::unique_ptr<V4Database> v4_database) {
     ASSERT_TRUE(v4_database);
     ASSERT_TRUE(v4_database->store_map_);
@@ skipping 20 matching lines @@
   }
 
   std::unique_ptr<ParsedServerResponse> CreateFakeServerResponse(
       StoreStateMap store_state_map,
       bool use_valid_response_type) {
     std::unique_ptr<ParsedServerResponse> parsed_server_response(
         new ParsedServerResponse);
     for (const auto& store_state_iter : store_state_map) {
       ListIdentifier identifier = store_state_iter.first;
       ListUpdateResponse* lur = new ListUpdateResponse;
-      lur->set_platform_type(identifier.platform_type);
-      lur->set_threat_entry_type(identifier.threat_entry_type);
-      lur->set_threat_type(identifier.threat_type);
+      lur->set_platform_type(identifier.platform_type());
+      lur->set_threat_entry_type(identifier.threat_entry_type());
+      lur->set_threat_type(identifier.threat_type());
       lur->set_new_client_state(store_state_iter.second);
       if (use_valid_response_type) {
         lur->set_response_type(ListUpdateResponse::FULL_UPDATE);
       } else {
         lur->set_response_type(ListUpdateResponse::RESPONSE_TYPE_UNSPECIFIED);
       }
       parsed_server_response->push_back(base::WrapUnique(lur));
     }
     return parsed_server_response;
   }
@@ skipping 26 matching lines @@
     }
   }
 
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   std::unique_ptr<V4Database> v4_database_;
   base::FilePath database_dirname_;
   base::ScopedTempDir temp_dir_;
   content::TestBrowserThreadBundle thread_bundle_;
   bool created_but_not_called_back_;
   bool created_and_called_back_;
-  StoreIdAndFileNames store_id_file_names_;
+  ListInfos list_infos_;
   std::vector<ListIdentifier> expected_identifiers_;
   std::vector<base::FilePath> expected_store_paths_;
   bool expected_resets_successfully_;
   std::unique_ptr<FakeV4StoreFactory> factory_;
   DatabaseUpdatedCallback callback_db_updated_;
   NewDatabaseReadyCallback callback_db_ready_;
   StoreStateMap expected_store_state_map_;
   base::hash_map<ListIdentifier, V4Store*> old_stores_map_;
   const ListIdentifier linux_malware_id_, win_malware_id_;
 };
 
 // Test to set up the database with fake stores.
 TEST_F(V4DatabaseTest, TestSetupDatabaseWithFakeStores) {
   expected_resets_successfully_ = true;
   RegisterFactory(!expected_resets_successfully_);
 
-  V4Database::Create(task_runner_, database_dirname_, store_id_file_names_,
+  V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
   task_runner_->RunPendingTasks();
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(true, created_and_called_back_);
 }
 
 // Test to set up the database with fake stores that fail to reset.
 TEST_F(V4DatabaseTest, TestSetupDatabaseWithFakeStoresFailsReset) {
   expected_resets_successfully_ = false;
   RegisterFactory(!expected_resets_successfully_);
 
-  V4Database::Create(task_runner_, database_dirname_, store_id_file_names_,
+  V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
   task_runner_->RunPendingTasks();
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(true, created_and_called_back_);
 }
 
 // Test to check database updates as expected.
 TEST_F(V4DatabaseTest, TestApplyUpdateWithNewStates) {
   expected_resets_successfully_ = true;
   RegisterFactory(!expected_resets_successfully_);
 
-  V4Database::Create(task_runner_, database_dirname_, store_id_file_names_,
+  V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
   task_runner_->RunPendingTasks();
   base::RunLoop().RunUntilIdle();
 
   // The database has now been created. Time to try to update it.
   EXPECT_TRUE(v4_database_);
   const StoreMap* db_stores = v4_database_->store_map_.get();
   EXPECT_EQ(expected_store_paths_.size(), db_stores->size());
   for (const auto& store_iter : *db_stores) {
@@ skipping 10 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   VerifyExpectedStoresState(true);
 }
 
 // Test to ensure no state updates leads to no store updates.
 TEST_F(V4DatabaseTest, TestApplyUpdateWithNoNewState) {
   expected_resets_successfully_ = true;
   RegisterFactory(!expected_resets_successfully_);
 
-  V4Database::Create(task_runner_, database_dirname_, store_id_file_names_,
+  V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
   task_runner_->RunPendingTasks();
   base::RunLoop().RunUntilIdle();
 
   // The database has now been created. Time to try to update it.
   EXPECT_TRUE(v4_database_);
   const StoreMap* db_stores = v4_database_->store_map_.get();
   EXPECT_EQ(expected_store_paths_.size(), db_stores->size());
   for (const auto& store_iter : *db_stores) {
@@ skipping 10 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   VerifyExpectedStoresState(false);
 }
 
 // Test to ensure no updates leads to no store updates.
 TEST_F(V4DatabaseTest, TestApplyUpdateWithEmptyUpdate) {
   expected_resets_successfully_ = true;
   RegisterFactory(!expected_resets_successfully_);
 
-  V4Database::Create(task_runner_, database_dirname_, store_id_file_names_,
+  V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
   task_runner_->RunPendingTasks();
   base::RunLoop().RunUntilIdle();
 
   // The database has now been created. Time to try to update it.
   EXPECT_TRUE(v4_database_);
   const StoreMap* db_stores = v4_database_->store_map_.get();
   EXPECT_EQ(expected_store_paths_.size(), db_stores->size());
   for (const auto& store_iter : *db_stores) {
@@ skipping 11 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   VerifyExpectedStoresState(false);
 }
 
 // Test to ensure invalid update leads to no store changes.
 TEST_F(V4DatabaseTest, TestApplyUpdateWithInvalidUpdate) {
   expected_resets_successfully_ = true;
   RegisterFactory(!expected_resets_successfully_);
 
-  V4Database::Create(task_runner_, database_dirname_, store_id_file_names_,
+  V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
   task_runner_->RunPendingTasks();
   base::RunLoop().RunUntilIdle();
 
   // The database has now been created. Time to try to update it.
   EXPECT_TRUE(v4_database_);
   const StoreMap* db_stores = v4_database_->store_map_.get();
   EXPECT_EQ(expected_store_paths_.size(), db_stores->size());
   for (const auto& store_iter : *db_stores) {
@@ skipping 10 matching lines @@
 
   VerifyExpectedStoresState(false);
 }
 
 // Test to ensure the case that all stores match a given full hash.
 TEST_F(V4DatabaseTest, TestAllStoresMatchFullHash) {
   bool hash_prefix_matches = true;
   expected_resets_successfully_ = true;
   RegisterFactory(!expected_resets_successfully_, hash_prefix_matches);
 
-  V4Database::Create(task_runner_, database_dirname_, store_id_file_names_,
+  V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
   task_runner_->RunPendingTasks();
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(true, created_and_called_back_);
 
   std::unordered_set<ListIdentifier> stores_to_look(
       {linux_malware_id_, win_malware_id_});
   StoreAndHashPrefixes store_and_hash_prefixes;
   v4_database_->GetStoresMatchingFullHash("anything", stores_to_look,
                                           &store_and_hash_prefixes);
   EXPECT_EQ(2u, store_and_hash_prefixes.size());
   std::unordered_set<ListIdentifier> stores_found;
   for (const auto& it : store_and_hash_prefixes) {
     stores_found.insert(it.list_id);
   }
   EXPECT_EQ(stores_to_look, stores_found);
 }
 
 // Test to ensure the case that no stores match a given full hash.
 TEST_F(V4DatabaseTest, TestNoStoreMatchesFullHash) {
   bool hash_prefix_matches = false;
   expected_resets_successfully_ = true;
   RegisterFactory(!expected_resets_successfully_, hash_prefix_matches);
 
-  V4Database::Create(task_runner_, database_dirname_, store_id_file_names_,
+  V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
   task_runner_->RunPendingTasks();
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(true, created_and_called_back_);
 
   std::unordered_set<ListIdentifier> stores_to_look(
       {linux_malware_id_, win_malware_id_});
   StoreAndHashPrefixes store_and_hash_prefixes;
   v4_database_->GetStoresMatchingFullHash("anything", stores_to_look,
                                           &store_and_hash_prefixes);
   EXPECT_TRUE(store_and_hash_prefixes.empty());
 }
 
 // Test to ensure the case that some stores match a given full hash.
 TEST_F(V4DatabaseTest, TestSomeStoresMatchFullHash) {
   // Setup stores to not match the full hash.
   bool hash_prefix_matches = false;
   expected_resets_successfully_ = true;
   RegisterFactory(!expected_resets_successfully_, hash_prefix_matches);
 
-  V4Database::Create(task_runner_, database_dirname_, store_id_file_names_,
+  V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
   task_runner_->RunPendingTasks();
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(true, created_and_called_back_);
 
   // Set the store corresponding to linux_malware_id_ to match the full hash.
   FakeV4Store* store = static_cast<FakeV4Store*>(
       v4_database_->store_map_->at(win_malware_id_).get());
@@ skipping 10 matching lines @@
 }
 
 // Test to ensure the case that only some stores are reported to match a given
 // full hash because of stores_to_look.
 TEST_F(V4DatabaseTest, TestSomeStoresMatchFullHashBecauseOfStoresToMatch) {
   // Setup all stores to match the full hash.
   bool hash_prefix_matches = true;
   expected_resets_successfully_ = true;
   RegisterFactory(!expected_resets_successfully_, hash_prefix_matches);
 
-  V4Database::Create(task_runner_, database_dirname_, store_id_file_names_,
+  V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
   task_runner_->RunPendingTasks();
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(true, created_and_called_back_);
 
   std::unordered_set<ListIdentifier> stores_to_look({linux_malware_id_});
   // Don't add win_malware_id_ to the stores_to_look.
   StoreAndHashPrefixes store_and_hash_prefixes;
   v4_database_->GetStoresMatchingFullHash("anything", stores_to_look,
                                           &store_and_hash_prefixes);
   EXPECT_EQ(1u, store_and_hash_prefixes.size());
   EXPECT_EQ(store_and_hash_prefixes.begin()->list_id, linux_malware_id_);
   EXPECT_FALSE(store_and_hash_prefixes.begin()->hash_prefix.empty());
 }
 
 }  // namespace safe_browsing