Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/safe_browsing

chrome/browser/safe_browsing/local_database_manager.cc

 // Copyright (c) 2012 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 "chrome/browser/safe_browsing/local_database_manager.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 535 matching lines @@
   SafeBrowsingCheck* check = new SafeBrowsingCheck(
       std::vector<GURL>(1, url), std::vector<SBFullHash>(), client, MALWARE,
       expected_threats);
   check->need_get_hash = cache_hits.empty();
   check->prefix_hits.swap(prefix_hits);
   check->cache_hits.swap(cache_hits);
   checks_[check] = base::WrapUnique(check);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&LocalSafeBrowsingDatabaseManager::OnCheckDone, this, check));
+      base::BindOnce(&LocalSafeBrowsingDatabaseManager::OnCheckDone, this,
+                     check));
 
   return false;
 }
 
 bool LocalSafeBrowsingDatabaseManager::CheckUrlForSubresourceFilter(
     const GURL& url,
     Client* client) {
   // TODO(melandory): implement Android support.
   NOTREACHED();
   return true;
@@ skipping 46 matching lines @@
   if (!cache_lifetime.is_zero() && MakeDatabaseAvailable())
     database_->CacheHashResults(prefixes, full_hashes, cache_lifetime);
 }
 
 void LocalSafeBrowsingDatabaseManager::GetChunks(GetChunksCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   DCHECK(!callback.is_null());
   safe_browsing_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&LocalSafeBrowsingDatabaseManager::GetAllChunksFromDatabase,
-                 this, callback));
+      base::BindOnce(
+          &LocalSafeBrowsingDatabaseManager::GetAllChunksFromDatabase, this,
+          callback));
 }
 
 void LocalSafeBrowsingDatabaseManager::AddChunks(
     const std::string& list,
     std::unique_ptr<std::vector<std::unique_ptr<SBChunkData>>> chunks,
     AddChunksCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   DCHECK(!callback.is_null());
   safe_browsing_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&LocalSafeBrowsingDatabaseManager::AddDatabaseChunks, this,
-                 list, base::Passed(&chunks), callback));
+      base::BindOnce(&LocalSafeBrowsingDatabaseManager::AddDatabaseChunks, this,
+                     list, base::Passed(&chunks), callback));
 }
 
 void LocalSafeBrowsingDatabaseManager::DeleteChunks(
     std::unique_ptr<std::vector<SBChunkDelete>> chunk_deletes) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   safe_browsing_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&LocalSafeBrowsingDatabaseManager::DeleteDatabaseChunks, this,
-                 base::Passed(&chunk_deletes)));
+      base::BindOnce(&LocalSafeBrowsingDatabaseManager::DeleteDatabaseChunks,
+                     this, base::Passed(&chunk_deletes)));
 }
 
 void LocalSafeBrowsingDatabaseManager::UpdateStarted() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   DCHECK(!update_in_progress_);
   update_in_progress_ = true;
 }
 
 void LocalSafeBrowsingDatabaseManager::UpdateFinished(bool update_succeeded) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   if (update_in_progress_) {
     update_in_progress_ = false;
     safe_browsing_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&LocalSafeBrowsingDatabaseManager::DatabaseUpdateFinished,
-                   this, update_succeeded));
+        base::BindOnce(
+            &LocalSafeBrowsingDatabaseManager::DatabaseUpdateFinished, this,
+            update_succeeded));
   }
 }
 
 void LocalSafeBrowsingDatabaseManager::ResetDatabase() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   safe_browsing_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&LocalSafeBrowsingDatabaseManager::OnResetDatabase, this));
+      base::BindOnce(&LocalSafeBrowsingDatabaseManager::OnResetDatabase, this));
 }
 
 void LocalSafeBrowsingDatabaseManager::StartOnIOThread(
     net::URLRequestContextGetter* request_context_getter,
     const V4ProtocolConfig& config) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   SafeBrowsingDatabaseManager::StartOnIOThread(request_context_getter, config);
 
   if (enabled_)
     return;
