[FileSystem] Change callback types in FileSystemOperation to be Once or Repeating.

Bug: 714018
Change-Id: I02bc49853ff630a0422ba0ddc8f08b7412046327
Reviewed-on: https://chromium-review.googlesource.com/1255148Reviewed-by: Stuart Langley <slangley@chromium.org>
Reviewed-by: Victor Costan <pwnall@chromium.org>
Commit-Queue: Marijn Kruisselbrink <mek@chromium.org>
Cr-Commit-Position: refs/heads/master@{#595636}

chrome/browser/chromeos/extensions/file_manager/private_api_file_system.cc

@@ -260,12 +260,13 @@ void ComputeChecksumRespondOnUIThread(
 
 // Calls a response callback on the UI thread.
 void GetFileMetadataRespondOnUIThread(
-    const storage::FileSystemOperation::GetMetadataCallback& callback,
+    storage::FileSystemOperation::GetMetadataCallback callback,
     base::File::Error result,
     const base::File::Info& file_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  base::PostTaskWithTraits(FROM_HERE, {BrowserThread::UI},
-                           base::BindOnce(callback, result, file_info));
+  base::PostTaskWithTraits(
+      FROM_HERE, {BrowserThread::UI},
+      base::BindOnce(std::move(callback), result, file_info));
 }
 
 }  // namespace
@@ -656,10 +657,11 @@ void GetFileMetadataOnIOThread(
     scoped_refptr<storage::FileSystemContext> file_system_context,
     const FileSystemURL& url,
     int fields,
-    const storage::FileSystemOperation::GetMetadataCallback& callback) {
+    storage::FileSystemOperation::GetMetadataCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   file_system_context->operation_runner()->GetMetadata(
-      url, fields, base::Bind(&GetFileMetadataRespondOnUIThread, callback));
+      url, fields,
+      base::BindOnce(&GetFileMetadataRespondOnUIThread, std::move(callback)));
 }
 
 // Checks if the available space of the |path| is enough for required |bytes|.
@@ -708,12 +710,12 @@ bool FileManagerPrivateInternalStartCopyFunction::RunAsync() {
       file_manager::util::GetDownloadsMountPointName(GetProfile())) {
     return base::PostTaskWithTraits(
         FROM_HERE, {BrowserThread::IO},
-        base::BindOnce(&GetFileMetadataOnIOThread, file_system_context,
-                       source_url_,
-                       storage::FileSystemOperation::GET_METADATA_FIELD_SIZE,
-                       base::Bind(&FileManagerPrivateInternalStartCopyFunction::
-                                      RunAfterGetFileMetadata,
-                                  this)));
+        base::BindOnce(
+            &GetFileMetadataOnIOThread, file_system_context, source_url_,
+            storage::FileSystemOperation::GET_METADATA_FIELD_SIZE,
+            base::BindOnce(&FileManagerPrivateInternalStartCopyFunction::
+                               RunAfterGetFileMetadata,
+                           this)));
   }
 
   return base::PostTaskWithTraits(

chrome/browser/chromeos/file_manager/fileapi_util.cc

@@ -357,9 +357,10 @@ class ConvertSelectedFileInfoListToFileChooserFileInfoListImpl {
         storage::FileSystemOperation::GET_METADATA_FIELD_IS_DIRECTORY |
             storage::FileSystemOperation::GET_METADATA_FIELD_SIZE |
             storage::FileSystemOperation::GET_METADATA_FIELD_LAST_MODIFIED,
-        base::Bind(&ConvertSelectedFileInfoListToFileChooserFileInfoListImpl::
-                       OnGotMetadataOnIOThread,
-                   base::Unretained(this), base::Passed(&lifetime), it));
+        base::BindOnce(
+            &ConvertSelectedFileInfoListToFileChooserFileInfoListImpl::
+                OnGotMetadataOnIOThread,
+            base::Unretained(this), std::move(lifetime), it));
   }
 
   // Callback invoked after GetMetadata.
@@ -423,7 +424,7 @@ void GetMetadataForPathOnIoThread(
     storage::FileSystemOperationRunner::GetMetadataCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   file_system_context->operation_runner()->GetMetadata(internal_url, fields,
-                                                       callback);
+                                                       std::move(callback));
 }
 
 }  // namespace
@@ -577,7 +578,7 @@ std::unique_ptr<base::ListValue> ConvertEntryDefinitionListToListValue(
 void CheckIfDirectoryExists(
     scoped_refptr<storage::FileSystemContext> file_system_context,
     const base::FilePath& directory_path,
-    const storage::FileSystemOperationRunner::StatusCallback& callback) {
+    storage::FileSystemOperationRunner::StatusCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   storage::ExternalFileSystemBackend* const backend =
@@ -589,14 +590,15 @@ void CheckIfDirectoryExists(
   base::PostTaskWithTraits(
       FROM_HERE, {BrowserThread::IO},
       base::BindOnce(&CheckIfDirectoryExistsOnIoThread, file_system_context,
-                     internal_url, google_apis::CreateRelayCallback(callback)));
+                     internal_url,
+                     google_apis::CreateRelayCallback(std::move(callback))));
 }
 
 void GetMetadataForPath(
     scoped_refptr<storage::FileSystemContext> file_system_context,
     const base::FilePath& entry_path,
     int fields,
-    const storage::FileSystemOperationRunner::GetMetadataCallback& callback) {
+    storage::FileSystemOperationRunner::GetMetadataCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   storage::ExternalFileSystemBackend* const backend =
@@ -609,7 +611,7 @@ void GetMetadataForPath(
       FROM_HERE, {BrowserThread::IO},
       base::BindOnce(&GetMetadataForPathOnIoThread, file_system_context,
                      internal_url, fields,
-                     google_apis::CreateRelayCallback(callback)));
+                     google_apis::CreateRelayCallback(std::move(callback))));
 }
 
 storage::FileSystemURL CreateIsolatedURLFromVirtualPath(

chrome/browser/chromeos/file_manager/fileapi_util.h

@@ -161,14 +161,14 @@ std::unique_ptr<base::ListValue> ConvertEntryDefinitionListToListValue(
 void CheckIfDirectoryExists(
     scoped_refptr<storage::FileSystemContext> file_system_context,
     const base::FilePath& directory_path,
-    const storage::FileSystemOperationRunner::StatusCallback& callback);
+    storage::FileSystemOperationRunner::StatusCallback callback);
 
 // Get metadata for an entry at |entry_path| absolute path.
 void GetMetadataForPath(
     scoped_refptr<storage::FileSystemContext> file_system_context,
     const base::FilePath& entry_path,
     int fields,
-    const storage::FileSystemOperationRunner::GetMetadataCallback& callback);
+    storage::FileSystemOperationRunner::GetMetadataCallback callback);
 
 // Obtains isolated file system URL from |virtual_path| pointing a file in the
 // external file system.

