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

chrome/browser/extensions/crx_installer.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/extensions/crx_installer.h"
 
 #include <map>
 #include <set>
 #include <utility>
 
@@ skipping 169 matching lines @@
 
   NotifyCrxInstallBegin();
 
   source_file_ = source_file.path;
 
   scoped_refptr<SandboxedUnpacker> unpacker(new SandboxedUnpacker(
       install_source_, creation_flags_, install_directory_,
       installer_task_runner_.get(), this));
 
   if (!installer_task_runner_->PostTask(
-          FROM_HERE, base::Bind(&SandboxedUnpacker::StartWithCrx,
-                                unpacker, source_file))) {
+          FROM_HERE, base::BindOnce(&SandboxedUnpacker::StartWithCrx, unpacker,
+                                    source_file))) {
     NOTREACHED();
   }
 }
 
 void CrxInstaller::InstallUserScript(const base::FilePath& source_file,
                                      const GURL& download_url) {
   DCHECK(!download_url.is_empty());
 
   NotifyCrxInstallBegin();
 
   source_file_ = source_file;
   download_url_ = download_url;
 
   if (!installer_task_runner_->PostTask(
           FROM_HERE,
-          base::Bind(&CrxInstaller::ConvertUserScriptOnFileThread, this)))
+          base::BindOnce(&CrxInstaller::ConvertUserScriptOnFileThread, this)))
     NOTREACHED();
 }
 
 void CrxInstaller::ConvertUserScriptOnFileThread() {
   base::string16 error;
   scoped_refptr<Extension> extension = ConvertUserScriptToExtension(
       source_file_, download_url_, install_directory_, &error);
   if (!extension.get()) {
     ReportFailureFromFileThread(CrxInstallError(error));
     return;
   }
 
   OnUnpackSuccess(extension->path(), extension->path(), nullptr,
                   extension.get(), SkBitmap());
 }
 
 void CrxInstaller::InstallWebApp(const WebApplicationInfo& web_app) {
   NotifyCrxInstallBegin();
 
   if (!installer_task_runner_->PostTask(
-          FROM_HERE,
-          base::Bind(&CrxInstaller::ConvertWebAppOnFileThread, this, web_app)))
+          FROM_HERE, base::BindOnce(&CrxInstaller::ConvertWebAppOnFileThread,
+                                    this, web_app)))
     NOTREACHED();
 }
 
 void CrxInstaller::ConvertWebAppOnFileThread(
     const WebApplicationInfo& web_app) {
   scoped_refptr<Extension> extension(ConvertWebAppToExtension(
       web_app, base::Time::Now(), install_directory_));
   if (!extension.get()) {
     // Validation should have stopped any potential errors before getting here.
     NOTREACHED() << "Could not convert web app to extension.";
@@ skipping 206 matching lines @@
   // We don't have to delete the unpack dir explicity since it is a child of
   // the temp dir.
   unpacked_extension_root_ = extension_dir;
 
   CrxInstallError error = AllowInstall(extension);
   if (error.type() != CrxInstallError::ERROR_NONE) {
     ReportFailureFromFileThread(error);
     return;
   }
 
-  if (!BrowserThread::PostTask(BrowserThread::UI,
-                               FROM_HERE,
-                               base::Bind(&CrxInstaller::CheckInstall, this)))
+  if (!BrowserThread::PostTask(
+          BrowserThread::UI, FROM_HERE,
+          base::BindOnce(&CrxInstaller::CheckInstall, this)))
     NOTREACHED();
 }
 
 void CrxInstaller::CheckInstall() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ExtensionService* service = service_weak_.get();
   if (!service || service->browser_terminating())
     return;
 
   // TODO(crbug.com/420147): Move this code to a utility class to avoid
@@ skipping 206 matching lines @@
 }
 
 void CrxInstaller::UpdateCreationFlagsAndCompleteInstall() {
   creation_flags_ = extension()->creation_flags() | Extension::REQUIRE_KEY;
   // If the extension was already installed and had file access, also grant file
   // access to the updated extension.
   if (ExtensionPrefs::Get(profile())->AllowFileAccess(extension()->id()))
     creation_flags_ |= Extension::ALLOW_FILE_ACCESS;
 
   if (!installer_task_runner_->PostTask(
-          FROM_HERE, base::Bind(&CrxInstaller::CompleteInstall, this))) {
+          FROM_HERE, base::BindOnce(&CrxInstaller::CompleteInstall, this))) {
     NOTREACHED();
   }
 }
 
 void CrxInstaller::CompleteInstall() {
   DCHECK(installer_task_runner_->RunsTasksOnCurrentThread());
 
   if (current_version_.IsValid() &&
       current_version_.CompareTo(*(extension()->version())) > 0) {
     ReportFailureFromFileThread(CrxInstallError(
@@ skipping 50 matching lines @@
   } else {
     LOG(ERROR) << error << " " << extension_id << " " << download_url_;
     ReportFailureFromFileThread(CrxInstallError(base::UTF8ToUTF16(error)));
   }
 }
 
 void CrxInstaller::ReportFailureFromFileThread(const CrxInstallError& error) {
   DCHECK(installer_task_runner_->RunsTasksOnCurrentThread());
   if (!BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
-          base::Bind(&CrxInstaller::ReportFailureFromUIThread, this, error))) {
+          base::BindOnce(&CrxInstaller::ReportFailureFromUIThread, this,
+                         error))) {
     NOTREACHED();
   }
 }
 
 void CrxInstaller::ReportFailureFromUIThread(const CrxInstallError& error) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!service_weak_.get() || service_weak_->browser_terminating())
     return;
 
