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

chrome/browser/media_galleries/fileapi/native_media_file_util.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/media_galleries/fileapi/native_media_file_util.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 138 matching lines @@
 void NativeMediaFileUtil::CreateDirectory(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     bool exclusive,
     bool recursive,
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   storage::FileSystemOperationContext* context_ptr = context.get();
   const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&NativeMediaFileUtil::CreateDirectoryOnTaskRunnerThread,
-                 weak_factory_.GetWeakPtr(), base::Passed(&context),
-                 url, exclusive, recursive, callback));
+      base::BindOnce(&NativeMediaFileUtil::CreateDirectoryOnTaskRunnerThread,
+                     weak_factory_.GetWeakPtr(), base::Passed(&context), url,
+                     exclusive, recursive, callback));
   DCHECK(success);
 }
 
 void NativeMediaFileUtil::GetFileInfo(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     int /* fields */,
     const GetFileInfoCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   storage::FileSystemOperationContext* context_ptr = context.get();
   const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&NativeMediaFileUtil::GetFileInfoOnTaskRunnerThread,
-                 weak_factory_.GetWeakPtr(), base::Passed(&context),
-                 url, callback));
+      base::BindOnce(&NativeMediaFileUtil::GetFileInfoOnTaskRunnerThread,
+                     weak_factory_.GetWeakPtr(), base::Passed(&context), url,
+                     callback));
   DCHECK(success);
 }
 
 void NativeMediaFileUtil::ReadDirectory(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     const ReadDirectoryCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   storage::FileSystemOperationContext* context_ptr = context.get();
   const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&NativeMediaFileUtil::ReadDirectoryOnTaskRunnerThread,
-                 weak_factory_.GetWeakPtr(), base::Passed(&context),
-                 url, callback));
+      base::BindOnce(&NativeMediaFileUtil::ReadDirectoryOnTaskRunnerThread,
+                     weak_factory_.GetWeakPtr(), base::Passed(&context), url,
+                     callback));
   DCHECK(success);
 }
 
 void NativeMediaFileUtil::Touch(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     const base::Time& last_access_time,
     const base::Time& last_modified_time,
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
@@ skipping 13 matching lines @@
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& src_url,
     const storage::FileSystemURL& dest_url,
     CopyOrMoveOption option,
     const CopyFileProgressCallback& progress_callback,
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   storage::FileSystemOperationContext* context_ptr = context.get();
   const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&NativeMediaFileUtil::CopyOrMoveFileLocalOnTaskRunnerThread,
-                 weak_factory_.GetWeakPtr(), base::Passed(&context),
-                 src_url, dest_url, option, true /* copy */, callback));
+      base::BindOnce(
+          &NativeMediaFileUtil::CopyOrMoveFileLocalOnTaskRunnerThread,
+          weak_factory_.GetWeakPtr(), base::Passed(&context), src_url, dest_url,
+          option, true /* copy */, callback));
   DCHECK(success);
 }
 
 void NativeMediaFileUtil::MoveFileLocal(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& src_url,
     const storage::FileSystemURL& dest_url,
     CopyOrMoveOption option,
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   storage::FileSystemOperationContext* context_ptr = context.get();
   const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&NativeMediaFileUtil::CopyOrMoveFileLocalOnTaskRunnerThread,
-                 weak_factory_.GetWeakPtr(), base::Passed(&context),
-                 src_url, dest_url, option, false /* copy */, callback));
+      base::BindOnce(
+          &NativeMediaFileUtil::CopyOrMoveFileLocalOnTaskRunnerThread,
+          weak_factory_.GetWeakPtr(), base::Passed(&context), src_url, dest_url,
+          option, false /* copy */, callback));
   DCHECK(success);
 }
 
 void NativeMediaFileUtil::CopyInForeignFile(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const base::FilePath& src_file_path,
     const storage::FileSystemURL& dest_url,
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   storage::FileSystemOperationContext* context_ptr = context.get();
   const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&NativeMediaFileUtil::CopyInForeignFileOnTaskRunnerThread,
-                 weak_factory_.GetWeakPtr(), base::Passed(&context),
-                 src_file_path, dest_url, callback));
+      base::BindOnce(&NativeMediaFileUtil::CopyInForeignFileOnTaskRunnerThread,
+                     weak_factory_.GetWeakPtr(), base::Passed(&context),
+                     src_file_path, dest_url, callback));
   DCHECK(success);
 }
 
 void NativeMediaFileUtil::DeleteFile(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   storage::FileSystemOperationContext* context_ptr = context.get();
   const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&NativeMediaFileUtil::DeleteFileOnTaskRunnerThread,
-                 weak_factory_.GetWeakPtr(), base::Passed(&context),
-                 url, callback));
+      base::BindOnce(&NativeMediaFileUtil::DeleteFileOnTaskRunnerThread,
+                     weak_factory_.GetWeakPtr(), base::Passed(&context), url,
+                     callback));
   DCHECK(success);
 }
 
 // This is needed to support Copy and Move.
 void NativeMediaFileUtil::DeleteDirectory(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   storage::FileSystemOperationContext* context_ptr = context.get();
   const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&NativeMediaFileUtil::DeleteDirectoryOnTaskRunnerThread,
-                 weak_factory_.GetWeakPtr(), base::Passed(&context),
-                 url, callback));
+      base::BindOnce(&NativeMediaFileUtil::DeleteDirectoryOnTaskRunnerThread,
+                     weak_factory_.GetWeakPtr(), base::Passed(&context), url,
+                     callback));
   DCHECK(success);
 }
 
 void NativeMediaFileUtil::DeleteRecursively(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   callback.Run(base::File::FILE_ERROR_INVALID_OPERATION);
 }
 
 void NativeMediaFileUtil::CreateSnapshotFile(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     const CreateSnapshotFileCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   storage::FileSystemOperationContext* context_ptr = context.get();
   const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&NativeMediaFileUtil::CreateSnapshotFileOnTaskRunnerThread,
-                 weak_factory_.GetWeakPtr(), base::Passed(&context),
-                 url, callback));
+      base::BindOnce(&NativeMediaFileUtil::CreateSnapshotFileOnTaskRunnerThread,
+                     weak_factory_.GetWeakPtr(), base::Passed(&context), url,
+                     callback));
   DCHECK(success);
 }
 
 void NativeMediaFileUtil::CreateDirectoryOnTaskRunnerThread(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     bool exclusive,
     bool recursive,
     const StatusCallback& callback) {
   DCHECK(IsOnTaskRunnerThread(context.get()));
   base::File::Error error =
       CreateDirectorySync(context.get(), url, exclusive, recursive);
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(callback, error));
+  content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
+                                   base::BindOnce(callback, error));
 }
 
 void NativeMediaFileUtil::GetFileInfoOnTaskRunnerThread(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     const GetFileInfoCallback& callback) {
   DCHECK(IsOnTaskRunnerThread(context.get()));
   base::File::Info file_info;
   base::File::Error error =
       GetFileInfoSync(context.get(), url, &file_info, NULL);
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(callback, error, file_info));
+  content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
+                                   base::BindOnce(callback, error, file_info));
 }
 
 void NativeMediaFileUtil::ReadDirectoryOnTaskRunnerThread(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     const ReadDirectoryCallback& callback) {
   DCHECK(IsOnTaskRunnerThread(context.get()));
   EntryList entry_list;
   base::File::Error error =
       ReadDirectorySync(context.get(), url, &entry_list);
   content::BrowserThread::PostTask(
-      content::BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(callback, error, entry_list, false /* has_more */));
+      content::BrowserThread::IO, FROM_HERE,
+      base::BindOnce(callback, error, entry_list, false /* has_more */));
 }
 
 void NativeMediaFileUtil::CopyOrMoveFileLocalOnTaskRunnerThread(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& src_url,
     const storage::FileSystemURL& dest_url,
     CopyOrMoveOption option,
     bool copy,
     const StatusCallback& callback) {
   DCHECK(IsOnTaskRunnerThread(context.get()));
   base::File::Error error =
       CopyOrMoveFileSync(context.get(), src_url, dest_url, option, copy);
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(callback, error));
+  content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
+                                   base::BindOnce(callback, error));
 }
 
 void NativeMediaFileUtil::CopyInForeignFileOnTaskRunnerThread(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const base::FilePath& src_file_path,
     const storage::FileSystemURL& dest_url,
     const StatusCallback& callback) {
   DCHECK(IsOnTaskRunnerThread(context.get()));
   base::File::Error error =
       CopyInForeignFileSync(context.get(), src_file_path, dest_url);
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(callback, error));
+  content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
+                                   base::BindOnce(callback, error));
 }
 
 void NativeMediaFileUtil::DeleteFileOnTaskRunnerThread(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK(IsOnTaskRunnerThread(context.get()));
   base::File::Error error = DeleteFileSync(context.get(), url);
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(callback, error));
+  content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
+                                   base::BindOnce(callback, error));
 }
 
 void NativeMediaFileUtil::DeleteDirectoryOnTaskRunnerThread(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK(IsOnTaskRunnerThread(context.get()));
   base::File::Error error = DeleteDirectorySync(context.get(), url);
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(callback, error));
+  content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
+                                   base::BindOnce(callback, error));
 }
 
 void NativeMediaFileUtil::CreateSnapshotFileOnTaskRunnerThread(
     std::unique_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     const CreateSnapshotFileCallback& callback) {
   DCHECK(IsOnTaskRunnerThread(context.get()));
   base::File::Info file_info;
   base::FilePath platform_path;
   scoped_refptr<storage::ShareableFileReference> file_ref;
   base::File::Error error = CreateSnapshotFileSync(
       context.get(), url, &file_info, &platform_path, &file_ref);
   content::BrowserThread::PostTask(
-      content::BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(callback, error, file_info, platform_path, file_ref));
+      content::BrowserThread::IO, FROM_HERE,
+      base::BindOnce(callback, error, file_info, platform_path, file_ref));
 }
 
 base::File::Error NativeMediaFileUtil::CreateDirectorySync(
     storage::FileSystemOperationContext* context,
     const storage::FileSystemURL& url,
     bool exclusive,
     bool recursive) {
   base::FilePath file_path;
   base::File::Error error = GetLocalFilePath(context, url, &file_path);
   if (error != base::File::FILE_OK)
@@ skipping 235 matching lines @@
     return base::File::FILE_ERROR_FAILED;
 
   if (!file_info.is_directory &&
       !media_path_filter_->Match(file_path)) {
     return failure_error;
   }
 
   *local_file_path = file_path;
   return base::File::FILE_OK;
 }