chrome/browser/chromeos/file_manager/filesystem_api_util.cc

@@ -91,12 +91,12 @@ void BoolCallbackAsFileErrorCallback(base::OnceCallback<void(bool)> callback,
 void PrepareFileAfterCheckExistOnIOThread(
     scoped_refptr<storage::FileSystemContext> file_system_context,
     const storage::FileSystemURL& url,
-    const storage::FileSystemOperation::StatusCallback& callback,
+    storage::FileSystemOperation::StatusCallback callback,
     base::File::Error error) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (error != base::File::FILE_ERROR_NOT_FOUND) {
-    callback.Run(error);
+    std::move(callback).Run(error);
     return;
   }
 
@@ -106,7 +106,8 @@ void PrepareFileAfterCheckExistOnIOThread(
   //
   // Note that the preceding call to FileExists is necessary for handling
   // read only filesystems that blindly rejects handling CreateFile().
-  file_system_context->operation_runner()->CreateFile(url, false, callback);
+  file_system_context->operation_runner()->CreateFile(url, false,
+                                                      std::move(callback));
 }
 
 // Checks whether a file exists at the given |url|, and try creating it if it
@@ -118,10 +119,10 @@ void PrepareFileOnIOThread(
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   file_system_context->operation_runner()->FileExists(
-      url, base::Bind(&PrepareFileAfterCheckExistOnIOThread,
-                      file_system_context, url,
-                      base::Bind(&BoolCallbackAsFileErrorCallback,
-                                 base::Passed(std::move(callback)))));
+      url, base::BindOnce(&PrepareFileAfterCheckExistOnIOThread,
+                          std::move(file_system_context), url,
+                          base::BindOnce(&BoolCallbackAsFileErrorCallback,
+                                         std::move(callback))));
 }
 
 }  // namespace

chrome/browser/chromeos/fileapi/recent_download_source.cc

@@ -48,24 +48,25 @@ void ReadDirectoryOnIOThread(
 }
 
 void OnGetMetadataOnIOThread(
-    const storage::FileSystemOperation::GetMetadataCallback& callback,
+    storage::FileSystemOperation::GetMetadataCallback callback,
     base::File::Error result,
     const base::File::Info& info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   base::PostTaskWithTraits(FROM_HERE, {BrowserThread::UI},
-                           base::BindOnce(callback, result, info));
+                           base::BindOnce(std::move(callback), result, info));
 }
 
 void GetMetadataOnIOThread(
     scoped_refptr<storage::FileSystemContext> file_system_context,
     const storage::FileSystemURL& url,
     int fields,
-    const storage::FileSystemOperation::GetMetadataCallback& callback) {
+    storage::FileSystemOperation::GetMetadataCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   file_system_context->operation_runner()->GetMetadata(
-      url, fields, base::Bind(&OnGetMetadataOnIOThread, callback));
+      url, fields,
+      base::BindOnce(&OnGetMetadataOnIOThread, std::move(callback)));
 }
 
 }  // namespace
@@ -138,8 +139,8 @@ void RecentDownloadSource::OnReadDirectory(
               &GetMetadataOnIOThread,
               base::WrapRefCounted(params_.value().file_system_context()), url,
               storage::FileSystemOperation::GET_METADATA_FIELD_LAST_MODIFIED,
-              base::Bind(&RecentDownloadSource::OnGetMetadata,
-                         weak_ptr_factory_.GetWeakPtr(), url)));
+              base::BindOnce(&RecentDownloadSource::OnGetMetadata,
+                             weak_ptr_factory_.GetWeakPtr(), url)));
     }
   }
 

chrome/browser/chromeos/fileapi/recent_drive_source.cc

@@ -28,24 +28,25 @@ namespace chromeos {
 namespace {
 
 void OnGetMetadataOnIOThread(
-    const storage::FileSystemOperation::GetMetadataCallback& callback,
+    storage::FileSystemOperation::GetMetadataCallback callback,
     base::File::Error result,
     const base::File::Info& info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   base::PostTaskWithTraits(FROM_HERE, {BrowserThread::UI},
-                           base::BindOnce(callback, result, info));
+                           base::BindOnce(std::move(callback), result, info));
 }
 
 void GetMetadataOnIOThread(
     scoped_refptr<storage::FileSystemContext> file_system_context,
     const storage::FileSystemURL& url,
     int fields,
-    const storage::FileSystemOperation::GetMetadataCallback& callback) {
+    storage::FileSystemOperation::GetMetadataCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   file_system_context->operation_runner()->GetMetadata(
-      url, fields, base::Bind(&OnGetMetadataOnIOThread, callback));
+      url, fields,
+      base::BindOnce(&OnGetMetadataOnIOThread, std::move(callback)));
 }
 
 }  // namespace
@@ -139,8 +140,8 @@ void RecentDriveSource::OnSearchMetadata(
             &GetMetadataOnIOThread,
             base::WrapRefCounted(params_.value().file_system_context()), url,
             storage::FileSystemOperation::GET_METADATA_FIELD_LAST_MODIFIED,
-            base::Bind(&RecentDriveSource::OnGetMetadata,
-                       weak_ptr_factory_.GetWeakPtr(), url)));
+            base::BindOnce(&RecentDriveSource::OnGetMetadata,
+                           weak_ptr_factory_.GetWeakPtr(), url)));
   }
 
   if (num_inflight_stats_ == 0)

chrome/browser/sync_file_system/local/local_file_sync_context.cc

@@ -363,7 +363,7 @@ void LocalFileSyncContext::DidRemoveExistingEntryForRemoteAddOrUpdate(
 
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, url);
-  FileSystemOperation::StatusCallback operation_callback = base::Bind(
+  FileSystemOperation::StatusCallback operation_callback = base::BindOnce(
       &LocalFileSyncContext::DidApplyRemoteChange, this, url, callback);
 
   DCHECK_EQ(FileChange::FILE_CHANGE_ADD_OR_UPDATE, change.change());
@@ -375,7 +375,7 @@ void LocalFileSyncContext::DidRemoveExistingEntryForRemoteAddOrUpdate(
           storage::VirtualPath::DirName(dir_path) == dir_path) {
         // Copying into the root directory.
         file_system_context->operation_runner()->CopyInForeignFile(
-            local_path, url_for_sync, operation_callback);
+            local_path, url_for_sync, std::move(operation_callback));
       } else {
         FileSystemURL dir_url = file_system_context->CreateCrackedFileSystemURL(
             url_for_sync.origin(),
@@ -383,16 +383,16 @@ void LocalFileSyncContext::DidRemoveExistingEntryForRemoteAddOrUpdate(
             storage::VirtualPath::DirName(url_for_sync.virtual_path()));
         file_system_context->operation_runner()->CreateDirectory(
             dir_url, false /* exclusive */, true /* recursive */,
-            base::Bind(&LocalFileSyncContext::DidCreateDirectoryForCopyIn, this,
-                       base::RetainedRef(file_system_context), local_path, url,
-                       operation_callback));
+            base::BindOnce(&LocalFileSyncContext::DidCreateDirectoryForCopyIn,
+                           this, base::RetainedRef(file_system_context),
+                           local_path, url, std::move(operation_callback)));
       }
       break;
     }
     case SYNC_FILE_TYPE_DIRECTORY:
       file_system_context->operation_runner()->CreateDirectory(
           url_for_sync, false /* exclusive */, true /* recursive */,
-          operation_callback);
+          std::move(operation_callback));
       break;
     case SYNC_FILE_TYPE_UNKNOWN:
       NOTREACHED() << "File type unknown for ADD_OR_UPDATE change";
