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

chrome/browser/chromeos/drive/drive_file_stream_reader_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 "chrome/browser/chromeos/drive/drive_file_stream_reader.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string>
 #include <utility>
@@ skipping 45 matching lines @@
     worker_thread_.reset(new base::Thread("ReaderProxyTest"));
     ASSERT_TRUE(worker_thread_->Start());
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
 
   base::ScopedTempDir temp_dir_;
   base::FilePath file_path_;
   std::string file_content_;
 
-  scoped_ptr<base::Thread> worker_thread_;
+  std::unique_ptr<base::Thread> worker_thread_;
 };
 
 TEST_F(LocalReaderProxyTest, Read) {
   // Open the file first.
-  scoped_ptr<util::LocalFileReader> file_reader(
+  std::unique_ptr<util::LocalFileReader> file_reader(
       new util::LocalFileReader(worker_thread_->task_runner().get()));
   net::TestCompletionCallback callback;
   file_reader->Open(file_path_, 0, callback.callback());
   ASSERT_EQ(net::OK, callback.WaitForResult());
 
   // Test instance.
   LocalReaderProxy proxy(std::move(file_reader), file_content_.size());
 
   // Make sure the read content is as same as the file.
   std::string content;
   ASSERT_EQ(net::OK, test_util::ReadAllData(&proxy, &content));
   EXPECT_EQ(file_content_, content);
 }
 
 TEST_F(LocalReaderProxyTest, ReadWithLimit) {
   // This test case, we only read first half of the file.
   const std::string expected_content =
       file_content_.substr(0, file_content_.size() / 2);
 
   // Open the file first.
-  scoped_ptr<util::LocalFileReader> file_reader(
+  std::unique_ptr<util::LocalFileReader> file_reader(
       new util::LocalFileReader(worker_thread_->task_runner().get()));
   net::TestCompletionCallback callback;
   file_reader->Open(file_path_, 0, callback.callback());
   ASSERT_EQ(net::OK, callback.WaitForResult());
 
   // Test instance.
   LocalReaderProxy proxy(std::move(file_reader), expected_content.size());
 
   // Make sure the read content is as same as the file.
   std::string content;
@@ skipping 30 matching lines @@
 
     net::TestCompletionCallback callback;
     const int kBufferSize = 3;
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 
     // If no data is available yet, ERR_IO_PENDING should be returned.
     int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
     EXPECT_EQ(net::ERR_IO_PENDING, result);
 
     // And when the data is supplied, the callback will be called.
-    scoped_ptr<std::string> data(new std::string("abcde"));
+    std::unique_ptr<std::string> data(new std::string("abcde"));
     proxy.OnGetContent(std::move(data));
 
     // The returned data should be fit to the buffer size.
     result = callback.GetResult(result);
     EXPECT_EQ(3, result);
     EXPECT_EQ("abc", std::string(buffer->data(), result));
 
     // The next Read should return immediately because there is pending data
     result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
     EXPECT_EQ(2, result);
@@ skipping 29 matching lines @@
 
   net::TestCompletionCallback callback;
   const int kBufferSize = 3;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 
   // If no data is available yet, ERR_IO_PENDING should be returned.
   int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
   EXPECT_EQ(net::ERR_IO_PENDING, result);
 
   // And when the data is supplied, the callback will be called.
-  scoped_ptr<std::string> data(new std::string("abcde"));
+  std::unique_ptr<std::string> data(new std::string("abcde"));
   proxy.OnGetContent(std::move(data));
   data.reset(new std::string("fgh"));
   proxy.OnGetContent(std::move(data));
   data.reset(new std::string("ijklmno"));
   proxy.OnGetContent(std::move(data));
 
   // The returned data should be fit to the buffer size.
   result = callback.GetResult(result);
   EXPECT_EQ(3, result);
   EXPECT_EQ("klm", std::string(buffer->data(), result));
@@ skipping 45 matching lines @@
 }
 
 TEST_F(NetworkReaderProxyTest, ErrorWithPendingData) {
   NetworkReaderProxy proxy(0, 10, 10, base::Bind(&base::DoNothing));
 
   net::TestCompletionCallback callback;
   const int kBufferSize = 3;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 
   // Supply the data before an error.
-  scoped_ptr<std::string> data(new std::string("abcde"));
+  std::unique_ptr<std::string> data(new std::string("abcde"));
   proxy.OnGetContent(std::move(data));
 
   // Emulate that an error is found.
   proxy.OnCompleted(FILE_ERROR_FAILED);
 
   // The next Read call should return the error code, even if there is
   // pending data (the pending data should be released in OnCompleted.
   EXPECT_EQ(net::ERR_FAILED,
             proxy.Read(buffer.get(), kBufferSize, callback.callback()));
 }
@@ skipping 44 matching lines @@
     return fake_file_system_.get();
   }
 
   DriveFileStreamReader::FileSystemGetter GetFileSystemGetter() {
     return base::Bind(&DriveFileStreamReaderTest::GetFileSystem,
                       base::Unretained(this));
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
 
-  scoped_ptr<base::Thread> worker_thread_;
+  std::unique_ptr<base::Thread> worker_thread_;
 
-  scoped_ptr<FakeDriveService> fake_drive_service_;
-  scoped_ptr<test_util::FakeFileSystem> fake_file_system_;
+  std::unique_ptr<FakeDriveService> fake_drive_service_;
+  std::unique_ptr<test_util::FakeFileSystem> fake_file_system_;
 };
 
 TEST_F(DriveFileStreamReaderTest, Read) {
   const base::FilePath kDriveFile =
       util::GetDriveMyDriveRootPath().AppendASCII("File 1.txt");
   // Create the reader, and initialize it.
   // In this case, the file is not yet locally cached.
-  scoped_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
+  std::unique_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
       GetFileSystemGetter(), worker_thread_->task_runner().get()));
   EXPECT_FALSE(reader->IsInitialized());
 
   int error = net::ERR_FAILED;
-  scoped_ptr<ResourceEntry> entry;
+  std::unique_ptr<ResourceEntry> entry;
   {
     base::RunLoop run_loop;
     reader->Initialize(
         kDriveFile,
         net::HttpByteRange(),
         google_apis::test_util::CreateQuitCallback(
             &run_loop,
             google_apis::test_util::CreateCopyResultCallback(&error, &entry)));
     run_loop.Run();
   }
@@ skipping 42 matching lines @@
 
 TEST_F(DriveFileStreamReaderTest, ReadRange) {
   // In this test case, we just confirm that the part of file is read.
   const int64_t kRangeOffset = 3;
   const int64_t kRangeLength = 4;
 
   const base::FilePath kDriveFile =
       util::GetDriveMyDriveRootPath().AppendASCII("File 1.txt");
   // Create the reader, and initialize it.
   // In this case, the file is not yet locally cached.
-  scoped_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
+  std::unique_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
       GetFileSystemGetter(), worker_thread_->task_runner().get()));
   EXPECT_FALSE(reader->IsInitialized());
 
   int error = net::ERR_FAILED;
-  scoped_ptr<ResourceEntry> entry;
+  std::unique_ptr<ResourceEntry> entry;
   net::HttpByteRange byte_range;
   byte_range.set_first_byte_position(kRangeOffset);
   // Last byte position is inclusive.
   byte_range.set_last_byte_position(kRangeOffset + kRangeLength - 1);
   {
     base::RunLoop run_loop;
     reader->Initialize(
         kDriveFile,
         byte_range,
         google_apis::test_util::CreateQuitCallback(
@@ skipping 43 matching lines @@
 }
 
 TEST_F(DriveFileStreamReaderTest, OutOfRangeError) {
   const int64_t kRangeOffset = 1000000;  // Out of range.
   const int64_t kRangeLength = 4;
 
   const base::FilePath kDriveFile =
       util::GetDriveMyDriveRootPath().AppendASCII("File 1.txt");
   // Create the reader, and initialize it.
   // In this case, the file is not yet locally cached.
-  scoped_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
+  std::unique_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
       GetFileSystemGetter(), worker_thread_->task_runner().get()));
   EXPECT_FALSE(reader->IsInitialized());
 
   int error = net::ERR_FAILED;
-  scoped_ptr<ResourceEntry> entry;
+  std::unique_ptr<ResourceEntry> entry;
   net::HttpByteRange byte_range;
   byte_range.set_first_byte_position(kRangeOffset);
   // Last byte position is inclusive.
   byte_range.set_last_byte_position(kRangeOffset + kRangeLength - 1);
   {
     base::RunLoop run_loop;
     reader->Initialize(
         kDriveFile,
         byte_range,
         google_apis::test_util::CreateQuitCallback(
             &run_loop,
             google_apis::test_util::CreateCopyResultCallback(&error, &entry)));
     run_loop.Run();
   }
   EXPECT_EQ(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE, error);
   EXPECT_FALSE(entry);
 }
 
 TEST_F(DriveFileStreamReaderTest, ZeroByteFileRead) {
   // Prepare an empty file
   {
     google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
-    scoped_ptr<google_apis::FileResource> entry;
+    std::unique_ptr<google_apis::FileResource> entry;
     fake_drive_service_->AddNewFile(
         "text/plain",
         "",  // empty
         fake_drive_service_->GetRootResourceId(),
         "EmptyFile.txt",
         false,  // shared_with_me
         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
     content::RunAllBlockingPoolTasksUntilIdle();
     ASSERT_EQ(google_apis::HTTP_CREATED, error);
     ASSERT_TRUE(entry);
     ASSERT_EQ(0, entry->file_size());
   }
 
   const base::FilePath kDriveFile =
       util::GetDriveMyDriveRootPath().AppendASCII("EmptyFile.txt");
   // Create the reader, and initialize it.
   // In this case, the file is not yet locally cached.
-  scoped_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
+  std::unique_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
       GetFileSystemGetter(), worker_thread_->task_runner().get()));
   EXPECT_FALSE(reader->IsInitialized());
 
   int error = net::ERR_FAILED;
-  scoped_ptr<ResourceEntry> entry;
+  std::unique_ptr<ResourceEntry> entry;
   {
     base::RunLoop run_loop;
     reader->Initialize(
         kDriveFile,
         net::HttpByteRange(),
         google_apis::test_util::CreateQuitCallback(
             &run_loop,
             google_apis::test_util::CreateCopyResultCallback(&error, &entry)));
     run_loop.Run();
   }
@@ skipping 29 matching lines @@
   ASSERT_TRUE(entry);
   EXPECT_TRUE(reader->IsInitialized());
 
   // Read data from the reader, again.
   std::string second_content;
   ASSERT_EQ(net::OK, test_util::ReadAllData(reader.get(), &second_content));
   EXPECT_EQ(0u, second_content.size());
 }
 
 }  // namespace drive