Convert Pass()→std::move() in //content/browser

content/browser/fileapi/blob_url_request_job_unittest.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 <stdint.h>
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 65 matching lines @@
 scoped_ptr<disk_cache::Backend> CreateInMemoryDiskCache() {
   scoped_ptr<disk_cache::Backend> cache;
   net::TestCompletionCallback callback;
   int rv = disk_cache::CreateCacheBackend(net::MEMORY_CACHE,
                                           net::CACHE_BACKEND_DEFAULT,
                                           base::FilePath(), 0,
                                           false, nullptr, nullptr, &cache,
                                           callback.callback());
   EXPECT_EQ(net::OK, callback.GetResult(rv));
 
-  return cache.Pass();
+  return cache;
 }
 
 disk_cache::ScopedEntryPtr CreateDiskCacheEntry(disk_cache::Backend* cache,
                                                 const char* key,
                                                 const std::string& data) {
   disk_cache::Entry* temp_entry = nullptr;
   net::TestCompletionCallback callback;
   int rv = cache->CreateEntry(key, &temp_entry, callback.callback());
   if (callback.GetResult(rv) != net::OK)
     return nullptr;
   disk_cache::ScopedEntryPtr entry(temp_entry);
 
   scoped_refptr<net::StringIOBuffer> iobuffer = new net::StringIOBuffer(data);
   rv = entry->WriteData(kTestDiskCacheStreamIndex, 0, iobuffer.get(),
                         iobuffer->size(), callback.callback(), false);
   EXPECT_EQ(static_cast<int>(data.size()), callback.GetResult(rv));
-  return entry.Pass();
+  return entry;
 }
 
 }  // namespace
 
 class BlobURLRequestJobTest : public testing::Test {
  public:
   // A simple ProtocolHandler implementation to create BlobURLRequestJob.
   class MockProtocolHandler :
       public net::URLRequestJobFactory::ProtocolHandler {
    public:
@@ skipping 167 matching lines @@
     blob_data_->AppendFile(temp_file2_, 5, 6, temp_file_modification_time2_);
     *expected_result += std::string(kTestFileData2 + 5, 6);
 
     blob_data_->AppendFileSystemFile(temp_file_system_file2_, 6, 7,
                                      temp_file_system_file_modification_time2_);
     *expected_result += std::string(kTestFileSystemFileData2 + 6, 7);
   }
 
   storage::BlobDataHandle* GetHandleFromBuilder() {
     if (!blob_handle_) {
-      blob_handle_ = blob_context_.AddFinishedBlob(blob_data_.get()).Pass();
+      blob_handle_ = blob_context_.AddFinishedBlob(blob_data_.get());
     }
     return blob_handle_.get();
   }
 
   // This only works if all the Blob items have a definite pre-computed length.
   // Otherwise, this will fail a CHECK.
   int64_t GetTotalBlobLength() {
     int64_t total = 0;
     scoped_ptr<BlobDataSnapshot> data =
         GetHandleFromBuilder()->CreateSnapshot();
@@ skipping 233 matching lines @@
   EXPECT_TRUE(request_->response_headers()->GetMimeType(&content_type));
   EXPECT_EQ(kTestContentType, content_type);
   void* iter = NULL;
   std::string content_disposition;
   EXPECT_TRUE(request_->response_headers()->EnumerateHeader(
       &iter, "Content-Disposition", &content_disposition));
   EXPECT_EQ(kTestContentDisposition, content_disposition);
 }
 
 }  // namespace content