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

chrome/browser/extensions/blacklist.cc

 // Copyright 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/extensions/blacklist.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/bind.h"
@@ skipping 61 matching lines @@
   typedef base::Callback<void(const std::set<std::string>&)> OnResultCallback;
 
   // Constructs a client to query the database manager for |extension_ids| and
   // run |callback| with the IDs of those which have been blacklisted.
   SafeBrowsingClientImpl(
       const std::set<std::string>& extension_ids,
       const OnResultCallback& callback)
       : callback_task_runner_(base::ThreadTaskRunnerHandle::Get()),
         callback_(callback) {
     BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(&SafeBrowsingClientImpl::StartCheck, this,
-                   g_database_manager.Get().get(),
-                   extension_ids));
+        BrowserThread::IO, FROM_HERE,
+        base::BindOnce(&SafeBrowsingClientImpl::StartCheck, this,
+                       g_database_manager.Get().get(), extension_ids));
   }
 
  private:
   friend class base::RefCountedThreadSafe<SafeBrowsingClientImpl>;
   ~SafeBrowsingClientImpl() override {}
 
   // Pass |database_manager| as a parameter to avoid touching
   // SafeBrowsingService on the IO thread.
   void StartCheck(scoped_refptr<SafeBrowsingDatabaseManager> database_manager,
                   const std::set<std::string>& extension_ids) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     if (database_manager->CheckExtensionIDs(extension_ids, this)) {
       // Definitely not blacklisted. Callback immediately.
       callback_task_runner_->PostTask(
-          FROM_HERE,
-          base::Bind(callback_, std::set<std::string>()));
+          FROM_HERE, base::BindOnce(callback_, std::set<std::string>()));
       return;
     }
     // Something might be blacklisted, response will come in
     // OnCheckExtensionsResult.
     AddRef();  // Balanced in OnCheckExtensionsResult
   }
 
   void OnCheckExtensionsResult(const std::set<std::string>& hits) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
-    callback_task_runner_->PostTask(FROM_HERE, base::Bind(callback_, hits));
+    callback_task_runner_->PostTask(FROM_HERE, base::BindOnce(callback_, hits));
     Release();  // Balanced in StartCheck.
   }
 
   scoped_refptr<base::SingleThreadTaskRunner> callback_task_runner_;
   OnResultCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingClientImpl);
 };
 
 void CheckOneExtensionState(
@@ skipping 65 matching lines @@
 Blacklist* Blacklist::Get(content::BrowserContext* context) {
   return BlacklistFactory::GetForBrowserContext(context);
 }
 
 void Blacklist::GetBlacklistedIDs(const std::set<std::string>& ids,
                                   const GetBlacklistedIDsCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (ids.empty() || !g_database_manager.Get().get().get()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(callback, BlacklistStateMap()));
+        FROM_HERE, base::BindOnce(callback, BlacklistStateMap()));
     return;
   }
 
   // Constructing the SafeBrowsingClientImpl begins the process of asking
   // safebrowsing for the blacklisted extensions. The set of blacklisted
   // extensions returned by SafeBrowsing will then be passed to
   // GetBlacklistStateIDs to get the particular BlacklistState for each id.
   new SafeBrowsingClientImpl(
       ids, base::Bind(&Blacklist::GetBlacklistStateForIDs, AsWeakPtr(),
                       callback));
@@ skipping 142 matching lines @@
 
 void Blacklist::Observe(int type,
                         const content::NotificationSource& source,
                         const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE, type);
   for (auto& observer : observers_)
     observer.OnBlacklistUpdated();
 }
 
 }  // namespace extensions