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

chrome/browser/chromeos/file_system_provider/fileapi/buffering_file_stream_writer_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_writer.h"
+
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.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_writer.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 {
 
 // Size of the intermediate buffer in bytes.
@@ skipping 85 matching lines @@
 
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_refptr<net::StringIOBuffer> short_text_buffer_;
   scoped_refptr<net::StringIOBuffer> long_text_buffer_;
 };
 
 TEST_F(FileSystemProviderBufferingFileStreamWriterTest, Write) {
   std::vector<std::string> inner_write_log;
   std::vector<int> inner_flush_log;
   BufferingFileStreamWriter writer(
-      make_scoped_ptr(new FakeFileStreamWriter(
+      base::WrapUnique(new FakeFileStreamWriter(
           &inner_write_log, &inner_flush_log, NULL, net::OK)),
       kIntermediateBufferLength);
 
   ASSERT_LT(kIntermediateBufferLength, 2 * short_text_buffer_->size());
 
   // Writing for the first time should succeed, but buffer the write without
   // calling the inner file stream writer.
   {
     std::vector<int> write_log;
     const int result = writer.Write(short_text_buffer_.get(),
@@ skipping 53 matching lines @@
     const int expected_inner_flush = 2 * short_text_buffer_->size();
     ASSERT_EQ(1u, inner_flush_log.size());
     EXPECT_EQ(expected_inner_flush, inner_flush_log[0]);
   }
 }
 
 TEST_F(FileSystemProviderBufferingFileStreamWriterTest, Write_WithError) {
   std::vector<std::string> inner_write_log;
   std::vector<int> inner_flush_log;
   BufferingFileStreamWriter writer(
-      scoped_ptr<storage::FileStreamWriter>(new FakeFileStreamWriter(
+      std::unique_ptr<storage::FileStreamWriter>(new FakeFileStreamWriter(
           &inner_write_log, &inner_flush_log, NULL, net::ERR_FAILED)),
       kIntermediateBufferLength);
 
   ASSERT_LT(kIntermediateBufferLength, 2 * short_text_buffer_->size());
 
   // Writing for the first time should succeed, but buffer the write without
   // calling the inner file stream writer. Because of that, the error will
   // not be generated unless the intermediate buffer is flushed.
   {
     std::vector<int> write_log;
@@ skipping 29 matching lines @@
     ASSERT_EQ(1u, write_log.size());
     EXPECT_EQ(net::ERR_FAILED, write_log[0]);
     EXPECT_EQ(0u, inner_flush_log.size());
   }
 }
 
 TEST_F(FileSystemProviderBufferingFileStreamWriterTest, Write_Directly) {
   std::vector<std::string> inner_write_log;
   std::vector<int> inner_flush_log;
   BufferingFileStreamWriter writer(
-      scoped_ptr<storage::FileStreamWriter>(new FakeFileStreamWriter(
+      std::unique_ptr<storage::FileStreamWriter>(new FakeFileStreamWriter(
           &inner_write_log, &inner_flush_log, NULL, net::OK)),
       kIntermediateBufferLength);
 
   ASSERT_GT(kIntermediateBufferLength, short_text_buffer_->size());
   ASSERT_LT(kIntermediateBufferLength, long_text_buffer_->size());
 
   // Write few bytes first, so the intermediate buffer is not empty.
   {
     std::vector<int> write_log;
     const int result = writer.Write(short_text_buffer_.get(),
@@ skipping 47 matching lines @@
     EXPECT_EQ(0u, inner_flush_log.size());
   }
 }
 
 TEST_F(FileSystemProviderBufferingFileStreamWriterTest, Cancel) {
   std::vector<std::string> inner_write_log;
   std::vector<int> inner_flush_log;
   int inner_cancel_counter = 0;
 
   BufferingFileStreamWriter writer(
-      scoped_ptr<storage::FileStreamWriter>(new FakeFileStreamWriter(
+      std::unique_ptr<storage::FileStreamWriter>(new FakeFileStreamWriter(
           &inner_write_log, &inner_flush_log, &inner_cancel_counter, net::OK)),
       kIntermediateBufferLength);
 
   // Write directly, so there is something to actually cancel. Note, that
   // buffered writes which do not invoke flushing the intermediate buffer finish
   // immediately, so they are not cancellable.
   std::vector<int> write_log;
   const int write_result = writer.Write(long_text_buffer_.get(),
                                         long_text_buffer_->size(),
                                         base::Bind(&LogValue<int>, &write_log));
   EXPECT_EQ(net::ERR_IO_PENDING, write_result);
 
   std::vector<int> cancel_log;
   const int cancel_result =
       writer.Cancel(base::Bind(&LogValue<int>, &cancel_log));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(net::ERR_IO_PENDING, cancel_result);
   ASSERT_EQ(1u, cancel_log.size());
   EXPECT_EQ(net::OK, cancel_log[0]);
   EXPECT_EQ(1, inner_cancel_counter);
 }
 
 TEST_F(FileSystemProviderBufferingFileStreamWriterTest, Flush) {
   std::vector<std::string> inner_write_log;
   std::vector<int> inner_flush_log;
   BufferingFileStreamWriter writer(
-      scoped_ptr<storage::FileStreamWriter>(new FakeFileStreamWriter(
+      std::unique_ptr<storage::FileStreamWriter>(new FakeFileStreamWriter(
           &inner_write_log, &inner_flush_log, NULL, net::OK)),
       kIntermediateBufferLength);
 
   // Write less bytes than size of the intermediate buffer.
   std::vector<int> write_log;
   const int write_result = writer.Write(short_text_buffer_.get(),
                                         short_text_buffer_->size(),
                                         base::Bind(&LogValue<int>, &write_log));
   base::RunLoop().RunUntilIdle();
 
@@ skipping 16 matching lines @@
   EXPECT_EQ(kShortTextToWrite, inner_write_log[0]);
 
   ASSERT_EQ(1u, inner_flush_log.size());
   EXPECT_EQ(short_text_buffer_->size(), inner_flush_log[0]);
 }
 
 TEST_F(FileSystemProviderBufferingFileStreamWriterTest, Flush_AfterWriteError) {
   std::vector<std::string> inner_write_log;
   std::vector<int> inner_flush_log;
   BufferingFileStreamWriter writer(
-      scoped_ptr<storage::FileStreamWriter>(new FakeFileStreamWriter(
+      std::unique_ptr<storage::FileStreamWriter>(new FakeFileStreamWriter(
           &inner_write_log, &inner_flush_log, NULL, net::ERR_FAILED)),
       kIntermediateBufferLength);
 
   // Write less bytes than size of the intermediate buffer. This should succeed
   // since the inner file stream writer is not invoked.
   std::vector<int> write_log;
   const int write_result = writer.Write(short_text_buffer_.get(),
                                         short_text_buffer_->size(),
                                         base::Bind(&LogValue<int>, &write_log));
   base::RunLoop().RunUntilIdle();
@@ skipping 16 matching lines @@
   ASSERT_EQ(1u, inner_write_log.size());
   EXPECT_EQ(kShortTextToWrite, inner_write_log[0]);
 
   // Flush of the inner file stream writer is not invoked, since a Write method
   // invocation fails before it.
   EXPECT_EQ(0u, inner_flush_log.size());
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos