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

content/browser/fileapi/blob_reader_unittest.cc

 // Copyright 2015 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_reader.h"
-
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner.h"
 #include "base/time/time.h"
 #include "content/public/test/async_file_test_helper.h"
 #include "content/public/test/test_file_system_context.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/disk_cache.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
+#include "storage/browser/blob/blob_reader.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/fileapi/file_stream_reader.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_file_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using base::FilePath;
 using content::AsyncFileTestHelper;
@@ skipping 11 matching lines @@
  private:
   ~EmptyDataHandle() override {}
 };
 
 // A disk_cache::Entry that arbitrarily delays the completion of a read
 // operation to allow testing some races without flake. This is particularly
 // relevant in this unit test, which uses the always-synchronous MEMORY_CACHE.
 class DelayedReadEntry : public disk_cache::Entry {
  public:
   explicit DelayedReadEntry(disk_cache::ScopedEntryPtr entry)
-      : entry_(entry.Pass()) {}
+      : entry_(std::move(entry)) {}
   ~DelayedReadEntry() override { EXPECT_FALSE(HasPendingReadCallbacks()); }
 
   bool HasPendingReadCallbacks() { return !pending_read_callbacks_.empty(); }
 
   void RunPendingReadCallbacks() {
     std::vector<base::Callback<void(void)>> callbacks;
     pending_read_callbacks_.swap(callbacks);
     for (const auto& callback : callbacks)
       callback.Run();
   }
@@ skipping 73 matching lines @@
 
 scoped_ptr<disk_cache::Backend> CreateInMemoryDiskCache(
     const scoped_refptr<base::SingleThreadTaskRunner>& thread) {
   scoped_ptr<disk_cache::Backend> cache;
   net::TestCompletionCallback callback;
   int rv = disk_cache::CreateCacheBackend(
       net::MEMORY_CACHE, net::CACHE_BACKEND_DEFAULT, FilePath(), 0, false,
       thread, 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;
 }
 
 template <typename T>
 void SetValue(T* address, T value) {
   *address = value;
 }
 
 class FakeFileStreamReader : public FileStreamReader {
  public:
   explicit FakeFileStreamReader(const std::string& contents)
@@ skipping 133 matching lines @@
 
   void TearDown() override {
     reader_.reset();
     blob_handle_.reset();
     message_loop_.RunUntilIdle();
     base::RunLoop().RunUntilIdle();
   }
 
  protected:
   void InitializeReader(BlobDataBuilder* builder) {
-    blob_handle_ = builder ? context_.AddFinishedBlob(builder).Pass() : nullptr;
+    blob_handle_ = builder ? context_.AddFinishedBlob(builder) : nullptr;
     provider_ = new MockFileStreamReaderProvider();
     scoped_ptr<BlobReader::FileStreamReaderProvider> temp_ptr(provider_);
-    reader_.reset(new BlobReader(blob_handle_.get(), temp_ptr.Pass(),
+    reader_.reset(new BlobReader(blob_handle_.get(), std::move(temp_ptr),
                                  message_loop_.task_runner().get()));
   }
 
   // Takes ownership of the file reader (the blob reader takes ownership).
   void ExpectLocalFileCall(const FilePath& file_path,
                            base::Time modification_time,
                            uint64_t initial_offset,
                            FakeFileStreamReader* reader) {
     EXPECT_CALL(*provider_, CreateForLocalFileMock(
                                 message_loop_.task_runner().get(), file_path,
@@ skipping 380 matching lines @@
 TEST_F(BlobReaderTest, DiskCacheAsync) {
   scoped_ptr<disk_cache::Backend> cache =
       CreateInMemoryDiskCache(message_loop_.task_runner());
   ASSERT_TRUE(cache);
 
   BlobDataBuilder b("uuid");
   const std::string kData = "Test Blob Data";
   scoped_refptr<BlobDataBuilder::DataHandle> data_handle =
       new EmptyDataHandle();
   scoped_ptr<DelayedReadEntry> delayed_read_entry(new DelayedReadEntry(
-      CreateDiskCacheEntry(cache.get(), "test entry", kData).Pass()));
+      CreateDiskCacheEntry(cache.get(), "test entry", kData)));
   b.AppendDiskCacheEntry(data_handle, delayed_read_entry.get(),
                          kTestDiskCacheStreamIndex);
   this->InitializeReader(&b);
 
   int size_result = -1;
   EXPECT_FALSE(IsReaderTotalSizeCalculated());
   EXPECT_EQ(BlobReader::Status::DONE,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
   CheckSizeCalculatedSynchronously(kData.size(), size_result);
 
@@ skipping 365 matching lines @@
   EXPECT_EQ(BlobReader::Status::DONE,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
   buffer = CreateBuffer(kDataSize + 1);
   EXPECT_EQ(BlobReader::Status::NET_ERROR,
             reader_->SetReadRange(0, kDataSize + 1));
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, reader_->net_error());
 }
 
 }  // namespace
 }  // namespace storage