[S] Use a weak_factory for V4Database callbacks + test

components/safe_browsing_db/v4_database.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 <memory>
 
 #include "base/callback.h"
 #include "base/debug/leak_annotations.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
@@ skipping 73 matching lines @@
 
   UMA_HISTOGRAM_TIMES("SafeBrowsing.V4DatabaseOpen.Time",
                       TimeTicks::Now() - create_start_time);
 }
 
 V4Database::V4Database(
     const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
     std::unique_ptr<StoreMap> store_map)
     : db_task_runner_(db_task_runner),
       store_map_(std::move(store_map)),
-      pending_store_updates_(0) {
+      pending_store_updates_(0),
+      weak_factory_on_io_(this) {
   DCHECK(db_task_runner->RunsTasksOnCurrentThread());
 }
 
 // static
 void V4Database::Destroy(std::unique_ptr<V4Database> v4_database) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   V4Database* v4_database_raw = v4_database.release();
   if (v4_database_raw) {
+    v4_database_raw->weak_factory_on_io_.InvalidateWeakPtrs();
     v4_database_raw->db_task_runner_->DeleteSoon(FROM_HERE, v4_database_raw);
   }
 }
 
 V4Database::~V4Database() {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 }
 
 void V4Database::ApplyUpdate(
     std::unique_ptr<ParsedServerResponse> parsed_server_response,
@@ skipping 10 matching lines @@
       base::ThreadTaskRunnerHandle::Get();
   for (std::unique_ptr<ListUpdateResponse>& response :
        *parsed_server_response) {
     ListIdentifier identifier(*response);
     StoreMap::const_iterator iter = store_map_->find(identifier);
     if (iter != store_map_->end()) {
       const std::unique_ptr<V4Store>& old_store = iter->second;
       if (old_store->state() != response->new_client_state()) {
         // A different state implies there are updates to process.
         pending_store_updates_++;
-        UpdatedStoreReadyCallback store_ready_callback = base::Bind(
-            &V4Database::UpdatedStoreReady, base::Unretained(this), identifier);
+        UpdatedStoreReadyCallback store_ready_callback =
+            base::Bind(&V4Database::UpdatedStoreReady,
+                       weak_factory_on_io_.GetWeakPtr(), identifier);
         db_task_runner_->PostTask(
             FROM_HERE,
             base::Bind(&V4Store::ApplyUpdate, base::Unretained(old_store.get()),
                        base::Passed(std::move(response)), current_task_runner,
                        store_ready_callback));
       }
     } else {
       NOTREACHED() << "Got update for unexpected identifier: " << identifier;
     }
   }
@@ skipping 68 matching lines @@
   }
 }
 
 void V4Database::VerifyChecksum(
     DatabaseReadyForUpdatesCallback db_ready_for_updates_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // TODO(vakh): Consider using PostTaskAndReply instead.
   const scoped_refptr<base::SingleThreadTaskRunner> callback_task_runner =
       base::ThreadTaskRunnerHandle::Get();
   db_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&V4Database::VerifyChecksumOnTaskRunner,
-                            base::Unretained(this), callback_task_runner,
-                            db_ready_for_updates_callback));
+      FROM_HERE,
+      base::Bind(&V4Database::VerifyChecksumOnTaskRunner,
+                 weak_factory_on_io_.GetWeakPtr(), callback_task_runner,
+                 db_ready_for_updates_callback));
 }
 
 void V4Database::VerifyChecksumOnTaskRunner(
     const scoped_refptr<base::SingleThreadTaskRunner>& callback_task_runner,
     DatabaseReadyForUpdatesCallback db_ready_for_updates_callback) {
   std::vector<ListIdentifier> stores_to_reset;
   for (const auto& store_map_iter : *store_map_) {
     if (!store_map_iter.second->VerifyChecksum()) {
       stores_to_reset.push_back(store_map_iter.first);
     }
@@ skipping 22 matching lines @@
       filename_(filename),
       list_id_(list_id),
       sb_threat_type_(sb_threat_type) {
   DCHECK(!fetch_updates_ || !filename_.empty());
   DCHECK_NE(SB_THREAT_TYPE_SAFE, sb_threat_type_);
 }
 
 ListInfo::~ListInfo() {}
 
 }  // namespace safe_browsing