@@ -1037,17 +1037,17 @@ void LocalFileSyncContext::DidCreateDirectoryForCopyIn(
     FileSystemContext* file_system_context,
     const base::FilePath& local_path,
     const FileSystemURL& dest_url,
-    const StatusCallback& callback,
+    StatusCallback callback,
     base::File::Error error) {
   if (error != base::File::FILE_OK) {
-    callback.Run(error);
+    std::move(callback).Run(error);
     return;
   }
 
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, dest_url);
   file_system_context->operation_runner()->CopyInForeignFile(
-      local_path, url_for_sync, callback);
+      local_path, url_for_sync, std::move(callback));
 }
 
 }  // namespace sync_file_system

chrome/browser/sync_file_system/local/local_file_sync_context.h

@@ -210,7 +210,7 @@ class LocalFileSyncContext
   void OnWriteEnabled(const storage::FileSystemURL& url) override;
 
  private:
-  using StatusCallback = base::Callback<void(base::File::Error result)>;
+  using StatusCallback = base::OnceCallback<void(base::File::Error result)>;
   using StatusCallbackQueue = base::circular_deque<SyncStatusCallback>;
   using FileSystemURLQueue = base::circular_deque<storage::FileSystemURL>;
   friend class base::RefCountedThreadSafe<LocalFileSyncContext>;
@@ -324,7 +324,7 @@ class LocalFileSyncContext
       storage::FileSystemContext* file_system_context,
       const base::FilePath& local_file_path,
       const storage::FileSystemURL& dest_url,
-      const StatusCallback& callback,
+      StatusCallback callback,
       base::File::Error error);
 
   const base::FilePath local_base_path_;

chrome/browser/sync_file_system/local/syncable_file_operation_runner_unittest.cc

@@ -384,10 +384,12 @@ TEST_F(SyncableFileOperationRunnerTest, CopyInForeignFile) {
   EXPECT_EQ(1, callback_count_);
 
   // Now the file must have been created and have the same content as temp_path.
+  // TODO(mek): AdaptCallbackForRepeating is needed here because
+  // CannedSyncableFileSystem hasn't switched to OnceCallback yet.
   ResetCallbackStatus();
   file_system_.DoVerifyFile(
       URL(kFile), kTestData,
-      ExpectStatus(FROM_HERE, File::FILE_OK));
+      base::AdaptCallbackForRepeating(ExpectStatus(FROM_HERE, File::FILE_OK)));
   content::RunAllTasksUntilIdle();
   EXPECT_EQ(1, callback_count_);
 }

chrome/browser/sync_file_system/local/syncable_file_system_operation.h

@@ -34,66 +34,66 @@ class SyncableFileSystemOperation : public storage::FileSystemOperation {
   // storage::FileSystemOperation overrides.
   void CreateFile(const storage::FileSystemURL& url,
                   bool exclusive,
-                  const StatusCallback& callback) override;
+                  StatusCallback callback) override;
   void CreateDirectory(const storage::FileSystemURL& url,
                        bool exclusive,
                        bool recursive,
-                       const StatusCallback& callback) override;
+                       StatusCallback callback) override;
   void Copy(const storage::FileSystemURL& src_url,
             const storage::FileSystemURL& dest_url,
             CopyOrMoveOption option,
             ErrorBehavior error_behavior,
             const CopyProgressCallback& progress_callback,
-            const StatusCallback& callback) override;
+            StatusCallback callback) override;
   void Move(const storage::FileSystemURL& src_url,
             const storage::FileSystemURL& dest_url,
             CopyOrMoveOption option,
-            const StatusCallback& callback) override;
+            StatusCallback callback) override;
   void DirectoryExists(const storage::FileSystemURL& url,
-                       const StatusCallback& callback) override;
+                       StatusCallback callback) override;
   void FileExists(const storage::FileSystemURL& url,
-                  const StatusCallback& callback) override;
+                  StatusCallback callback) override;
   void GetMetadata(const storage::FileSystemURL& url,
                    int fields,
-                   const GetMetadataCallback& callback) override;
+                   GetMetadataCallback callback) override;
   void ReadDirectory(const storage::FileSystemURL& url,
                      const ReadDirectoryCallback& callback) override;
   void Remove(const storage::FileSystemURL& url,
               bool recursive,
-              const StatusCallback& callback) override;
+              StatusCallback callback) override;
   void Write(const storage::FileSystemURL& url,
              std::unique_ptr<storage::FileWriterDelegate> writer_delegate,
              std::unique_ptr<storage::BlobReader> blob_reader,
              const WriteCallback& callback) override;
   void Truncate(const storage::FileSystemURL& url,
                 int64_t length,
-                const StatusCallback& callback) override;
+                StatusCallback callback) override;
   void TouchFile(const storage::FileSystemURL& url,
                  const base::Time& last_access_time,
                  const base::Time& last_modified_time,
-                 const StatusCallback& callback) override;
+                 StatusCallback callback) override;
   void OpenFile(const storage::FileSystemURL& url,
                 int file_flags,
-                const OpenFileCallback& callback) override;
-  void Cancel(const StatusCallback& cancel_callback) override;
+                OpenFileCallback callback) override;
+  void Cancel(StatusCallback cancel_callback) override;
   void CreateSnapshotFile(const storage::FileSystemURL& path,
                           SnapshotFileCallback callback) override;
   void CopyInForeignFile(const base::FilePath& src_local_disk_path,
                          const storage::FileSystemURL& dest_url,
-                         const StatusCallback& callback) override;
+                         StatusCallback callback) override;
   void RemoveFile(const storage::FileSystemURL& url,
-                  const StatusCallback& callback) override;
+                  StatusCallback callback) override;
   void RemoveDirectory(const storage::FileSystemURL& url,
-                       const StatusCallback& callback) override;
+                       StatusCallback callback) override;
   void CopyFileLocal(const storage::FileSystemURL& src_url,
                      const storage::FileSystemURL& dest_url,
                      CopyOrMoveOption option,
                      const CopyFileProgressCallback& progress_callback,
-                     const StatusCallback& callback) override;
+                     StatusCallback callback) override;
   void MoveFileLocal(const storage::FileSystemURL& src_url,
                      const storage::FileSystemURL& dest_url,
                      CopyOrMoveOption option,
-                     const StatusCallback& callback) override;
+                     StatusCallback callback) override;
   base::File::Error SyncGetPlatformPath(const storage::FileSystemURL& url,
                                         base::FilePath* platform_path) override;
 

