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

chrome/browser/extensions/api/developer_private/developer_private_api.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/api/developer_private/developer_private_api.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 1054 matching lines @@
   project_name = directory_url_str.substr(pos + 1);
   project_base_url_ = directory_url_str.substr(0, pos + 1);
 
   base::FilePath project_path(GetProfile()->GetPath());
   project_path = project_path.AppendASCII(kUnpackedAppsFolder);
   project_path = project_path.Append(
       base::FilePath::FromUTF8Unsafe(project_name));
 
   project_base_path_ = project_path;
 
-  content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(&DeveloperPrivateLoadDirectoryFunction::
-                     ClearExistingDirectoryContent,
-                 this,
-                 project_base_path_));
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE, FROM_HERE,
+      base::BindOnce(
+          &DeveloperPrivateLoadDirectoryFunction::ClearExistingDirectoryContent,
+          this, project_base_path_));
   return true;
 }
 
 void DeveloperPrivateLoadDirectoryFunction::Load() {
   ExtensionService* service = GetExtensionService(GetProfile());
   UnpackedInstaller::Create(service)->Load(project_base_path_);
 
   // TODO(grv) : The unpacked installer should fire an event when complete
   // and return the extension_id.
   SetResult(base::MakeUnique<base::Value>("-1"));
   SendResponse(true);
 }
 
 void DeveloperPrivateLoadDirectoryFunction::ClearExistingDirectoryContent(
     const base::FilePath& project_path) {
 
   // Clear the project directory before copying new files.
   base::DeleteFile(project_path, true /*recursive*/);
 
   pending_copy_operations_count_ = 1;
 
-  content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&DeveloperPrivateLoadDirectoryFunction::
-                 ReadDirectoryByFileSystemAPI,
-                 this, project_path, project_path.BaseName()));
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO, FROM_HERE,
+      base::BindOnce(
+          &DeveloperPrivateLoadDirectoryFunction::ReadDirectoryByFileSystemAPI,
+          this, project_path, project_path.BaseName()));
 }
 
 void DeveloperPrivateLoadDirectoryFunction::ReadDirectoryByFileSystemAPI(
     const base::FilePath& project_path,
     const base::FilePath& destination_path) {
   GURL project_url = GURL(project_base_url_ + destination_path.AsUTF8Unsafe());
   storage::FileSystemURL url = context_->CrackURL(project_url);
 
   context_->operation_runner()->ReadDirectory(
       url, base::Bind(&DeveloperPrivateLoadDirectoryFunction::
@@ skipping 42 matching lines @@
             target_path));
   }
 
   if (!has_more) {
     // Directory copy operation released here.
     pending_copy_operations_count_--;
 
     if (!pending_copy_operations_count_) {
       content::BrowserThread::PostTask(
           content::BrowserThread::UI, FROM_HERE,
-          base::Bind(&DeveloperPrivateLoadDirectoryFunction::SendResponse,
-                     this,
-                     success_));
+          base::BindOnce(&DeveloperPrivateLoadDirectoryFunction::SendResponse,
+                         this, success_));
     }
   }
 }
 
 void DeveloperPrivateLoadDirectoryFunction::SnapshotFileCallback(
     const base::FilePath& target_path,
     base::File::Error result,
     const base::File::Info& file_info,
     const base::FilePath& src_path,
     const scoped_refptr<storage::ShareableFileReference>& file_ref) {
   if (result != base::File::FILE_OK) {
     SetError("Error in copying files from sync filesystem.");
     success_ = false;
     return;
   }
 
-  content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(&DeveloperPrivateLoadDirectoryFunction::CopyFile,
-                 this,
-                 src_path,
-                 target_path));
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE, FROM_HERE,
+      base::BindOnce(&DeveloperPrivateLoadDirectoryFunction::CopyFile, this,
+                     src_path, target_path));
 }
 
 void DeveloperPrivateLoadDirectoryFunction::CopyFile(
     const base::FilePath& src_path,
     const base::FilePath& target_path) {
   if (!base::CreateDirectory(target_path.DirName())) {
     SetError("Error in copying files from sync filesystem.");
     success_ = false;
   }
 
   if (success_)
     base::CopyFile(src_path, target_path);
 
   CHECK(pending_copy_operations_count_ > 0);
   pending_copy_operations_count_--;
 
   if (!pending_copy_operations_count_) {
-    content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-        base::Bind(&DeveloperPrivateLoadDirectoryFunction::Load,
-                   this));
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::BindOnce(&DeveloperPrivateLoadDirectoryFunction::Load, this));
   }
 }
 
 DeveloperPrivateLoadDirectoryFunction::DeveloperPrivateLoadDirectoryFunction()
     : pending_copy_operations_count_(0), success_(true) {}
 
 DeveloperPrivateLoadDirectoryFunction::~DeveloperPrivateLoadDirectoryFunction()
     {}
 
 ExtensionFunction::ResponseAction DeveloperPrivateChoosePathFunction::Run() {
@@ skipping 357 matching lines @@
         update.extension_id, update.command_name, *update.keybinding);
   }
 
   return RespondNow(NoArguments());
 }
 
 
 }  // namespace api
 
 }  // namespace extensions