@@ skipping 23 matching lines @@
 
 void CrxInstaller::ReportSuccessFromFileThread() {
   DCHECK(installer_task_runner_->RunsTasksOnCurrentThread());
 
   // Tracking number of extensions installed by users
   if (install_cause() == extension_misc::INSTALL_CAUSE_USER_DOWNLOAD)
     UMA_HISTOGRAM_ENUMERATION("Extensions.ExtensionInstalled", 1, 2);
 
   if (!BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
-          base::Bind(&CrxInstaller::ReportSuccessFromUIThread, this)))
+          base::BindOnce(&CrxInstaller::ReportSuccessFromUIThread, this)))
     NOTREACHED();
 
   // Delete temporary files.
   CleanupTempFiles();
 }
 
 void CrxInstaller::ReportSuccessFromUIThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!service_weak_.get() || service_weak_->browser_terminating())
@@ skipping 42 matching lines @@
   InstallTrackerFactory::GetForBrowserContext(profile())
       ->OnFinishCrxInstall(success ? extension()->id() : expected_id_, success);
 
   if (success)
     ConfirmReEnable();
 }
 
 void CrxInstaller::CleanupTempFiles() {
   if (!installer_task_runner_->RunsTasksOnCurrentThread()) {
     if (!installer_task_runner_->PostTask(
-            FROM_HERE,
-            base::Bind(&CrxInstaller::CleanupTempFiles, this))) {
+            FROM_HERE, base::BindOnce(&CrxInstaller::CleanupTempFiles, this))) {
       NOTREACHED();
     }
     return;
   }
 
   // Delete the temp directory and crx file as necessary.
   if (!temp_dir_.value().empty()) {
     file_util::DeleteFile(temp_dir_, true);
     temp_dir_ = base::FilePath();
   }
@@ skipping 45 matching lines @@
         ExtensionInstallPrompt::GetReEnablePromptTypeForExtension(
             service->profile(), extension());
     client_->ShowDialog(base::Bind(&CrxInstaller::OnInstallPromptDone, this),
                         extension(), nullptr,
                         base::MakeUnique<ExtensionInstallPrompt::Prompt>(type),
                         ExtensionInstallPrompt::GetDefaultShowDialogCallback());
   }
 }
 
 }  // namespace extensions