storage/browser/fileapi/copy_or_move_operation_delegate.h

@@ -57,7 +57,7 @@ class CopyOrMoveOperationDelegate
         const base::TimeDelta& min_progress_callback_invocation_span);
     ~StreamCopyHelper();
 
-    void Run(const StatusCallback& callback);
+    void Run(StatusCallback callback);
 
     // Requests cancelling. After the cancelling is done, |callback| passed to
     // Run will be called.
@@ -65,18 +65,19 @@ class CopyOrMoveOperationDelegate
 
    private:
     // Reads the content from the |reader_|.
-    void Read(const StatusCallback& callback);
-    void DidRead(const StatusCallback& callback, int result);
+    void Read(StatusCallback callback);
+    void DidRead(StatusCallback callback, int result);
 
     // Writes the content in |buffer| to |writer_|.
-    void Write(const StatusCallback& callback,
+    void Write(StatusCallback callback,
                scoped_refptr<net::DrainableIOBuffer> buffer);
-    void DidWrite(const StatusCallback& callback,
-                  scoped_refptr<net::DrainableIOBuffer> buffer, int result);
+    void DidWrite(StatusCallback callback,
+                  scoped_refptr<net::DrainableIOBuffer> buffer,
+                  int result);
 
     // Flushes the written content in |writer_|.
-    void Flush(const StatusCallback& callback, bool is_eof);
-    void DidFlush(const StatusCallback& callback, bool is_eof, int result);
+    void Flush(StatusCallback callback, bool is_eof);
+    void DidFlush(StatusCallback callback, bool is_eof, int result);
 
     std::unique_ptr<storage::FileStreamReader> reader_;
     std::unique_ptr<FileStreamWriter> writer_;
@@ -99,18 +100,17 @@ class CopyOrMoveOperationDelegate
                               CopyOrMoveOption option,
                               ErrorBehavior error_behavior,
                               const CopyProgressCallback& progress_callback,
-                              const StatusCallback& callback);
+                              StatusCallback callback);
   ~CopyOrMoveOperationDelegate() override;
 
   // RecursiveOperationDelegate overrides:
   void Run() override;
   void RunRecursively() override;
-  void ProcessFile(const FileSystemURL& url,
-                   const StatusCallback& callback) override;
+  void ProcessFile(const FileSystemURL& url, StatusCallback callback) override;
   void ProcessDirectory(const FileSystemURL& url,
-                        const StatusCallback& callback) override;
+                        StatusCallback callback) override;
   void PostProcessDirectory(const FileSystemURL& url,
-                            const StatusCallback& callback) override;
+                            StatusCallback callback) override;
 
  protected:
   void OnCancel() override;
@@ -118,32 +118,33 @@ class CopyOrMoveOperationDelegate
  private:
   void DidCopyOrMoveFile(const FileSystemURL& src_url,
                          const FileSystemURL& dest_url,
-                         const StatusCallback& callback,
+                         StatusCallback callback,
                          CopyOrMoveImpl* impl,
                          base::File::Error error);
-  void DidTryRemoveDestRoot(const StatusCallback& callback,
-                            base::File::Error error);
+  void DidTryRemoveDestRoot(StatusCallback callback, base::File::Error error);
   void ProcessDirectoryInternal(const FileSystemURL& src_url,
                                 const FileSystemURL& dest_url,
-                                const StatusCallback& callback);
+                                StatusCallback callback);
   void DidCreateDirectory(const FileSystemURL& src_url,
                           const FileSystemURL& dest_url,
-                          const StatusCallback& callback,
+                          StatusCallback callback,
                           base::File::Error error);
-  void PostProcessDirectoryAfterGetMetadata(
-      const FileSystemURL& src_url,
-      const StatusCallback& callback,
-      base::File::Error error,
-      const base::File::Info& file_info);
+  void PostProcessDirectoryAfterGetMetadata(const FileSystemURL& src_url,
+                                            StatusCallback callback,
+                                            base::File::Error error,
+                                            const base::File::Info& file_info);
   void PostProcessDirectoryAfterTouchFile(const FileSystemURL& src_url,
-                                          const StatusCallback& callback,
+                                          StatusCallback callback,
                                           base::File::Error error);
-  void DidRemoveSourceForMove(const StatusCallback& callback,
-                              base::File::Error error);
+  void DidRemoveSourceForMove(StatusCallback callback, base::File::Error error);
 
   void OnCopyFileProgress(const FileSystemURL& src_url, int64_t size);
   FileSystemURL CreateDestURL(const FileSystemURL& src_url) const;
 
+#if DCHECK_IS_ON()
+  bool did_run_ = false;
+#endif
+
   FileSystemURL src_root_;
   FileSystemURL dest_root_;
   bool same_file_system_;

storage/browser/fileapi/file_system_operation_impl.h

