Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/file_system_provider/fileapi/buffering_file_stream_reader_unittest.cc

 // Copyright 2014 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 "chrome/browser/chromeos/file_system_provider/fileapi/buffering_file_stream_reader.h"
+
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
-#include "chrome/browser/chromeos/file_system_provider/fileapi/buffering_file_stream_reader.h"
 #include "chrome/browser/chromeos/fileapi/file_system_backend.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
 namespace file_system_provider {
 namespace {
 
@@ skipping 59 matching lines @@
  protected:
   FileSystemProviderBufferingFileStreamReaderTest() {}
   ~FileSystemProviderBufferingFileStreamReaderTest() override {}
 
   content::TestBrowserThreadBundle thread_bundle_;
 };
 
 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read) {
   std::vector<int> inner_read_log;
   BufferingFileStreamReader reader(
-      scoped_ptr<storage::FileStreamReader>(
+      std::unique_ptr<storage::FileStreamReader>(
           new FakeFileStreamReader(&inner_read_log, net::OK)),
-      kPreloadingBufferLength,
-      kFileSize);
+      kPreloadingBufferLength, kFileSize);
 
   // For the first read, the internal file stream reader is fired, as there is
   // no data in the preloading buffer.
   {
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize));
     std::vector<int> read_log;
     const int result = reader.Read(
         buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log));
     base::RunLoop().RunUntilIdle();
 
@@ skipping 50 matching lines @@
     ASSERT_EQ(1u, inner_read_log.size());
     EXPECT_EQ(kPreloadingBufferLength, inner_read_log[0]);
     ASSERT_EQ(1u, read_log.size());
     EXPECT_EQ(kChunkSize, read_log[0]);
   }
 }
 
 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_Directly) {
   std::vector<int> inner_read_log;
   BufferingFileStreamReader reader(
-      scoped_ptr<storage::FileStreamReader>(
+      std::unique_ptr<storage::FileStreamReader>(
           new FakeFileStreamReader(&inner_read_log, net::OK)),
-      kPreloadingBufferLength,
-      kFileSize);
+      kPreloadingBufferLength, kFileSize);
 
   // First read couple of bytes, so the internal buffer is filled out.
   {
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize));
     std::vector<int> read_log;
     const int result = reader.Read(
         buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log));
     base::RunLoop().RunUntilIdle();
 
     EXPECT_EQ(net::ERR_IO_PENDING, result);
@@ skipping 37 matching lines @@
     EXPECT_EQ(read_bytes, inner_read_log[0]);
     ASSERT_EQ(1u, read_log.size());
     EXPECT_EQ(read_bytes, read_log[0]);
   }
 }
 
 TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
        Read_MoreThanBufferSize) {
   std::vector<int> inner_read_log;
   BufferingFileStreamReader reader(
-      scoped_ptr<storage::FileStreamReader>(
+      std::unique_ptr<storage::FileStreamReader>(
           new FakeFileStreamReader(&inner_read_log, net::OK)),
-      kPreloadingBufferLength,
-      kFileSize);
+      kPreloadingBufferLength, kFileSize);
   // First read couple of bytes, so the internal buffer is filled out.
   {
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize));
     std::vector<int> read_log;
     const int result = reader.Read(
         buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log));
     base::RunLoop().RunUntilIdle();
 
     EXPECT_EQ(net::ERR_IO_PENDING, result);
     ASSERT_EQ(1u, inner_read_log.size());
