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

storage/browser/fileapi/file_system_operation_runner.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_runner.h"
 
 #include <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/url_request/url_request_context.h"
 #include "storage/browser/blob/blob_url_request_job_factory.h"
 #include "storage/browser/blob/shareable_file_reference.h"
 #include "storage/browser/fileapi/file_observers.h"
 #include "storage/browser/fileapi/file_stream_writer.h"
@@ skipping 237 matching lines @@
   }
 
   scoped_ptr<FileStreamWriter> writer(
       file_system_context_->CreateFileStreamWriter(url, offset));
   if (!writer) {
     // Write is not supported.
     DidWrite(handle, callback, base::File::FILE_ERROR_SECURITY, 0, true);
     return handle.id;
   }
 
-  scoped_ptr<FileWriterDelegate> writer_delegate(
-      new FileWriterDelegate(writer.Pass(), url.mount_option().flush_policy()));
+  scoped_ptr<FileWriterDelegate> writer_delegate(new FileWriterDelegate(
+      std::move(writer), url.mount_option().flush_policy()));
 
   scoped_ptr<net::URLRequest> blob_request(
       storage::BlobProtocolHandler::CreateBlobRequest(
-          blob.Pass(), url_request_context, writer_delegate.get()));
+          std::move(blob), url_request_context, writer_delegate.get()));
 
   PrepareForWrite(handle.id, url);
-  operation->Write(
-      url, writer_delegate.Pass(), blob_request.Pass(),
-      base::Bind(&FileSystemOperationRunner::DidWrite, AsWeakPtr(),
-                 handle, callback));
+  operation->Write(url, std::move(writer_delegate), std::move(blob_request),
+                   base::Bind(&FileSystemOperationRunner::DidWrite, AsWeakPtr(),
+                              handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::Truncate(
     const FileSystemURL& url,
     int64_t length,
     const StatusCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(url, &error);
@@ skipping 297 matching lines @@
     base::File file,
     const base::Closure& on_close_callback) {
   if (handle.scope) {
     finished_operations_.insert(handle.id);
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&FileSystemOperationRunner::DidOpenFile,
                               AsWeakPtr(), handle, callback, Passed(&file),
                               on_close_callback));
     return;
   }
-  callback.Run(file.Pass(), on_close_callback);
+  callback.Run(std::move(file), on_close_callback);
   FinishOperation(handle.id);
 }
 
 void FileSystemOperationRunner::DidCreateSnapshot(
     const OperationHandle& handle,
     const SnapshotFileCallback& callback,
     base::File::Error rv,
     const base::File::Info& file_info,
     const base::FilePath& platform_path,
     const scoped_refptr<storage::ShareableFileReference>& file_ref) {
@@ skipping 78 matching lines @@
       stray_cancel_callbacks_.find(id);
   if (found_cancel != stray_cancel_callbacks_.end()) {
     // This cancel has been requested after the operation has finished,
     // so report that we failed to stop it.
     found_cancel->second.Run(base::File::FILE_ERROR_INVALID_OPERATION);
     stray_cancel_callbacks_.erase(found_cancel);
   }
 }
 
 }  // namespace storage