@@ -35,66 +35,64 @@ class STORAGE_EXPORT FileSystemOperationImpl : public FileSystemOperation {
   // FileSystemOperation overrides.
   void CreateFile(const FileSystemURL& url,
                   bool exclusive,
-                  const StatusCallback& callback) override;
+                  StatusCallback callback) override;
   void CreateDirectory(const FileSystemURL& url,
                        bool exclusive,
                        bool recursive,
-                       const StatusCallback& callback) override;
+                       StatusCallback callback) override;
   void Copy(const FileSystemURL& src_url,
             const FileSystemURL& dest_url,
             CopyOrMoveOption option,
             ErrorBehavior error_behavior,
             const CopyProgressCallback& progress_callback,
-            const StatusCallback& callback) override;
+            StatusCallback callback) override;
   void Move(const FileSystemURL& src_url,
             const FileSystemURL& dest_url,
             CopyOrMoveOption option,
-            const StatusCallback& callback) override;
+            StatusCallback callback) override;
   void DirectoryExists(const FileSystemURL& url,
-                       const StatusCallback& callback) override;
-  void FileExists(const FileSystemURL& url,
-                  const StatusCallback& callback) override;
+                       StatusCallback callback) override;
+  void FileExists(const FileSystemURL& url, StatusCallback callback) override;
   void GetMetadata(const FileSystemURL& url,
                    int fields,
-                   const GetMetadataCallback& callback) override;
+                   GetMetadataCallback callback) override;
   void ReadDirectory(const FileSystemURL& url,
                      const ReadDirectoryCallback& callback) override;
   void Remove(const FileSystemURL& url,
               bool recursive,
-              const StatusCallback& callback) override;
+              StatusCallback callback) override;
   void Write(const FileSystemURL& url,
              std::unique_ptr<FileWriterDelegate> writer_delegate,
              std::unique_ptr<BlobReader> blob_reader,
              const WriteCallback& callback) override;
   void Truncate(const FileSystemURL& url,
                 int64_t length,
-                const StatusCallback& callback) override;
+                StatusCallback callback) override;
   void TouchFile(const FileSystemURL& url,
                  const base::Time& last_access_time,
                  const base::Time& last_modified_time,
-                 const StatusCallback& callback) override;
+                 StatusCallback callback) override;
   void OpenFile(const FileSystemURL& url,
                 int file_flags,
-                const OpenFileCallback& callback) override;
-  void Cancel(const StatusCallback& cancel_callback) override;
+                OpenFileCallback callback) override;
+  void Cancel(StatusCallback cancel_callback) override;
   void CreateSnapshotFile(const FileSystemURL& path,
                           SnapshotFileCallback callback) override;
   void CopyInForeignFile(const base::FilePath& src_local_disk_path,
                          const FileSystemURL& dest_url,
-                         const StatusCallback& callback) override;
-  void RemoveFile(const FileSystemURL& url,
-                  const StatusCallback& callback) override;
+                         StatusCallback callback) override;
+  void RemoveFile(const FileSystemURL& url, StatusCallback callback) override;
   void RemoveDirectory(const FileSystemURL& url,
-                       const StatusCallback& callback) override;
+                       StatusCallback callback) override;
   void CopyFileLocal(const FileSystemURL& src_url,
                      const FileSystemURL& dest_url,
                      CopyOrMoveOption option,
                      const CopyFileProgressCallback& progress_callback,
-                     const StatusCallback& callback) override;
+                     StatusCallback callback) override;
   void MoveFileLocal(const FileSystemURL& src_url,
                      const FileSystemURL& dest_url,
                      CopyOrMoveOption option,
-                     const StatusCallback& callback) override;
+                     StatusCallback callback) override;
   base::File::Error SyncGetPlatformPath(const FileSystemURL& url,
                                         base::FilePath* platform_path) override;
 
@@ -112,18 +110,17 @@ class STORAGE_EXPORT FileSystemOperationImpl : public FileSystemOperation {
 
   // Queries the quota and usage and then runs the given |task|.
   // If an error occurs during the quota query it runs |error_callback| instead.
-  void GetUsageAndQuotaThenRunTask(
-      const FileSystemURL& url,
-      const base::Closure& task,
-      const base::Closure& error_callback);
+  void GetUsageAndQuotaThenRunTask(const FileSystemURL& url,
+                                   base::OnceClosure task,
+                                   base::OnceClosure error_callback);
 
   // Called after the quota info is obtained from the quota manager
   // (which is triggered by GetUsageAndQuotaThenRunTask).
   // Sets the quota info in the operation_context_ and then runs the given
   // |task| if the returned quota status is successful, otherwise runs
   // |error_callback|.
-  void DidGetUsageAndQuotaAndRunTask(const base::Closure& task,
-                                     const base::Closure& error_callback,
+  void DidGetUsageAndQuotaAndRunTask(base::OnceClosure task,
+                                     base::OnceClosure error_callback,
                                      blink::mojom::QuotaStatusCode status,
                                      int64_t usage,
                                      int64_t quota);
@@ -131,49 +128,50 @@ class STORAGE_EXPORT FileSystemOperationImpl : public FileSystemOperation {
   // The 'body' methods that perform the actual work (i.e. posting the
   // file task on proxy_) after the quota check.
   void DoCreateFile(const FileSystemURL& url,
-                    const StatusCallback& callback, bool exclusive);
+                    StatusCallback callback,
+                    bool exclusive);
   void DoCreateDirectory(const FileSystemURL& url,
-                         const StatusCallback& callback,
+                         StatusCallback callback,
                          bool exclusive,
                          bool recursive);
   void DoCopyFileLocal(const FileSystemURL& src,
                        const FileSystemURL& dest,
                        CopyOrMoveOption option,
                        const CopyFileProgressCallback& progress_callback,
-                       const StatusCallback& callback);
+                       StatusCallback callback);
   void DoMoveFileLocal(const FileSystemURL& src,
                        const FileSystemURL& dest,
                        CopyOrMoveOption option,
-                       const StatusCallback& callback);
+                       StatusCallback callback);
   void DoCopyInForeignFile(const base::FilePath& src_local_disk_file_path,
                            const FileSystemURL& dest,
-                           const StatusCallback& callback);
+                           StatusCallback callback);
   void DoTruncate(const FileSystemURL& url,
-                  const StatusCallback& callback,
+                  StatusCallback callback,
                   int64_t length);
   void DoOpenFile(const FileSystemURL& url,
-                  const OpenFileCallback& callback, int file_flags);
+                  OpenFileCallback callback,
+                  int file_flags);
 
   // Callback for CreateFile for |exclusive|=true cases.
