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

storage/browser/fileapi/copy_or_move_operation_delegate.cc

 // Copyright (c) 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/copy_or_move_operation_delegate.h"
 
 #include <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "storage/browser/blob/shareable_file_reference.h"
 #include "storage/browser/fileapi/copy_or_move_file_validator.h"
 #include "storage/browser/fileapi/file_observers.h"
 #include "storage/browser/fileapi/file_stream_reader.h"
@@ skipping 357 matching lines @@
       scoped_ptr<storage::FileStreamReader> reader,
       scoped_ptr<FileStreamWriter> writer,
       const FileSystemOperation::CopyFileProgressCallback&
           file_progress_callback)
       : operation_runner_(operation_runner),
         file_system_context_(file_system_context),
         operation_type_(operation_type),
         src_url_(src_url),
         dest_url_(dest_url),
         option_(option),
-        reader_(reader.Pass()),
-        writer_(writer.Pass()),
+        reader_(std::move(reader)),
+        writer_(std::move(writer)),
         file_progress_callback_(file_progress_callback),
         cancel_requested_(false),
         weak_factory_(this) {}
 
   void Run(
       const CopyOrMoveOperationDelegate::StatusCallback& callback) override {
     // Reader can be created even if the entry does not exist or the entry is
     // a directory. To check errors before destination file creation,
     // check metadata first.
     operation_runner_->GetMetadata(
@@ skipping 98 matching lines @@
       error = base::File::FILE_ERROR_ABORT;
 
     if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
 
     NotifyOnStartUpdate(dest_url_);
     DCHECK(!copy_helper_);
     copy_helper_.reset(new CopyOrMoveOperationDelegate::StreamCopyHelper(
-        reader_.Pass(), writer_.Pass(), dest_url_.mount_option().flush_policy(),
-        kReadBufferSize, file_progress_callback_,
+        std::move(reader_), std::move(writer_),
+        dest_url_.mount_option().flush_policy(), kReadBufferSize,
+        file_progress_callback_,
         base::TimeDelta::FromMilliseconds(
             kMinProgressCallbackInvocationSpanInMilliseconds)));
     copy_helper_->Run(
         base::Bind(&StreamCopyOrMoveImpl::RunAfterStreamCopy,
                    weak_factory_.GetWeakPtr(), callback, last_modified));
   }
 
   void RunAfterStreamCopy(
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
       const base::Time& last_modified,
@@ skipping 69 matching lines @@
 
 }  // namespace
 
 CopyOrMoveOperationDelegate::StreamCopyHelper::StreamCopyHelper(
     scoped_ptr<storage::FileStreamReader> reader,
     scoped_ptr<FileStreamWriter> writer,
     storage::FlushPolicy flush_policy,
     int buffer_size,
     const FileSystemOperation::CopyFileProgressCallback& file_progress_callback,
     const base::TimeDelta& min_progress_callback_invocation_span)
-    : reader_(reader.Pass()),
-      writer_(writer.Pass()),
+    : reader_(std::move(reader)),
+      writer_(std::move(writer)),
       flush_policy_(flush_policy),
       file_progress_callback_(file_progress_callback),
       io_buffer_(new net::IOBufferWithSize(buffer_size)),
       num_copied_bytes_(0),
       previous_flush_offset_(0),
       min_progress_callback_invocation_span_(
           min_progress_callback_invocation_span),
       cancel_requested_(false),
-      weak_factory_(this) {
-}
+      weak_factory_(this) {}
 
 CopyOrMoveOperationDelegate::StreamCopyHelper::~StreamCopyHelper() {
 }
 
 void CopyOrMoveOperationDelegate::StreamCopyHelper::Run(
     const StatusCallback& callback) {
   file_progress_callback_.Run(0);
   last_progress_callback_invocation_time_ = base::Time::Now();
   Read(callback);
 }
@@ skipping 199 matching lines @@
     }
 
     if (!validator_factory) {
       scoped_ptr<storage::FileStreamReader> reader =
           file_system_context()->CreateFileStreamReader(
               src_url, 0 /* offset */, storage::kMaximumLength, base::Time());
       scoped_ptr<FileStreamWriter> writer =
           file_system_context()->CreateFileStreamWriter(dest_url, 0);
       if (reader && writer) {
         impl = new StreamCopyOrMoveImpl(
-            operation_runner(),
-            file_system_context(),
-            operation_type_,
-            src_url,
-            dest_url,
-            option_,
-            reader.Pass(),
-            writer.Pass(),
+            operation_runner(), file_system_context(), operation_type_, src_url,
+            dest_url, option_, std::move(reader), std::move(writer),
             base::Bind(&CopyOrMoveOperationDelegate::OnCopyFileProgress,
-                       weak_factory_.GetWeakPtr(),
-                       src_url));
+                       weak_factory_.GetWeakPtr(), src_url));
       }
     }
 
     if (!impl) {
       impl = new SnapshotCopyOrMoveImpl(
           operation_runner(), operation_type_, src_url, dest_url, option_,
           validator_factory,
           base::Bind(&CopyOrMoveOperationDelegate::OnCopyFileProgress,
                      weak_factory_.GetWeakPtr(), src_url));
     }
@@ skipping 184 matching lines @@
   base::FilePath relative = dest_root_.virtual_path();
   src_root_.virtual_path().AppendRelativePath(src_url.virtual_path(),
                                               &relative);
   return file_system_context()->CreateCrackedFileSystemURL(
       dest_root_.origin(),
       dest_root_.mount_type(),
       relative);
 }
 
 }  // namespace storage