[S] Use a weak_factory for V4Database callbacks + test

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 92 matching lines @@
         database_dirname_.AppendASCII("win_url_malware.fake"));
 
     list_infos_.emplace_back(true, "linux_url_malware", linux_malware_id_,
                              SB_THREAT_TYPE_URL_MALWARE);
     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_);
 
     // The following check ensures that the callback was called asynchronously.
     EXPECT_TRUE(created_but_not_called_back_);
 
     ASSERT_EQ(expected_store_paths_.size(), v4_database->store_map_->size());
     ASSERT_EQ(expected_identifiers_.size(), v4_database->store_map_->size());
@@ skipping 346 matching lines @@
 
   EXPECT_TRUE(v4_database_->AreStoresAvailable(
       StoresToCheck({linux_malware_id_, win_malware_id_})));
 
   EXPECT_FALSE(v4_database_->AreStoresAvailable(
       StoresToCheck({linux_malware_id_, bogus_id})));
 
   EXPECT_FALSE(v4_database_->AreStoresAvailable(StoresToCheck({bogus_id})));
 }
 
+// Test to ensure that the callback to the database is dropped when the database
+// gets destroyed. See http://crbug.com/683147#c5 for more details.
+TEST_F(V4DatabaseTest, UsingWeakPtrDropsCallback) {
+  RegisterFactory();
+
+  // Step 1: Create the database.
+  V4Database::Create(task_runner_, database_dirname_, list_infos_,
+                     callback_db_ready_);
+  created_but_not_called_back_ = true;
+  WaitForTasksOnTaskRunner();
+
+  // Step 2: Try to update the database. This posts V4Store::ApplyUpdate on the
+  // task runner.
+  std::unique_ptr<ParsedServerResponse> parsed_server_response(
+      new ParsedServerResponse);
+  auto lur = base::MakeUnique<ListUpdateResponse>();
+  lur->set_platform_type(linux_malware_id_.platform_type());
+  lur->set_threat_entry_type(linux_malware_id_.threat_entry_type());
+  lur->set_threat_type(linux_malware_id_.threat_type());
+  lur->set_new_client_state("new_state");
+  lur->set_response_type(ListUpdateResponse::FULL_UPDATE);
+  parsed_server_response->push_back(std::move(lur));
+
+  // We pass |null_callback| as the second argument to |ApplyUpdate| since we
+  // expect it to not get called. This callback method is called from
+  // V4Database::UpdatedStoreReady but we expect that call to get dropped.
+  base::Callback<void()> null_callback;
+  v4_database_->ApplyUpdate(std::move(parsed_server_response), null_callback);
+
+  // Step 3: Before V4Store::ApplyUpdate gets executed on the task runner,
+  // destroy the database. This posts ~V4Database() on the task runner.
+  V4Database::Destroy(std::move(v4_database_));
+
+  // Step 4: Wait for the task runner to go to completion. The test should
+  // finish to completion and the |null_callback| should not get called.
+  WaitForTasksOnTaskRunner();
+}
+
 }  // namespace safe_browsing