@@ skipping 79 matching lines @@
   //  * If |database_| is NULL, then either no creation request is in flight, in
   //    which case we don't need to do anything, or one is in flight, in which
   //    case the database will be recreated before our deletion request is
   //    handled, and could be used on the IO thread in that time period, leading
   //    to the same problem as above.
   // Checking DatabaseAvailable() avoids both of these.
   if (DatabaseAvailable()) {
     closing_database_ = true;
     safe_browsing_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&LocalSafeBrowsingDatabaseManager::OnCloseDatabase, this));
+        base::BindOnce(&LocalSafeBrowsingDatabaseManager::OnCloseDatabase,
+                       this));
   }
 
   // Delete pending checks, calling back any clients with 'SB_THREAT_TYPE_SAFE'.
   // We have to do this after the db thread returns because methods on it can
   // have copies of these pointers, so deleting them might lead to accessing
   // garbage.
   for (const auto& check : checks_) {
     if (check.first->client)
       check.first->OnSafeBrowsingResult();
   }
 
   checks_.clear();
   gethash_requests_.clear();
 }
 
 bool LocalSafeBrowsingDatabaseManager::DatabaseAvailable() const {
   base::AutoLock lock(database_lock_);
   return !closing_database_ && (database_ != NULL);
 }
 
 bool LocalSafeBrowsingDatabaseManager::MakeDatabaseAvailable() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   if (DatabaseAvailable())
     return true;
   safe_browsing_task_runner_->PostTask(
-      FROM_HERE, base::Bind(base::IgnoreResult(
-                                &LocalSafeBrowsingDatabaseManager::GetDatabase),
-                            this));
+      FROM_HERE,
+      base::BindOnce(
+          base::IgnoreResult(&LocalSafeBrowsingDatabaseManager::GetDatabase),
+          this));
   return false;
 }
 
 SafeBrowsingDatabase* LocalSafeBrowsingDatabaseManager::GetDatabase() {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
 
   if (database_)
     return database_;
 
   const base::TimeTicks before = base::TimeTicks::Now();
   std::unique_ptr<SafeBrowsingDatabase> database = SafeBrowsingDatabase::Create(
       safe_browsing_task_runner_, enable_download_protection_,
       enable_csd_whitelist_, enable_download_whitelist_,
       enable_extension_blacklist_, enable_ip_blacklist_,
       enable_unwanted_software_blacklist_, enable_module_whitelist_);
 
   database->Init(SafeBrowsingService::GetBaseFilename());
   {
     // Acquiring the lock here guarantees correct ordering between the writes to
     // the new database object above, and the setting of |database_| below.
     base::AutoLock lock(database_lock_);
     database_ = database.release();
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&LocalSafeBrowsingDatabaseManager::DatabaseLoadComplete,
-                 this));
+      base::BindOnce(&LocalSafeBrowsingDatabaseManager::DatabaseLoadComplete,
+                     this));
 
   UMA_HISTOGRAM_TIMES("SB2.DatabaseOpen", base::TimeTicks::Now() - before);
   return database_;
 }
 
 void LocalSafeBrowsingDatabaseManager::OnCheckDone(SafeBrowsingCheck* check) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!enabled_)
     return;
@@ skipping 24 matching lines @@
       requestors.push_back(check);
       gethash_requests_[prefix] = requestors;
     }
 
     // Reset the start time so that we can measure the network time without the
     // database time.
     check->start = base::TimeTicks::Now();
 
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&LocalSafeBrowsingDatabaseManager::OnRequestFullHash, this,
-                   check));
+        base::BindOnce(&LocalSafeBrowsingDatabaseManager::OnRequestFullHash,
+                       this, check));
   } else {
     // We may have cached results for previous GetHash queries.  Since
     // this data comes from cache, don't histogram hits.
     HandleOneCheck(check, check->cache_hits);
   }
 }
 
 void LocalSafeBrowsingDatabaseManager::OnRequestFullHash(
     SafeBrowsingCheck* check) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   check->extended_reporting_level = GetExtendedReporting();
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&LocalSafeBrowsingDatabaseManager::RequestFullHash, this,
-                 check));
+      base::BindOnce(&LocalSafeBrowsingDatabaseManager::RequestFullHash, this,
+                     check));
 }
 
 ExtendedReportingLevel
 LocalSafeBrowsingDatabaseManager::GetExtendedReporting() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Determine if the last used profile is opted into extended reporting.
   // Note: It is possible that the last used profile is not the one triggers
   // the hash request, but not very likely.
   ExtendedReportingLevel extended_reporting_level = SBER_LEVEL_OFF;
