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

chrome/browser/extensions/api/file_system/file_system_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/file_system/file_system_api.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
@@ skipping 207 matching lines @@
     FileInfoOptCallback;
 
 // Passes optional file info to the UI thread depending on |result| and |info|.
 void PassFileInfoToUIThread(const FileInfoOptCallback& callback,
                             base::File::Error result,
                             const base::File::Info& info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   std::unique_ptr<base::File::Info> file_info(
       result == base::File::FILE_OK ? new base::File::Info(info) : NULL);
   content::BrowserThread::PostTask(
-      content::BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(callback, base::Passed(&file_info)));
+      content::BrowserThread::UI, FROM_HERE,
+      base::BindOnce(callback, base::Passed(&file_info)));
 }
 
 // Gets a WebContents instance handle for a platform app hosted in
 // |render_frame_host|. If not found, then returns NULL.
 content::WebContents* GetWebContentsForRenderFrameHost(
     Profile* profile,
     content::RenderFrameHost* render_frame_host) {
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(render_frame_host);
   // Check if there is an app window associated with the web contents; if not,
@@ skipping 333 matching lines @@
     error_ = kRequiresFileSystemWriteError;
     return false;
   }
 
   if (!app_file_handler_util::ValidateFileEntryAndGetPath(
           filesystem_name, filesystem_path,
           render_frame_host()->GetProcess()->GetID(), &path_, &error_))
     return false;
 
   content::BrowserThread::PostTaskAndReply(
-      content::BrowserThread::FILE,
-      FROM_HERE,
-      base::Bind(
+      content::BrowserThread::FILE, FROM_HERE,
+      base::BindOnce(
           &FileSystemGetWritableEntryFunction::SetIsDirectoryOnFileThread,
           this),
-      base::Bind(
+      base::BindOnce(
           &FileSystemGetWritableEntryFunction::CheckPermissionAndSendResponse,
           this));
   return true;
 }
 
 void FileSystemGetWritableEntryFunction::CheckPermissionAndSendResponse() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (is_directory_ &&
       !extension_->permissions_data()->HasAPIPermission(
           APIPermission::kFileSystemDirectory)) {
@@ skipping 43 matching lines @@
              ui::SelectFileDialog::Type picker_type)
       : function_(function) {
     select_file_dialog_ = ui::SelectFileDialog::Create(
         this, new ChromeSelectFilePolicy(web_contents));
     gfx::NativeWindow owning_window = web_contents ?
         platform_util::GetTopLevel(web_contents->GetNativeView()) :
         NULL;
 
     if (g_skip_picker_for_test) {
       if (g_use_suggested_path_for_test) {
-        content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-            base::Bind(
+        content::BrowserThread::PostTask(
+            content::BrowserThread::UI, FROM_HERE,
+            base::BindOnce(
                 &FileSystemChooseEntryFunction::FilePicker::FileSelected,
                 base::Unretained(this), suggested_name, 1,
                 static_cast<void*>(NULL)));
       } else if (g_path_to_be_picked_for_test) {
         content::BrowserThread::PostTask(
             content::BrowserThread::UI, FROM_HERE,
-            base::Bind(
+            base::BindOnce(
                 &FileSystemChooseEntryFunction::FilePicker::FileSelected,
                 base::Unretained(this), *g_path_to_be_picked_for_test, 1,
                 static_cast<void*>(NULL)));
       } else if (g_paths_to_be_picked_for_test) {
         content::BrowserThread::PostTask(
-            content::BrowserThread::UI,
-            FROM_HERE,
-            base::Bind(
+            content::BrowserThread::UI, FROM_HERE,
+            base::BindOnce(
                 &FileSystemChooseEntryFunction::FilePicker::MultiFilesSelected,
-                base::Unretained(this),
-                *g_paths_to_be_picked_for_test,
+                base::Unretained(this), *g_paths_to_be_picked_for_test,
                 static_cast<void*>(NULL)));
       } else {
-        content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-            base::Bind(
-                &FileSystemChooseEntryFunction::FilePicker::
-                    FileSelectionCanceled,
-                base::Unretained(this), static_cast<void*>(NULL)));
+        content::BrowserThread::PostTask(
+            content::BrowserThread::UI, FROM_HERE,
+            base::BindOnce(&FileSystemChooseEntryFunction::FilePicker::
+                               FileSelectionCanceled,
+                           base::Unretained(this), static_cast<void*>(NULL)));
       }
       return;
     }
 
     select_file_dialog_->SelectFile(picker_type,
                                     base::string16(),
                                     suggested_name,
                                     &file_type_info,
                                     0,
                                     base::FilePath::StringType(),
@@ skipping 173 matching lines @@
     }
 
     DCHECK_EQ(paths.size(), 1u);
     bool non_native_path = false;
 #if defined(OS_CHROMEOS)
     non_native_path =
         file_manager::util::IsUnderNonNativeLocalPath(GetProfile(), paths[0]);
 #endif
 
     content::BrowserThread::PostTask(
-        content::BrowserThread::FILE,
-        FROM_HERE,
-        base::Bind(
+        content::BrowserThread::FILE, FROM_HERE,
+        base::BindOnce(
             &FileSystemChooseEntryFunction::ConfirmDirectoryAccessOnFileThread,
-            this,
-            non_native_path,
-            paths,
-            web_contents));
+            this, non_native_path, paths, web_contents));
     return;
   }
 
   OnDirectoryAccessConfirmed(paths);
 }
 
 void FileSystemChooseEntryFunction::FileSelectionCanceled() {
   error_ = kUserCancelled;
   SendResponse(false);
 }
 
 void FileSystemChooseEntryFunction::ConfirmDirectoryAccessOnFileThread(
     bool non_native_path,
     const std::vector<base::FilePath>& paths,
     content::WebContents* web_contents) {
   const base::FilePath check_path =
       non_native_path ? paths[0] : base::MakeAbsoluteFilePath(paths[0]);
   if (check_path.empty()) {
     content::BrowserThread::PostTask(
-        content::BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&FileSystemChooseEntryFunction::FileSelectionCanceled,
-                   this));
+        content::BrowserThread::UI, FROM_HERE,
+        base::BindOnce(&FileSystemChooseEntryFunction::FileSelectionCanceled,
+                       this));
     return;
   }
 
   for (size_t i = 0; i < arraysize(kGraylistedPaths); i++) {
     base::FilePath graylisted_path;
     if (PathService::Get(kGraylistedPaths[i], &graylisted_path) &&
         (check_path == graylisted_path ||
          check_path.IsParent(graylisted_path))) {
       if (g_skip_directory_confirmation_for_test) {
         if (g_allow_directory_access_for_test) {
           break;
         } else {
           content::BrowserThread::PostTask(
-              content::BrowserThread::UI,
-              FROM_HERE,
-              base::Bind(&FileSystemChooseEntryFunction::FileSelectionCanceled,
-                         this));
+              content::BrowserThread::UI, FROM_HERE,
+              base::BindOnce(
+                  &FileSystemChooseEntryFunction::FileSelectionCanceled, this));
         }
         return;
       }
 
       content::BrowserThread::PostTask(
-          content::BrowserThread::UI,
-          FROM_HERE,
-          base::Bind(
+          content::BrowserThread::UI, FROM_HERE,
+          base::BindOnce(
               CreateDirectoryAccessConfirmationDialog,
               app_file_handler_util::HasFileSystemWritePermission(
                   extension_.get()),
-              base::UTF8ToUTF16(extension_->name()),
-              web_contents,
+              base::UTF8ToUTF16(extension_->name()), web_contents,
               base::Bind(
                   &FileSystemChooseEntryFunction::OnDirectoryAccessConfirmed,
-                  this,
-                  paths),
+                  this, paths),
               base::Bind(&FileSystemChooseEntryFunction::FileSelectionCanceled,
                          this)));
       return;
     }
   }
 
   content::BrowserThread::PostTask(
-      content::BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&FileSystemChooseEntryFunction::OnDirectoryAccessConfirmed,
-                 this, paths));
+      content::BrowserThread::UI, FROM_HERE,
+      base::BindOnce(&FileSystemChooseEntryFunction::OnDirectoryAccessConfirmed,
+                     this, paths));
 }
 
 void FileSystemChooseEntryFunction::OnDirectoryAccessConfirmed(
     const std::vector<base::FilePath>& paths) {
   if (app_file_handler_util::HasFileSystemWritePermission(extension_.get())) {
     PrepareFilesForWritableApp(paths);
     return;
   }
 
   // Don't need to check the file, it's for reading.
@@ skipping 191 matching lines @@
             ->GetFileSystemContext();
     const storage::FileSystemURL url = context->CreateCrackedFileSystemURL(
         site,
         storage::kFileSystemTypeIsolated,
         IsolatedContext::GetInstance()
             ->CreateVirtualRootPath(filesystem_id)
             .Append(base::FilePath::FromUTF8Unsafe(filesystem_path)));
 
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
-        base::Bind(
+        base::BindOnce(
             base::IgnoreResult(
                 &storage::FileSystemOperationRunner::GetMetadata),
             context->operation_runner()->AsWeakPtr(), url,
             storage::FileSystemOperation::GET_METADATA_FIELD_IS_DIRECTORY,
             base::Bind(
                 &PassFileInfoToUIThread,
                 base::Bind(&FileSystemRetainEntryFunction::RetainFileEntry,
                            this, entry_id, path))));
     return true;
   }
@@ skipping 263 matching lines @@
     return RespondNow(Error(kNotSupportedOnNonKioskSessionError));
   std::vector<api::file_system::Volume> result_volume_list;
   FillVolumeList(chrome_details_.GetProfile(), &result_volume_list);
 
   return RespondNow(ArgumentList(
       api::file_system::GetVolumeList::Results::Create(result_volume_list)));
 }
 #endif
 
 }  // namespace extensions