Destroy store on task runner. That's where all store operations happen.

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 169 matching lines @@
                   new_store_map->at(identifier).get());
       }
     }
   }
 
   void VerifyChecksumCallback(const std::vector<ListIdentifier>& stores) {
     EXPECT_FALSE(verify_checksum_called_back_);
     verify_checksum_called_back_ = true;
   }
 
+  void WaitForTasksOnTaskRunner() {
+    task_runner_->RunPendingTasks();
+    base::RunLoop().RunUntilIdle();
+  }
+
   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_;
   bool verify_checksum_called_back_;
   ListInfos list_infos_;
   std::vector<ListIdentifier> expected_identifiers_;
   std::vector<base::FilePath> expected_store_paths_;
   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) {
   RegisterFactory();
 
   V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
-  task_runner_->RunPendingTasks();
-
-  base::RunLoop().RunUntilIdle();
+  WaitForTasksOnTaskRunner();
   EXPECT_EQ(true, created_and_called_back_);
 }
 
 // Test to check database updates as expected.
 TEST_F(V4DatabaseTest, TestApplyUpdateWithNewStates) {
   RegisterFactory();
 
   V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
-  task_runner_->RunPendingTasks();
-  base::RunLoop().RunUntilIdle();
+  WaitForTasksOnTaskRunner();
 
   // 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) {
     V4Store* store = store_iter.second.get();
     expected_store_state_map_[store_iter.first] = store->state() + "_fake";
     old_stores_map_[store_iter.first] = store;
   }
 
   v4_database_->ApplyUpdate(
       CreateFakeServerResponse(expected_store_state_map_, true),
       callback_db_updated_);
 
-  task_runner_->RunPendingTasks();
-  base::RunLoop().RunUntilIdle();
+  // Wait for the ApplyUpdate callback to get called.
+  WaitForTasksOnTaskRunner();
 
   VerifyExpectedStoresState(true);
+
+  // Wait for the old stores to get destroyed on task runner.
+  WaitForTasksOnTaskRunner();
 }
 
 // Test to ensure no state updates leads to no store updates.
 TEST_F(V4DatabaseTest, TestApplyUpdateWithNoNewState) {
   RegisterFactory();
 
   V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
-  task_runner_->RunPendingTasks();
-  base::RunLoop().RunUntilIdle();
+  WaitForTasksOnTaskRunner();
 
   // 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) {
     V4Store* store = store_iter.second.get();
     expected_store_state_map_[store_iter.first] = store->state();
     old_stores_map_[store_iter.first] = store;
   }
 
   v4_database_->ApplyUpdate(
       CreateFakeServerResponse(expected_store_state_map_, true),
       callback_db_updated_);
 
-  task_runner_->RunPendingTasks();
-  base::RunLoop().RunUntilIdle();
+  WaitForTasksOnTaskRunner();
 
   VerifyExpectedStoresState(false);
 }
 
 // Test to ensure no updates leads to no store updates.
 TEST_F(V4DatabaseTest, TestApplyUpdateWithEmptyUpdate) {
   RegisterFactory();
 
   V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
-  task_runner_->RunPendingTasks();
-  base::RunLoop().RunUntilIdle();
+  WaitForTasksOnTaskRunner();
 
   // 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) {
     V4Store* store = store_iter.second.get();
     expected_store_state_map_[store_iter.first] = store->state();
     old_stores_map_[store_iter.first] = store;
   }
 
   std::unique_ptr<ParsedServerResponse> parsed_server_response(
       new ParsedServerResponse);
   v4_database_->ApplyUpdate(std::move(parsed_server_response),
                             callback_db_updated_);
 
-  task_runner_->RunPendingTasks();
-  base::RunLoop().RunUntilIdle();
+  WaitForTasksOnTaskRunner();
 
   VerifyExpectedStoresState(false);
 }
 
 // Test to ensure invalid update leads to no store changes.
 TEST_F(V4DatabaseTest, TestApplyUpdateWithInvalidUpdate) {
   RegisterFactory();
 
   V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
-  task_runner_->RunPendingTasks();
-  base::RunLoop().RunUntilIdle();
+  WaitForTasksOnTaskRunner();
 
   // 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) {
     V4Store* store = store_iter.second.get();
     expected_store_state_map_[store_iter.first] = store->state();
     old_stores_map_[store_iter.first] = store;
   }
 
   v4_database_->ApplyUpdate(
       CreateFakeServerResponse(expected_store_state_map_, false),
       callback_db_updated_);