-  void DidEnsureFileExistsExclusive(const StatusCallback& callback,
+  void DidEnsureFileExistsExclusive(StatusCallback callback,
                                     base::File::Error rv,
                                     bool created);
 
   // Callback for CreateFile for |exclusive|=false cases.
-  void DidEnsureFileExistsNonExclusive(const StatusCallback& callback,
+  void DidEnsureFileExistsNonExclusive(StatusCallback callback,
                                        base::File::Error rv,
                                        bool created);
 
-  void DidFinishOperation(const StatusCallback& callback,
-                          base::File::Error rv);
-  void DidDirectoryExists(const StatusCallback& callback,
+  void DidFinishOperation(StatusCallback callback, base::File::Error rv);
+  void DidDirectoryExists(StatusCallback callback,
                           base::File::Error rv,
                           const base::File::Info& file_info);
-  void DidFileExists(const StatusCallback& callback,
+  void DidFileExists(StatusCallback callback,
                      base::File::Error rv,
                      const base::File::Info& file_info);
   void DidDeleteRecursively(const FileSystemURL& url,
-                            const StatusCallback& callback,
+                            StatusCallback callback,
                             base::File::Error rv);
   void DidWrite(const FileSystemURL& url,
                 const WriteCallback& callback,

storage/browser/fileapi/file_system_operation_runner.h

@@ -59,12 +59,12 @@ class STORAGE_EXPORT FileSystemOperationRunner {
   // in case a file is already present at the URL.
   OperationID CreateFile(const FileSystemURL& url,
                          bool exclusive,
-                         const StatusCallback& callback);
+                         StatusCallback callback);
 
   OperationID CreateDirectory(const FileSystemURL& url,
                               bool exclusive,
                               bool recursive,
-                              const StatusCallback& callback);
+                              StatusCallback callback);
 
   // Copies a file or directory from |src_url| to |dest_url|. If
   // |src_url| is a directory, the contents of |src_url| are copied to
@@ -77,7 +77,7 @@ class STORAGE_EXPORT FileSystemOperationRunner {
                    CopyOrMoveOption option,
                    ErrorBehavior error_behavior,
                    const CopyProgressCallback& progress_callback,
-                   const StatusCallback& callback);
+                   StatusCallback callback);
 
   // Moves a file or directory from |src_url| to |dest_url|. A new file
   // or directory is created at |dest_url| as needed.
@@ -85,20 +85,19 @@ class STORAGE_EXPORT FileSystemOperationRunner {
   OperationID Move(const FileSystemURL& src_url,
                    const FileSystemURL& dest_url,
                    CopyOrMoveOption option,
-                   const StatusCallback& callback);
+                   StatusCallback callback);
 
   // Checks if a directory is present at |url|.
   OperationID DirectoryExists(const FileSystemURL& url,
-                              const StatusCallback& callback);
+                              StatusCallback callback);
 
   // Checks if a file is present at |url|.
-  OperationID FileExists(const FileSystemURL& url,
-                         const StatusCallback& callback);
+  OperationID FileExists(const FileSystemURL& url, StatusCallback callback);
 
   // Gets the metadata of a file or directory at |url|.
   OperationID GetMetadata(const FileSystemURL& url,
                           int fields,
-                          const GetMetadataCallback& callback);
+                          GetMetadataCallback callback);
 
   // Reads contents of a directory at |url|.
   OperationID ReadDirectory(const FileSystemURL& url,
@@ -106,8 +105,9 @@ class STORAGE_EXPORT FileSystemOperationRunner {
 
   // Removes a file or directory at |url|. If |recursive| is true, remove
   // all files and directories under the directory at |url| recursively.
-  OperationID Remove(const FileSystemURL& url, bool recursive,
-                     const StatusCallback& callback);
+  OperationID Remove(const FileSystemURL& url,
+                     bool recursive,
+                     StatusCallback callback);
 
   // Writes contents of |blob_url| to |url| at |offset|.
   OperationID Write(const FileSystemURL& url,
@@ -120,12 +120,12 @@ class STORAGE_EXPORT FileSystemOperationRunner {
   // part is filled with null bytes.
   OperationID Truncate(const FileSystemURL& url,
                        int64_t length,
-                       const StatusCallback& callback);
+                       StatusCallback callback);
 
   // Tries to cancel the operation |id| [we support cancelling write or
   // truncate only]. Reports failure for the current operation, then reports
   // success for the cancel operation itself via the |callback|.
-  void Cancel(OperationID id, const StatusCallback& callback);
+  void Cancel(OperationID id, StatusCallback callback);
 
   // Modifies timestamps of a file or directory at |url| with
   // |last_access_time| and |last_modified_time|. The function DOES NOT
@@ -135,7 +135,7 @@ class STORAGE_EXPORT FileSystemOperationRunner {
   OperationID TouchFile(const FileSystemURL& url,
                         const base::Time& last_access_time,
                         const base::Time& last_modified_time,
-                        const StatusCallback& callback);
+                        StatusCallback callback);
 
   // Opens a file at |url| with |file_flags|, where flags are OR'ed
   // values of base::PlatformFileFlags.
@@ -146,7 +146,7 @@ class STORAGE_EXPORT FileSystemOperationRunner {
   // This function is used only by Pepper as of writing.
   OperationID OpenFile(const FileSystemURL& url,
                        int file_flags,
-                       const OpenFileCallback& callback);
+                       OpenFileCallback callback);
 
   // Creates a local snapshot file for a given |url| and returns the
   // metadata and platform url of the snapshot file via |callback|.
@@ -171,7 +171,7 @@ class STORAGE_EXPORT FileSystemOperationRunner {
   //
   OperationID CopyInForeignFile(const base::FilePath& src_local_disk_path,
                                 const FileSystemURL& dest_url,
-                                const StatusCallback& callback);
+                                StatusCallback callback);
 
   // Removes a single file.
   //
@@ -179,8 +179,7 @@ class STORAGE_EXPORT FileSystemOperationRunner {
   // - File::FILE_ERROR_NOT_FOUND if |url| does not exist.
   // - File::FILE_ERROR_NOT_A_FILE if |url| is not a file.
   //
-  OperationID RemoveFile(const FileSystemURL& url,
-                         const StatusCallback& callback);
+  OperationID RemoveFile(const FileSystemURL& url, StatusCallback callback);
 
   // Removes a single empty directory.
   //
@@ -190,7 +189,7 @@ class STORAGE_EXPORT FileSystemOperationRunner {
   // - File::FILE_ERROR_NOT_EMPTY if |url| is not empty.
   //
   OperationID RemoveDirectory(const FileSystemURL& url,
-                              const StatusCallback& callback);
+                              StatusCallback callback);
 
   // Copies a file from |src_url| to |dest_url|.
   // This must be called for files that belong to the same filesystem
@@ -211,7 +210,7 @@ class STORAGE_EXPORT FileSystemOperationRunner {
                             const FileSystemURL& dest_url,
                             CopyOrMoveOption option,
                             const CopyFileProgressCallback& progress_callback,
-                            const StatusCallback& callback);
+                            StatusCallback callback);
 
   // Moves a local file from |src_url| to |dest_url|.
   // This must be called for files that belong to the same filesystem
@@ -230,7 +229,7 @@ class STORAGE_EXPORT FileSystemOperationRunner {
   OperationID MoveFileLocal(const FileSystemURL& src_url,
                             const FileSystemURL& dest_url,
                             CopyOrMoveOption option,
-                            const StatusCallback& callback);
+                            StatusCallback callback);
 
   // This is called only by pepper plugin as of writing to synchronously get
   // the underlying platform path to upload a file in the sandboxed filesystem
@@ -243,10 +242,10 @@ class STORAGE_EXPORT FileSystemOperationRunner {
   explicit FileSystemOperationRunner(FileSystemContext* file_system_context);
 
   void DidFinish(const OperationID id,
-                 const StatusCallback& callback,
+                 StatusCallback callback,
                  base::File::Error rv);
   void DidGetMetadata(const OperationID id,
-                      const GetMetadataCallback& callback,
+                      GetMetadataCallback callback,
                       base::File::Error rv,
                       const base::File::Info& file_info);
   void DidReadDirectory(const OperationID id,
@@ -260,7 +259,7 @@ class STORAGE_EXPORT FileSystemOperationRunner {
                 int64_t bytes,
                 bool complete);
   void DidOpenFile(const OperationID id,
-                   const OpenFileCallback& callback,
+                   OpenFileCallback callback,
                    base::File file,
                    base::OnceClosure on_close_callback);
   void DidCreateSnapshot(

storage/browser/fileapi/recursive_operation_delegate.cc

@@ -33,12 +33,12 @@ void RecursiveOperationDelegate::Cancel() {
 void RecursiveOperationDelegate::StartRecursiveOperation(
     const FileSystemURL& root,
     ErrorBehavior error_behavior,
-    const StatusCallback& callback) {
+    StatusCallback callback) {
   DCHECK(pending_directory_stack_.empty());
   DCHECK(pending_files_.empty());
 
   error_behavior_ = error_behavior;
-  callback_ = callback;
+  callback_ = std::move(callback);
 
   TryProcessFile(root);
 }
@@ -221,13 +221,13 @@ void RecursiveOperationDelegate::DidPostProcessDirectory(
 
 void RecursiveOperationDelegate::Done(base::File::Error error) {
   if (canceled_ && error == base::File::FILE_OK) {
-    callback_.Run(base::File::FILE_ERROR_ABORT);
+    std::move(callback_).Run(base::File::FILE_ERROR_ABORT);
   } else {
     if (error_behavior_ == FileSystemOperation::ERROR_BEHAVIOR_SKIP &&
         failed_some_operations_)
-      callback_.Run(base::File::FILE_ERROR_FAILED);
+      std::move(callback_).Run(base::File::FILE_ERROR_FAILED);
     else
-      callback_.Run(error);
+      std::move(callback_).Run(error);
   }
 }
 

storage/browser/fileapi/recursive_operation_delegate.h

@@ -43,18 +43,17 @@ class STORAGE_EXPORT RecursiveOperationDelegate
   // This is called each time a file is found while recursively
   // performing an operation.
   virtual void ProcessFile(const FileSystemURL& url,
-                           const StatusCallback& callback) = 0;
+                           StatusCallback callback) = 0;
 
   // This is called each time a directory is found while recursively
   // performing an operation.
   virtual void ProcessDirectory(const FileSystemURL& url,
-                                const StatusCallback& callback) = 0;
-
+                                StatusCallback callback) = 0;
 
   // This is called each time after files and subdirectories for a
   // directory is processed while recursively performing an operation.
   virtual void PostProcessDirectory(const FileSystemURL& url,
-                                    const StatusCallback& callback) = 0;
+                                    StatusCallback callback) = 0;
 
   // Cancels the currently running operation.
   void Cancel();
@@ -111,7 +110,7 @@ class STORAGE_EXPORT RecursiveOperationDelegate
   // under |root| is processed, or fired earlier when any suboperation fails.
   void StartRecursiveOperation(const FileSystemURL& root,
                                ErrorBehavior error_behavior,
-                               const StatusCallback& callback);
+                               StatusCallback callback);
 
   FileSystemContext* file_system_context() { return file_system_context_; }
   const FileSystemContext* file_system_context() const {

storage/browser/fileapi/recursive_operation_delegate_unittest.cc

@@ -44,10 +44,10 @@ class LoggingRecursiveOperation : public storage::RecursiveOperationDelegate {
 
   LoggingRecursiveOperation(FileSystemContext* file_system_context,
                             const FileSystemURL& root,
-                            const StatusCallback& callback)
+                            StatusCallback callback)
       : storage::RecursiveOperationDelegate(file_system_context),
         root_(root),
-        callback_(callback),
+        callback_(std::move(callback)),
         weak_factory_(this) {}
   ~LoggingRecursiveOperation() override = default;
 
@@ -57,40 +57,41 @@ class LoggingRecursiveOperation : public storage::RecursiveOperationDelegate {
   void Run() override { NOTREACHED(); }
 
   void RunRecursively() override {
-    StartRecursiveOperation(
-        root_, storage::FileSystemOperation::ERROR_BEHAVIOR_ABORT, callback_);
+    StartRecursiveOperation(root_,
+                            storage::FileSystemOperation::ERROR_BEHAVIOR_ABORT,
+                            std::move(callback_));
   }
 
   void RunRecursivelyWithIgnoringError() {
-    StartRecursiveOperation(
-        root_, storage::FileSystemOperation::ERROR_BEHAVIOR_SKIP, callback_);
+    StartRecursiveOperation(root_,
+                            storage::FileSystemOperation::ERROR_BEHAVIOR_SKIP,
+                            std::move(callback_));
   }
 
-  void ProcessFile(const FileSystemURL& url,
-                   const StatusCallback& callback) override {
+  void ProcessFile(const FileSystemURL& url, StatusCallback callback) override {
     RecordLogEntry(LogEntry::PROCESS_FILE, url);
 
     if (error_url_.is_valid() && error_url_ == url) {
-      callback.Run(base::File::FILE_ERROR_FAILED);
+      std::move(callback).Run(base::File::FILE_ERROR_FAILED);
       return;
     }
 
     operation_runner()->GetMetadata(
         url, storage::FileSystemOperation::GET_METADATA_FIELD_IS_DIRECTORY,
-        base::Bind(&LoggingRecursiveOperation::DidGetMetadata,
-                   weak_factory_.GetWeakPtr(), callback));
+        base::BindOnce(&LoggingRecursiveOperation::DidGetMetadata,
+                       weak_factory_.GetWeakPtr(), std::move(callback)));
   }
 
   void ProcessDirectory(const FileSystemURL& url,
-                        const StatusCallback& callback) override {
+                        StatusCallback callback) override {
     RecordLogEntry(LogEntry::PROCESS_DIRECTORY, url);
-    callback.Run(base::File::FILE_OK);
+    std::move(callback).Run(base::File::FILE_OK);
   }
 
   void PostProcessDirectory(const FileSystemURL& url,
-                            const StatusCallback& callback) override {
+                            StatusCallback callback) override {
     RecordLogEntry(LogEntry::POST_PROCESS_DIRECTORY, url);
-    callback.Run(base::File::FILE_OK);
+    std::move(callback).Run(base::File::FILE_OK);
   }
 
   void SetEntryToFail(const FileSystemURL& url) { error_url_ = url; }
@@ -103,17 +104,17 @@ class LoggingRecursiveOperation : public storage::RecursiveOperationDelegate {
     log_entries_.push_back(entry);
   }
 
-  void DidGetMetadata(const StatusCallback& callback,
+  void DidGetMetadata(StatusCallback callback,
                       base::File::Error result,
                       const base::File::Info& file_info) {
     if (result != base::File::FILE_OK) {
-      callback.Run(result);
+      std::move(callback).Run(result);
       return;
     }
 
-    callback.Run(file_info.is_directory ?
-                 base::File::FILE_ERROR_NOT_A_FILE :
-                 base::File::FILE_OK);
+    std::move(callback).Run(file_info.is_directory
+                                ? base::File::FILE_ERROR_NOT_A_FILE
+                                : base::File::FILE_OK);
   }
 
   FileSystemURL root_;

storage/browser/fileapi/remove_operation_delegate.cc

@@ -13,71 +13,77 @@ namespace storage {
 RemoveOperationDelegate::RemoveOperationDelegate(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
-    const StatusCallback& callback)
+    StatusCallback callback)
     : RecursiveOperationDelegate(file_system_context),
       url_(url),
-      callback_(callback),
-      weak_factory_(this) {
-}
+      callback_(std::move(callback)),
+      weak_factory_(this) {}
 
 RemoveOperationDelegate::~RemoveOperationDelegate() = default;
 
 void RemoveOperationDelegate::Run() {
-  operation_runner()->RemoveFile(url_, base::Bind(
-      &RemoveOperationDelegate::DidTryRemoveFile, weak_factory_.GetWeakPtr()));
+#if DCHECK_IS_ON()
+  DCHECK(!did_run_);
+  did_run_ = true;
+#endif
+  operation_runner()->RemoveFile(
+      url_, base::BindOnce(&RemoveOperationDelegate::DidTryRemoveFile,
+                           weak_factory_.GetWeakPtr()));
 }
 
 void RemoveOperationDelegate::RunRecursively() {
+#if DCHECK_IS_ON()
+  DCHECK(!did_run_);
+  did_run_ = true;
+#endif
   StartRecursiveOperation(url_, FileSystemOperation::ERROR_BEHAVIOR_ABORT,
-                          callback_);
+                          std::move(callback_));
 }
 
 void RemoveOperationDelegate::ProcessFile(const FileSystemURL& url,
-                                          const StatusCallback& callback) {
+                                          StatusCallback callback) {
   operation_runner()->RemoveFile(
-      url,
-      base::Bind(&RemoveOperationDelegate::DidRemoveFile,
-                 weak_factory_.GetWeakPtr(), callback));
+      url, base::BindOnce(&RemoveOperationDelegate::DidRemoveFile,
+                          weak_factory_.GetWeakPtr(), std::move(callback)));
 }
 
 void RemoveOperationDelegate::ProcessDirectory(const FileSystemURL& url,
-                                               const StatusCallback& callback) {
-  callback.Run(base::File::FILE_OK);
+                                               StatusCallback callback) {
+  std::move(callback).Run(base::File::FILE_OK);
 }
 
-void RemoveOperationDelegate::PostProcessDirectory(
-    const FileSystemURL& url, const StatusCallback& callback) {
-  operation_runner()->RemoveDirectory(url, callback);
+void RemoveOperationDelegate::PostProcessDirectory(const FileSystemURL& url,
+                                                   StatusCallback callback) {
+  operation_runner()->RemoveDirectory(url, std::move(callback));
 }
 
 void RemoveOperationDelegate::DidTryRemoveFile(base::File::Error error) {
   if (error != base::File::FILE_ERROR_NOT_A_FILE &&
       error != base::File::FILE_ERROR_SECURITY) {
-    callback_.Run(error);
+    std::move(callback_).Run(error);
     return;
   }
   operation_runner()->RemoveDirectory(
-      url_,
-      base::Bind(&RemoveOperationDelegate::DidTryRemoveDirectory,
-                 weak_factory_.GetWeakPtr(), error));
+      url_, base::BindOnce(&RemoveOperationDelegate::DidTryRemoveDirectory,
+                           weak_factory_.GetWeakPtr(), error));
 }
 
 void RemoveOperationDelegate::DidTryRemoveDirectory(
     base::File::Error remove_file_error,
     base::File::Error remove_directory_error) {
-  callback_.Run(
-      remove_directory_error == base::File::FILE_ERROR_NOT_A_DIRECTORY ?
-      remove_file_error :
-      remove_directory_error);
+  std::move(callback_).Run(remove_directory_error ==
+                                   base::File::FILE_ERROR_NOT_A_DIRECTORY
+                               ? remove_file_error
+                               : remove_directory_error);
 }
 
-void RemoveOperationDelegate::DidRemoveFile(const StatusCallback& callback,
+void RemoveOperationDelegate::DidRemoveFile(StatusCallback callback,
                                             base::File::Error error) {
   if (error == base::File::FILE_ERROR_NOT_FOUND) {
-    callback.Run(base::File::FILE_OK);
+    std::move(callback).Run(base::File::FILE_OK);
     return;
   }
-  callback.Run(error);
+  std::move(callback).Run(error);
 }
 
 }  // namespace storage

storage/browser/fileapi/remove_operation_delegate.h

@@ -14,26 +14,27 @@ class RemoveOperationDelegate : public RecursiveOperationDelegate {
  public:
   RemoveOperationDelegate(FileSystemContext* file_system_context,
                           const FileSystemURL& url,
-                          const StatusCallback& callback);
+                          StatusCallback callback);
   ~RemoveOperationDelegate() override;
 
   // RecursiveOperationDelegate overrides:
   void Run() override;
   void RunRecursively() override;
-  void ProcessFile(const FileSystemURL& url,
-                   const StatusCallback& callback) override;
+  void ProcessFile(const FileSystemURL& url, StatusCallback callback) override;
   void ProcessDirectory(const FileSystemURL& url,
-                        const StatusCallback& callback) override;
+                        StatusCallback callback) override;
   void PostProcessDirectory(const FileSystemURL& url,
-                            const StatusCallback& callback) override;
+                            StatusCallback callback) override;
 
  private:
   void DidTryRemoveFile(base::File::Error error);
   void DidTryRemoveDirectory(base::File::Error remove_file_error,
                              base::File::Error remove_directory_error);
-  void DidRemoveFile(const StatusCallback& callback,
-                     base::File::Error error);
+  void DidRemoveFile(StatusCallback callback, base::File::Error error);
 
+#if DCHECK_IS_ON()
+  bool did_run_ = false;
+#endif
   FileSystemURL url_;
   StatusCallback callback_;
   base::WeakPtrFactory<RemoveOperationDelegate> weak_factory_;