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

chrome/browser/extensions/api/runtime/chrome_runtime_api_delegate.cc

 // Copyright 2014 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/api/runtime/chrome_runtime_api_delegate.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 191 matching lines @@
 
   ExtensionService* service =
       ExtensionSystem::Get(browser_context_)->extension_service();
   if (reload_info.second >= kFastReloadCount) {
     // Unloading an extension clears all warnings, so first terminate the
     // extension, and then add the warning. Since this is called from an
     // extension function unloading the extension has to be done
     // asynchronously. Fortunately PostTask guarentees FIFO order so just
     // post both tasks.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&ExtensionService::TerminateExtension,
-                              service->AsWeakPtr(), extension_id));
+        FROM_HERE, base::BindOnce(&ExtensionService::TerminateExtension,
+                                  service->AsWeakPtr(), extension_id));
     extensions::WarningSet warnings;
     warnings.insert(
         extensions::Warning::CreateReloadTooFrequentWarning(
             extension_id));
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&extensions::WarningService::NotifyWarningsOnUI,
-                              browser_context_, warnings));
+        FROM_HERE,
+        base::BindOnce(&extensions::WarningService::NotifyWarningsOnUI,
+                       browser_context_, warnings));
   } else {
     // We can't call ReloadExtension directly, since when this method finishes
     // it tries to decrease the reference count for the extension, which fails
     // if the extension has already been reloaded; so instead we post a task.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&ExtensionService::ReloadExtension,
-                              service->AsWeakPtr(), extension_id));
+        FROM_HERE, base::BindOnce(&ExtensionService::ReloadExtension,
+                                  service->AsWeakPtr(), extension_id));
   }
 }
 
 bool ChromeRuntimeAPIDelegate::CheckForUpdates(
     const std::string& extension_id,
     const UpdateCheckCallback& callback) {
   ExtensionSystem* system = ExtensionSystem::Get(browser_context_);
   ExtensionService* service = system->extension_service();
   ExtensionUpdater* updater = service->updater();
   if (!updater) {
     return false;
   }
 
   UpdateCheckInfo& info = update_check_info_[extension_id];
 
   // If not enough time has elapsed, or we have 10 or more outstanding calls,
   // return a status of throttled.
   if (info.backoff->ShouldRejectRequest() || info.callbacks.size() >= 10) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, UpdateCheckResult(true, kUpdateThrottled, "")));
+        FROM_HERE, base::BindOnce(callback, UpdateCheckResult(
+                                                true, kUpdateThrottled, "")));
   } else {
     info.callbacks.push_back(callback);
     updater->CheckExtensionSoon(
         extension_id, base::Bind(&ChromeRuntimeAPIDelegate::UpdateCheckComplete,
                                  base::Unretained(this), extension_id));
   }
   return true;
 }
 
 void ChromeRuntimeAPIDelegate::OpenURL(const GURL& uninstall_url) {
@@ skipping 128 matching lines @@
     const UpdateCheckResult& result) {
   auto it = update_check_info_.find(extension_id);
   if (it == update_check_info_.end())
     return;
   std::vector<UpdateCheckCallback> callbacks;
   it->second.callbacks.swap(callbacks);
   for (const auto& callback : callbacks) {
     callback.Run(result);
   }
 }