@@ skipping 19 matching lines @@
     EXPECT_EQ(0u, read_log.size());
   }
 }
 
 TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
        Read_LessThanBufferSize) {
   std::vector<int> inner_read_log;
   const int total_bytes_to_read = 3;
   ASSERT_LT(total_bytes_to_read, kPreloadingBufferLength);
   BufferingFileStreamReader reader(
-      scoped_ptr<storage::FileStreamReader>(
+      std::unique_ptr<storage::FileStreamReader>(
           new FakeFileStreamReader(&inner_read_log, net::OK)),
-      kPreloadingBufferLength,
-      total_bytes_to_read);
+      kPreloadingBufferLength, total_bytes_to_read);
 
   // For the first read, the internal file stream reader is fired, as there is
   // no data in the preloading buffer.
   const int read_bytes = 2;
   ASSERT_LT(read_bytes, kPreloadingBufferLength);
   ASSERT_LE(read_bytes, total_bytes_to_read);
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(read_bytes));
   std::vector<int> read_log;
   const int result = reader.Read(
       buffer.get(), read_bytes, base::Bind(&LogValue<int>, &read_log));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(net::ERR_IO_PENDING, result);
   ASSERT_EQ(1u, inner_read_log.size());
   EXPECT_EQ(total_bytes_to_read, inner_read_log[0]);
   ASSERT_EQ(1u, read_log.size());
   EXPECT_EQ(read_bytes, read_log[0]);
 }
 
 TEST_F(FileSystemProviderBufferingFileStreamReaderTest,
        Read_LessThanBufferSize_WithoutSpecifiedLength) {
   std::vector<int> inner_read_log;
   BufferingFileStreamReader reader(
-      scoped_ptr<storage::FileStreamReader>(
+      std::unique_ptr<storage::FileStreamReader>(
           new FakeFileStreamReader(&inner_read_log, net::OK)),
-      kPreloadingBufferLength,
-      storage::kMaximumLength);
+      kPreloadingBufferLength, storage::kMaximumLength);
 
   // For the first read, the internal file stream reader is fired, as there is
   // no data in the preloading buffer.
   const int read_bytes = 2;
   ASSERT_LT(read_bytes, kPreloadingBufferLength);
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(read_bytes));
   std::vector<int> read_log;
   const int result = reader.Read(
       buffer.get(), read_bytes, base::Bind(&LogValue<int>, &read_log));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(net::ERR_IO_PENDING, result);
   ASSERT_EQ(1u, inner_read_log.size());
   EXPECT_EQ(kPreloadingBufferLength, inner_read_log[0]);
   ASSERT_EQ(1u, read_log.size());
   EXPECT_EQ(read_bytes, read_log[0]);
 }
 
 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, Read_WithError) {
   std::vector<int> inner_read_log;
   BufferingFileStreamReader reader(
-      scoped_ptr<storage::FileStreamReader>(
+      std::unique_ptr<storage::FileStreamReader>(
           new FakeFileStreamReader(&inner_read_log, net::ERR_ACCESS_DENIED)),
-      kPreloadingBufferLength,
-      kFileSize);
+      kPreloadingBufferLength, kFileSize);
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kChunkSize));
   std::vector<int> read_log;
   const int result = reader.Read(
       buffer.get(), kChunkSize, base::Bind(&LogValue<int>, &read_log));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(net::ERR_IO_PENDING, result);
   ASSERT_EQ(1u, inner_read_log.size());
   EXPECT_EQ(kPreloadingBufferLength, inner_read_log[0]);
   ASSERT_EQ(1u, read_log.size());
   EXPECT_EQ(net::ERR_ACCESS_DENIED, read_log[0]);
 }
 
 TEST_F(FileSystemProviderBufferingFileStreamReaderTest, GetLength) {
-  BufferingFileStreamReader reader(scoped_ptr<storage::FileStreamReader>(
+  BufferingFileStreamReader reader(std::unique_ptr<storage::FileStreamReader>(
                                        new FakeFileStreamReader(NULL, net::OK)),
-                                   kPreloadingBufferLength,
-                                   kFileSize);
+                                   kPreloadingBufferLength, kFileSize);
 
   std::vector<int64_t> get_length_log;
   const int64_t result =
       reader.GetLength(base::Bind(&LogValue<int64_t>, &get_length_log));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(net::ERR_IO_PENDING, result);
   ASSERT_EQ(1u, get_length_log.size());
   EXPECT_EQ(kFileSize, get_length_log[0]);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos