Convert Pass()→std::move() in //storage

storage/browser/fileapi/file_system_operation_impl.cc

 // Copyright 2013 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 "storage/browser/fileapi/file_system_operation_impl.h"
 
 #include <stdint.h>
-
 #include <limits>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request.h"
 #include "storage/browser/blob/shareable_file_reference.h"
 #include "storage/browser/fileapi/async_file_util.h"
@@ skipping 22 matching lines @@
     base::WeakPtr<FileSystemOperationImpl> operation,
     const FileSystemOperationImpl::OpenFileCallback& callback,
     base::File file,
     const base::Closure& on_close_callback) {
   if (!operation) {
     context->default_file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&Destruct, base::Passed(&file)));
     return;
   }
-  callback.Run(file.Pass(), on_close_callback);
+  callback.Run(std::move(file), on_close_callback);
 }
 
 }  // namespace
 
 FileSystemOperation* FileSystemOperation::Create(
     const FileSystemURL& url,
     FileSystemContext* file_system_context,
     scoped_ptr<FileSystemOperationContext> operation_context) {
   return new FileSystemOperationImpl(url, file_system_context,
-                                     operation_context.Pass());
+                                     std::move(operation_context));
 }
 
 FileSystemOperationImpl::~FileSystemOperationImpl() {
 }
 
 void FileSystemOperationImpl::CreateFile(const FileSystemURL& url,
                                          bool exclusive,
                                          const StatusCallback& callback) {
   // crbug.com/349708
   TRACE_EVENT0("io", "FileSystemOperationImpl::CreateFile");
@@ skipping 55 matching lines @@
       FileSystemOperation::CopyProgressCallback(),
       base::Bind(&FileSystemOperationImpl::DidFinishOperation,
                  weak_factory_.GetWeakPtr(), callback)));
   recursive_operation_delegate_->RunRecursively();
 }
 
 void FileSystemOperationImpl::DirectoryExists(const FileSystemURL& url,
                                               const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationDirectoryExists));
   async_file_util_->GetFileInfo(
-      operation_context_.Pass(), url, GET_METADATA_FIELD_IS_DIRECTORY,
+      std::move(operation_context_), url, GET_METADATA_FIELD_IS_DIRECTORY,
       base::Bind(&FileSystemOperationImpl::DidDirectoryExists,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void FileSystemOperationImpl::FileExists(const FileSystemURL& url,
                                          const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationFileExists));
   async_file_util_->GetFileInfo(
-      operation_context_.Pass(), url, GET_METADATA_FIELD_IS_DIRECTORY,
+      std::move(operation_context_), url, GET_METADATA_FIELD_IS_DIRECTORY,
       base::Bind(&FileSystemOperationImpl::DidFileExists,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void FileSystemOperationImpl::GetMetadata(const FileSystemURL& url,
                                           int fields,
                                           const GetMetadataCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationGetMetadata));
-  async_file_util_->GetFileInfo(operation_context_.Pass(), url, fields,
+  async_file_util_->GetFileInfo(std::move(operation_context_), url, fields,
                                 callback);
 }
 
 void FileSystemOperationImpl::ReadDirectory(
     const FileSystemURL& url, const ReadDirectoryCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationReadDirectory));
-  async_file_util_->ReadDirectory(
-      operation_context_.Pass(), url, callback);
+  async_file_util_->ReadDirectory(std::move(operation_context_), url, callback);
 }
 
 void FileSystemOperationImpl::Remove(const FileSystemURL& url,
                                      bool recursive,
                                      const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationRemove));
   DCHECK(!recursive_operation_delegate_);
 
   if (recursive) {
     // For recursive removal, try to delegate the operation to AsyncFileUtil
     // first. If not supported, it is delegated to RemoveOperationDelegate
     // in DidDeleteRecursively.
     async_file_util_->DeleteRecursively(
-        operation_context_.Pass(), url,
+        std::move(operation_context_), url,
         base::Bind(&FileSystemOperationImpl::DidDeleteRecursively,
                    weak_factory_.GetWeakPtr(), url, callback));
     return;
   }
 
   recursive_operation_delegate_.reset(
       new RemoveOperationDelegate(
           file_system_context(), url,
           base::Bind(&FileSystemOperationImpl::DidFinishOperation,
                      weak_factory_.GetWeakPtr(), callback)));
   recursive_operation_delegate_->Run();
 }
 
 void FileSystemOperationImpl::Write(
     const FileSystemURL& url,
     scoped_ptr<FileWriterDelegate> writer_delegate,
     scoped_ptr<net::URLRequest> blob_request,
     const WriteCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationWrite));
-  file_writer_delegate_ = writer_delegate.Pass();
+  file_writer_delegate_ = std::move(writer_delegate);
   file_writer_delegate_->Start(
-      blob_request.Pass(),
-      base::Bind(&FileSystemOperationImpl::DidWrite,
-                 weak_factory_.GetWeakPtr(), url, callback));
+      std::move(blob_request),
+      base::Bind(&FileSystemOperationImpl::DidWrite, weak_factory_.GetWeakPtr(),
+                 url, callback));
 }
 
 void FileSystemOperationImpl::Truncate(const FileSystemURL& url,
                                        int64_t length,
                                        const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationTruncate));
 
   // crbug.com/349708
   TRACE_EVENT0("io", "FileSystemOperationImpl::Truncate");
 
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&FileSystemOperationImpl::DoTruncate,
                  weak_factory_.GetWeakPtr(), url, callback, length),
       base::Bind(callback, base::File::FILE_ERROR_FAILED));
 }
 
 void FileSystemOperationImpl::TouchFile(const FileSystemURL& url,
                                         const base::Time& last_access_time,
                                         const base::Time& last_modified_time,
                                         const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationTouchFile));
 
   // crbug.com/349708
   TRACE_EVENT0("io", "FileSystemOperationImpl::TouchFile");
 
   async_file_util_->Touch(
-      operation_context_.Pass(), url,
-      last_access_time, last_modified_time,
+      std::move(operation_context_), url, last_access_time, last_modified_time,
       base::Bind(&FileSystemOperationImpl::DidFinishOperation,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void FileSystemOperationImpl::OpenFile(const FileSystemURL& url,
                                        int file_flags,
                                        const OpenFileCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationOpenFile));
 
   if (file_flags &
@@ skipping 32 matching lines @@
     // For truncate we have no way to cancel the inflight operation (for now).
     // Let it just run and dispatch cancel callback later.
     DCHECK_EQ(kOperationTruncate, pending_operation_);
   }
 }
 
 void FileSystemOperationImpl::CreateSnapshotFile(
     const FileSystemURL& url,
     const SnapshotFileCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCreateSnapshotFile));
-  async_file_util_->CreateSnapshotFile(
-      operation_context_.Pass(), url, callback);
+  async_file_util_->CreateSnapshotFile(std::move(operation_context_), url,
+                                       callback);
 }
 
 void FileSystemOperationImpl::CopyInForeignFile(
     const base::FilePath& src_local_disk_file_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCopyInForeignFile));
 
   // crbug.com/349708
   TRACE_EVENT0("io", "FileSystemOperationImpl::CopyInForeinFile");
 
   GetUsageAndQuotaThenRunTask(
       dest_url,
       base::Bind(&FileSystemOperationImpl::DoCopyInForeignFile,
                  weak_factory_.GetWeakPtr(), src_local_disk_file_path, dest_url,
                  callback),
       base::Bind(callback, base::File::FILE_ERROR_FAILED));
 }
 
 void FileSystemOperationImpl::RemoveFile(
     const FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationRemove));
   async_file_util_->DeleteFile(
-      operation_context_.Pass(), url,
+      std::move(operation_context_), url,
       base::Bind(&FileSystemOperationImpl::DidFinishOperation,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void FileSystemOperationImpl::RemoveDirectory(
     const FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationRemove));
   async_file_util_->DeleteDirectory(
-      operation_context_.Pass(), url,
+      std::move(operation_context_), url,
       base::Bind(&FileSystemOperationImpl::DidFinishOperation,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void FileSystemOperationImpl::CopyFileLocal(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     CopyOrMoveOption option,
     const CopyFileProgressCallback& progress_callback,
     const StatusCallback& callback) {
@@ skipping 40 matching lines @@
       file_system_context()->sandbox_delegate()->sync_file_util();
   file_util->GetLocalFilePath(operation_context_.get(), url, platform_path);
   return base::File::FILE_OK;
 }
 
 FileSystemOperationImpl::FileSystemOperationImpl(
     const FileSystemURL& url,
     FileSystemContext* file_system_context,
     scoped_ptr<FileSystemOperationContext> operation_context)
     : file_system_context_(file_system_context),
-      operation_context_(operation_context.Pass()),
+      operation_context_(std::move(operation_context)),
       async_file_util_(NULL),
       pending_operation_(kOperationNone),
       weak_factory_(this) {
   DCHECK(operation_context_.get());
   operation_context_->DetachUserDataThread();
   async_file_util_ = file_system_context_->GetAsyncFileUtil(url.type());
   DCHECK(async_file_util_);
 }
 
 void FileSystemOperationImpl::GetUsageAndQuotaThenRunTask(
@@ skipping 35 matching lines @@
 
   operation_context_->set_allowed_bytes_growth(quota - usage);
   task.Run();
 }
 
 void FileSystemOperationImpl::DoCreateFile(
     const FileSystemURL& url,
     const StatusCallback& callback,
     bool exclusive) {
   async_file_util_->EnsureFileExists(
-      operation_context_.Pass(), url,
+      std::move(operation_context_), url,
       base::Bind(
-          exclusive ?
-              &FileSystemOperationImpl::DidEnsureFileExistsExclusive :
-              &FileSystemOperationImpl::DidEnsureFileExistsNonExclusive,
+          exclusive ? &FileSystemOperationImpl::DidEnsureFileExistsExclusive
+                    : &FileSystemOperationImpl::DidEnsureFileExistsNonExclusive,
           weak_factory_.GetWeakPtr(), callback));
 }
 
 void FileSystemOperationImpl::DoCreateDirectory(
     const FileSystemURL& url,
     const StatusCallback& callback,
     bool exclusive, bool recursive) {
   async_file_util_->CreateDirectory(
-      operation_context_.Pass(),
-      url, exclusive, recursive,
+      std::move(operation_context_), url, exclusive, recursive,
       base::Bind(&FileSystemOperationImpl::DidFinishOperation,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void FileSystemOperationImpl::DoCopyFileLocal(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     CopyOrMoveOption option,
     const CopyFileProgressCallback& progress_callback,
     const StatusCallback& callback) {
   async_file_util_->CopyFileLocal(
-      operation_context_.Pass(), src_url, dest_url, option, progress_callback,
+      std::move(operation_context_), src_url, dest_url, option,
+      progress_callback,
       base::Bind(&FileSystemOperationImpl::DidFinishOperation,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void FileSystemOperationImpl::DoMoveFileLocal(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     CopyOrMoveOption option,
     const StatusCallback& callback) {
   async_file_util_->MoveFileLocal(
-      operation_context_.Pass(), src_url, dest_url, option,
+      std::move(operation_context_), src_url, dest_url, option,
       base::Bind(&FileSystemOperationImpl::DidFinishOperation,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void FileSystemOperationImpl::DoCopyInForeignFile(
     const base::FilePath& src_local_disk_file_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   async_file_util_->CopyInForeignFile(
-      operation_context_.Pass(),
-      src_local_disk_file_path, dest_url,
+      std::move(operation_context_), src_local_disk_file_path, dest_url,
       base::Bind(&FileSystemOperationImpl::DidFinishOperation,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void FileSystemOperationImpl::DoTruncate(const FileSystemURL& url,
                                          const StatusCallback& callback,
                                          int64_t length) {
   async_file_util_->Truncate(
-      operation_context_.Pass(), url, length,
+      std::move(operation_context_), url, length,
       base::Bind(&FileSystemOperationImpl::DidFinishOperation,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void FileSystemOperationImpl::DoOpenFile(const FileSystemURL& url,
                                          const OpenFileCallback& callback,
                                          int file_flags) {
   async_file_util_->CreateOrOpen(
-      operation_context_.Pass(), url, file_flags,
-      base::Bind(&DidOpenFile,
-                 file_system_context_, weak_factory_.GetWeakPtr(), callback));
+      std::move(operation_context_), url, file_flags,
+      base::Bind(&DidOpenFile, file_system_context_, weak_factory_.GetWeakPtr(),
+                 callback));
 }
 
 void FileSystemOperationImpl::DidEnsureFileExistsExclusive(
     const StatusCallback& callback,
     base::File::Error rv, bool created) {
   if (rv == base::File::FILE_OK && !created) {
     callback.Run(base::File::FILE_ERROR_EXISTS);
   } else {
     DidFinishOperation(callback, rv);
   }
@@ skipping 79 matching lines @@
 }
 
 bool FileSystemOperationImpl::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
   return true;
 }
 
 }  // namespace storage