@@ skipping 32 matching lines @@
   database_update_in_progress_ = true;
   GetDatabase();  // This guarantees that |database_| is non-NULL.
   if (database_->UpdateStarted(&lists)) {
     database_error = false;
   } else {
     database_->UpdateFinished(false);
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(
+      base::BindOnce(
           &LocalSafeBrowsingDatabaseManager::BeforeGetAllChunksFromDatabase,
           this, lists, database_error, callback));
 }
 
 void LocalSafeBrowsingDatabaseManager::BeforeGetAllChunksFromDatabase(
     const std::vector<SBListChunkRanges>& lists,
     bool database_error,
     GetChunksCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   ExtendedReportingLevel extended_reporting_level = GetExtendedReporting();
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&LocalSafeBrowsingDatabaseManager::OnGetAllChunksFromDatabase,
-                 this, lists, database_error, extended_reporting_level,
-                 callback));
+      base::BindOnce(
+          &LocalSafeBrowsingDatabaseManager::OnGetAllChunksFromDatabase, this,
+          lists, database_error, extended_reporting_level, callback));
 }
 
 void LocalSafeBrowsingDatabaseManager::OnGetAllChunksFromDatabase(
     const std::vector<SBListChunkRanges>& lists,
     bool database_error,
     ExtendedReportingLevel reporting_level,
     GetChunksCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (enabled_)
     callback.Run(lists, database_error, reporting_level);
@@ skipping 38 matching lines @@
 
 void LocalSafeBrowsingDatabaseManager::AddDatabaseChunks(
     const std::string& list_name,
     std::unique_ptr<std::vector<std::unique_ptr<SBChunkData>>> chunks,
     AddChunksCallback callback) {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
   if (chunks)
     GetDatabase()->InsertChunks(list_name, *chunks);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&LocalSafeBrowsingDatabaseManager::OnAddChunksComplete, this,
-                 callback));
+      base::BindOnce(&LocalSafeBrowsingDatabaseManager::OnAddChunksComplete,
+                     this, callback));
 }
 
 void LocalSafeBrowsingDatabaseManager::DeleteDatabaseChunks(
     std::unique_ptr<std::vector<SBChunkDelete>> chunk_deletes) {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
   if (chunk_deletes)
     GetDatabase()->DeleteChunks(*chunk_deletes);
 }
 
 void LocalSafeBrowsingDatabaseManager::DatabaseUpdateFinished(
     bool update_succeeded) {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
   GetDatabase()->UpdateFinished(update_succeeded);
   DCHECK(database_update_in_progress_);
   database_update_in_progress_ = false;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(
+      base::BindOnce(
           &LocalSafeBrowsingDatabaseManager::NotifyDatabaseUpdateFinished, this,
           update_succeeded));
 }
 
 void LocalSafeBrowsingDatabaseManager::OnCloseDatabase() {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(closing_database_);
 
   // Because |closing_database_| is true, nothing on the IO thread will be
   // accessing the database, so it's safe to delete and then NULL the pointer.
@@ skipping 190 matching lines @@
       new base::WeakPtrFactory<LocalSafeBrowsingDatabaseManager>(this));
   SafeBrowsingCheck* check_ptr = check.get();
   checks_[check_ptr] = std::move(check);
 
   base::PostTaskAndReplyWithResult(
       safe_browsing_task_runner_.get(), FROM_HERE, task,
       base::Bind(&LocalSafeBrowsingDatabaseManager::OnAsyncCheckDone,
                  check_ptr->weak_ptr_factory_->GetWeakPtr(), check_ptr));
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&LocalSafeBrowsingDatabaseManager::TimeoutCallback,
-                 check_ptr->weak_ptr_factory_->GetWeakPtr(), check_ptr),
+      base::BindOnce(&LocalSafeBrowsingDatabaseManager::TimeoutCallback,
+                     check_ptr->weak_ptr_factory_->GetWeakPtr(), check_ptr),
       check_timeout_);
 }
 
 bool LocalSafeBrowsingDatabaseManager::IsDownloadProtectionEnabled() const {
   return enable_download_protection_;
 }
 
 }  // namespace safe_browsing