-  task_runner_->RunPendingTasks();
-  base::RunLoop().RunUntilIdle();
+  WaitForTasksOnTaskRunner();
 
   VerifyExpectedStoresState(false);
 }
 
 // Test to ensure the case that all stores match a given full hash.
 TEST_F(V4DatabaseTest, TestAllStoresMatchFullHash) {
   bool hash_prefix_matches = true;
   RegisterFactory(hash_prefix_matches);
 
   V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
-  task_runner_->RunPendingTasks();
-
-  base::RunLoop().RunUntilIdle();
+  WaitForTasksOnTaskRunner();
   EXPECT_EQ(true, created_and_called_back_);
 
   StoresToCheck stores_to_check({linux_malware_id_, win_malware_id_});
   StoreAndHashPrefixes store_and_hash_prefixes;
   v4_database_->GetStoresMatchingFullHash("anything", stores_to_check,
                                           &store_and_hash_prefixes);
   EXPECT_EQ(2u, store_and_hash_prefixes.size());
   StoresToCheck stores_found;
   for (const auto& it : store_and_hash_prefixes) {
     stores_found.insert(it.list_id);
   }
   EXPECT_EQ(stores_to_check, stores_found);
 }
 
 // Test to ensure the case that no stores match a given full hash.
 TEST_F(V4DatabaseTest, TestNoStoreMatchesFullHash) {
   bool hash_prefix_matches = false;
   RegisterFactory(hash_prefix_matches);
 
   V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
-  task_runner_->RunPendingTasks();
-
-  base::RunLoop().RunUntilIdle();
+  WaitForTasksOnTaskRunner();
   EXPECT_EQ(true, created_and_called_back_);
 
   StoreAndHashPrefixes store_and_hash_prefixes;
   v4_database_->GetStoresMatchingFullHash(
       "anything", StoresToCheck({linux_malware_id_, win_malware_id_}),
       &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;
   RegisterFactory(hash_prefix_matches);
 
   V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
-  task_runner_->RunPendingTasks();
-
-  base::RunLoop().RunUntilIdle();
+  WaitForTasksOnTaskRunner();
   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());
   store->set_hash_prefix_matches(true);
 
   StoreAndHashPrefixes store_and_hash_prefixes;
   v4_database_->GetStoresMatchingFullHash(
       "anything", StoresToCheck({linux_malware_id_, win_malware_id_}),
       &store_and_hash_prefixes);
   EXPECT_EQ(1u, store_and_hash_prefixes.size());
   EXPECT_EQ(store_and_hash_prefixes.begin()->list_id, win_malware_id_);
   EXPECT_FALSE(store_and_hash_prefixes.begin()->hash_prefix.empty());
 }
 
 // Test to ensure the case that only some stores are reported to match a given
 // full hash because of StoresToCheck.
 TEST_F(V4DatabaseTest, TestSomeStoresMatchFullHashBecauseOfStoresToMatch) {
   // Setup all stores to match the full hash.
   bool hash_prefix_matches = true;
   RegisterFactory(hash_prefix_matches);
 
   V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
-  task_runner_->RunPendingTasks();
-
-  base::RunLoop().RunUntilIdle();
+  WaitForTasksOnTaskRunner();
   EXPECT_EQ(true, created_and_called_back_);
 
   // Don't add win_malware_id_ to the StoresToCheck.
   StoreAndHashPrefixes store_and_hash_prefixes;
   v4_database_->GetStoresMatchingFullHash(
       "anything", StoresToCheck({linux_malware_id_}), &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());
 }
 
 TEST_F(V4DatabaseTest, VerifyChecksumCalledAsync) {
   bool hash_prefix_matches = true;
   RegisterFactory(hash_prefix_matches);
 
   V4Database::Create(task_runner_, database_dirname_, list_infos_,
                      callback_db_ready_);
   created_but_not_called_back_ = true;
-  task_runner_->RunPendingTasks();
-
-  base::RunLoop().RunUntilIdle();
+  WaitForTasksOnTaskRunner();
   EXPECT_EQ(true, created_and_called_back_);
 
   // verify_checksum_called_back_ set to false in the constructor.
   EXPECT_FALSE(verify_checksum_called_back_);
   // Now call VerifyChecksum and pass the callback that sets
   // verify_checksum_called_back_ to true.
   v4_database_->VerifyChecksum(base::Bind(
       &V4DatabaseTest::VerifyChecksumCallback, base::Unretained(this)));
   // verify_checksum_called_back_ should still be false since the checksum
   // verification is async.
   EXPECT_FALSE(verify_checksum_called_back_);
-  task_runner_->RunPendingTasks();
-  base::RunLoop().RunUntilIdle();
+  WaitForTasksOnTaskRunner();
   EXPECT_TRUE(verify_checksum_called_back_);
 }
 
 }  // namespace safe_browsing