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

storage/browser/blob/blob_data_handle.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/blob/blob_data_handle.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 29 matching lines @@
     return make_scoped_ptr(FileStreamReader::CreateForLocalFile(
         task_runner, file_path, initial_offset, expected_modification_time));
   }
 
   scoped_ptr<FileStreamReader> CreateFileStreamReader(
       const GURL& filesystem_url,
       int64_t offset,
       int64_t max_bytes_to_read,
       const base::Time& expected_modification_time) override {
     return file_system_context_->CreateFileStreamReader(
-                                   storage::FileSystemURL(
-                                       file_system_context_->CrackURL(
-                                           filesystem_url)),
-                                   offset, max_bytes_to_read,
-                                   expected_modification_time)
-        .Pass();
+        storage::FileSystemURL(file_system_context_->CrackURL(filesystem_url)),
+        offset, max_bytes_to_read, expected_modification_time);
   }
 
  private:
   scoped_refptr<FileSystemContext> file_system_context_;
   DISALLOW_COPY_AND_ASSIGN(FileStreamReaderProviderImpl);
 };
 
 }  // namespace
 
 BlobDataHandle::BlobDataHandleShared::BlobDataHandleShared(
@@ skipping 12 matching lines @@
     FileSystemContext* file_system_context,
     base::SequencedTaskRunner* file_task_runner) const {
   return scoped_ptr<BlobReader>(new BlobReader(
       this, scoped_ptr<BlobReader::FileStreamReaderProvider>(
                 new FileStreamReaderProviderImpl(file_system_context)),
       file_task_runner));
 }
 
 scoped_ptr<BlobDataSnapshot>
 BlobDataHandle::BlobDataHandleShared::CreateSnapshot() const {
-  return context_->CreateSnapshot(uuid_).Pass();
+  return context_->CreateSnapshot(uuid_);
 }
 
 BlobDataHandle::BlobDataHandleShared::~BlobDataHandleShared() {
   if (context_.get())
     context_->DecrementBlobRefCount(uuid_);
 }
 
 BlobDataHandle::BlobDataHandle(const std::string& uuid,
                                const std::string& content_type,
                                const std::string& content_disposition,
@@ skipping 15 matching lines @@
 
 BlobDataHandle::~BlobDataHandle() {
   BlobDataHandleShared* raw = shared_.get();
   raw->AddRef();
   shared_ = nullptr;
   io_task_runner_->ReleaseSoon(FROM_HERE, raw);
 }
 
 scoped_ptr<BlobDataSnapshot> BlobDataHandle::CreateSnapshot() const {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
-  return shared_->CreateSnapshot().Pass();
+  return shared_->CreateSnapshot();
 }
 
 const std::string& BlobDataHandle::uuid() const {
   return shared_->uuid_;
 }
 
 const std::string& BlobDataHandle::content_type() const {
   return shared_->content_type_;
 }
 
 const std::string& BlobDataHandle::content_disposition() const {
   return shared_->content_disposition_;
 }
 
 }  // namespace storage