Remove ScopedVector from ElementsUploadDataStream

net/base/elements_upload_data_stream_unittest.cc

 // Copyright (c) 2012 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 "net/base/elements_upload_data_stream.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 124 matching lines @@
   ~ElementsUploadDataStreamTest() override {
     element_readers_.clear();
     base::RunLoop().RunUntilIdle();
   }
 
   void FileChangedHelper(const base::FilePath& file_path,
                          const base::Time& time,
                          bool error_expected);
 
   base::ScopedTempDir temp_dir_;
-  ScopedVector<UploadElementReader> element_readers_;
+  std::vector<scoped_ptr<UploadElementReader>> element_readers_;
 };
 
 TEST_F(ElementsUploadDataStreamTest, EmptyUploadData) {
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
   ASSERT_EQ(OK, stream->Init(CompletionCallback()));
   EXPECT_TRUE(stream->IsInMemory());
   EXPECT_EQ(0U, stream->size());
   EXPECT_EQ(0U, stream->position());
   EXPECT_TRUE(stream->IsEOF());
 }
 
 TEST_F(ElementsUploadDataStreamTest, ConsumeAllBytes) {
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
+  element_readers_.push_back(
+      make_scoped_ptr(new UploadBytesElementReader(kTestData, kTestDataSize)));
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
   ASSERT_EQ(OK, stream->Init(CompletionCallback()));
   EXPECT_TRUE(stream->IsInMemory());
   EXPECT_EQ(kTestDataSize, stream->size());
   EXPECT_EQ(0U, stream->position());
   EXPECT_FALSE(stream->IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream->IsEOF()) {
     int bytes_read =
         stream->Read(buf.get(), kTestBufferSize, CompletionCallback());
     ASSERT_LE(0, bytes_read);  // Not an error.
   }
   EXPECT_EQ(kTestDataSize, stream->position());
   ASSERT_TRUE(stream->IsEOF());
 }
 
 TEST_F(ElementsUploadDataStreamTest, File) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
-  element_readers_.push_back(
-      new UploadFileElementReader(base::ThreadTaskRunnerHandle::Get().get(),
-                                  temp_file_path, 0, kuint64max, base::Time()));
+  element_readers_.push_back(make_scoped_ptr(new UploadFileElementReader(
+      base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0, kuint64max,
+      base::Time())));
 
   TestCompletionCallback init_callback;
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
   ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback.callback()));
   ASSERT_EQ(OK, init_callback.WaitForResult());
   EXPECT_FALSE(stream->IsInMemory());
   EXPECT_EQ(kTestDataSize, stream->size());
   EXPECT_EQ(0U, stream->position());
   EXPECT_FALSE(stream->IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream->IsEOF()) {
     TestCompletionCallback read_callback;
     ASSERT_EQ(
         ERR_IO_PENDING,
         stream->Read(buf.get(), kTestBufferSize, read_callback.callback()));
     ASSERT_LE(0, read_callback.WaitForResult());  // Not an error.
   }
   EXPECT_EQ(kTestDataSize, stream->position());
   ASSERT_TRUE(stream->IsEOF());
 }
 
 TEST_F(ElementsUploadDataStreamTest, FileSmallerThanLength) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
   const uint64_t kFakeSize = kTestDataSize * 2;
 
   UploadFileElementReader::ScopedOverridingContentLengthForTests
       overriding_content_length(kFakeSize);
 
-  element_readers_.push_back(
-      new UploadFileElementReader(base::ThreadTaskRunnerHandle::Get().get(),
-                                  temp_file_path, 0, kuint64max, base::Time()));
+  element_readers_.push_back(make_scoped_ptr(new UploadFileElementReader(
+      base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0, kuint64max,
+      base::Time())));
 
   TestCompletionCallback init_callback;
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
   ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback.callback()));
   ASSERT_EQ(OK, init_callback.WaitForResult());
   EXPECT_FALSE(stream->IsInMemory());
   EXPECT_EQ(kFakeSize, stream->size());
   EXPECT_EQ(0U, stream->position());
   EXPECT_FALSE(stream->IsEOF());
   uint64_t read_counter = 0;
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream->IsEOF()) {
     TestCompletionCallback read_callback;
     ASSERT_EQ(
         ERR_IO_PENDING,
         stream->Read(buf.get(), kTestBufferSize, read_callback.callback()));
     int bytes_read = read_callback.WaitForResult();
     ASSERT_LE(0, bytes_read);  // Not an error.
     read_counter += bytes_read;
     EXPECT_EQ(read_counter, stream->position());
   }
   // UpdateDataStream will pad out the file with 0 bytes so that the HTTP
   // transaction doesn't hang.  Therefore we expected the full size.
   EXPECT_EQ(kFakeSize, read_counter);
   EXPECT_EQ(read_counter, stream->position());
 }
 
 TEST_F(ElementsUploadDataStreamTest, ReadErrorSync) {
   // This element cannot be read.
-  MockUploadElementReader* reader =
-      new MockUploadElementReader(kTestDataSize, true);
+  scoped_ptr<MockUploadElementReader> reader(
+      new MockUploadElementReader(kTestDataSize, true));
   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
   reader->SetReadExpectation(ERR_FAILED);
-  element_readers_.push_back(reader);
+  element_readers_.push_back(std::move(reader));
 
   // This element is ignored because of the error from the previous reader.
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
+  element_readers_.push_back(
+      make_scoped_ptr(new UploadBytesElementReader(kTestData, kTestDataSize)));
 
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
 
   // Run Init().
   ASSERT_EQ(OK, stream->Init(CompletionCallback()));
   EXPECT_EQ(kTestDataSize*2, stream->size());
   EXPECT_EQ(0U, stream->position());
   EXPECT_FALSE(stream->IsEOF());
 
   // Prepare a buffer filled with non-zero data.
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   std::fill_n(buf->data(), kTestBufferSize, -1);
 
   // Read() results in success even when the reader returns error.
   EXPECT_EQ(static_cast<int>(kTestDataSize * 2),
             stream->Read(buf.get(), kTestBufferSize, CompletionCallback()));
   EXPECT_EQ(kTestDataSize * 2, stream->position());
   EXPECT_TRUE(stream->IsEOF());
 
   // The buffer is filled with zero.
   EXPECT_EQ(static_cast<int>(kTestDataSize*2),
             std::count(buf->data(), buf->data() + kTestBufferSize, 0));
 }
 
 TEST_F(ElementsUploadDataStreamTest, ReadErrorAsync) {
   // This element cannot be read.
-  MockUploadElementReader* reader =
-      new MockUploadElementReader(kTestDataSize, false);
+  scoped_ptr<MockUploadElementReader> reader(
+      new MockUploadElementReader(kTestDataSize, false));
   reader->SetAsyncInitExpectation(OK);
   reader->SetReadExpectation(ERR_FAILED);
-  element_readers_.push_back(reader);
+  element_readers_.push_back(std::move(reader));
 
   // This element is ignored because of the error from the previous reader.
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
+  element_readers_.push_back(
+      make_scoped_ptr(new UploadBytesElementReader(kTestData, kTestDataSize)));
 
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
 
   // Run Init().
   TestCompletionCallback init_callback;
   ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback.callback()));
   EXPECT_EQ(OK, init_callback.WaitForResult());
   EXPECT_EQ(kTestDataSize*2, stream->size());
   EXPECT_EQ(0U, stream->position());
   EXPECT_FALSE(stream->IsEOF());
 
   // Prepare a buffer filled with non-zero data.
@@ skipping 15 matching lines @@
 
 TEST_F(ElementsUploadDataStreamTest, FileAndBytes) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   const uint64_t kFileRangeOffset = 1;
   const uint64_t kFileRangeLength = 4;
-  element_readers_.push_back(new UploadFileElementReader(
+  element_readers_.push_back(make_scoped_ptr(new UploadFileElementReader(
       base::ThreadTaskRunnerHandle::Get().get(), temp_file_path,
-      kFileRangeOffset, kFileRangeLength, base::Time()));
+      kFileRangeOffset, kFileRangeLength, base::Time())));
 
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
+  element_readers_.push_back(
+      make_scoped_ptr(new UploadBytesElementReader(kTestData, kTestDataSize)));
 
   const uint64_t kStreamSize = kTestDataSize + kFileRangeLength;
   TestCompletionCallback init_callback;
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
   ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback.callback()));
   ASSERT_EQ(OK, init_callback.WaitForResult());
   EXPECT_FALSE(stream->IsInMemory());
   EXPECT_EQ(kStreamSize, stream->size());
   EXPECT_EQ(0U, stream->position());
   EXPECT_FALSE(stream->IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream->IsEOF()) {
     TestCompletionCallback read_callback;
     const int result =
         stream->Read(buf.get(), kTestBufferSize, read_callback.callback());
     const int bytes_read =
         result != ERR_IO_PENDING ? result : read_callback.WaitForResult();
     ASSERT_LE(0, bytes_read);  // Not an error.
   }
   EXPECT_EQ(kStreamSize, stream->position());
   ASSERT_TRUE(stream->IsEOF());
 }
 
 // Init() with on-memory and not-on-memory readers.
 TEST_F(ElementsUploadDataStreamTest, InitAsync) {
   // Create UploadDataStream with mock readers.
-  MockUploadElementReader* reader = NULL;
+  scoped_ptr<MockUploadElementReader> reader(
+      new MockUploadElementReader(kTestDataSize, true));
+  EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
+  element_readers_.push_back(std::move(reader));
 
-  reader = new MockUploadElementReader(kTestDataSize, true);
-  EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
-  element_readers_.push_back(reader);
+  scoped_ptr<MockUploadElementReader> reader2(
+      new MockUploadElementReader(kTestDataSize, true));
+  EXPECT_CALL(*reader2, Init(_)).WillOnce(Return(OK));
+  element_readers_.push_back(std::move(reader2));
 
-  reader = new MockUploadElementReader(kTestDataSize, true);
-  EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
-  element_readers_.push_back(reader);
+  scoped_ptr<MockUploadElementReader> reader3(
+      new MockUploadElementReader(kTestDataSize, false));
+  reader3->SetAsyncInitExpectation(OK);
+  element_readers_.push_back(std::move(reader3));
 
-  reader = new MockUploadElementReader(kTestDataSize, false);
-  reader->SetAsyncInitExpectation(OK);
-  element_readers_.push_back(reader);
+  scoped_ptr<MockUploadElementReader> reader4(
+      new MockUploadElementReader(kTestDataSize, false));
+  reader4->SetAsyncInitExpectation(OK);
+  element_readers_.push_back(std::move(reader4));
 
-  reader = new MockUploadElementReader(kTestDataSize, false);
-  reader->SetAsyncInitExpectation(OK);
-  element_readers_.push_back(reader);
-
-  reader = new MockUploadElementReader(kTestDataSize, true);
-  EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
-  element_readers_.push_back(reader);
+  scoped_ptr<MockUploadElementReader> reader5(
+      new MockUploadElementReader(kTestDataSize, true));
+  EXPECT_CALL(*reader5, Init(_)).WillOnce(Return(OK));
+  element_readers_.push_back(std::move(reader5));
 
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
 
   // Run Init().
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING, stream->Init(callback.callback()));
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 // Init() of a reader fails asynchronously.
 TEST_F(ElementsUploadDataStreamTest, InitAsyncFailureAsync) {
   // Create UploadDataStream with a mock reader.
-  MockUploadElementReader* reader = NULL;
-
-  reader = new MockUploadElementReader(kTestDataSize, false);
+  scoped_ptr<MockUploadElementReader> reader(
+      new MockUploadElementReader(kTestDataSize, false));
   reader->SetAsyncInitExpectation(ERR_FAILED);
-  element_readers_.push_back(reader);
+  element_readers_.push_back(std::move(reader));
 
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
 
   // Run Init().
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING, stream->Init(callback.callback()));
   EXPECT_EQ(ERR_FAILED, callback.WaitForResult());
 }
 
 // Init() of a reader fails synchronously.
 TEST_F(ElementsUploadDataStreamTest, InitAsyncFailureSync) {
   // Create UploadDataStream with mock readers.
-  MockUploadElementReader* reader = NULL;
+  scoped_ptr<MockUploadElementReader> reader(
+      new MockUploadElementReader(kTestDataSize, false));
+  reader->SetAsyncInitExpectation(OK);
+  element_readers_.push_back(std::move(reader));
 
-  reader = new MockUploadElementReader(kTestDataSize, false);
-  reader->SetAsyncInitExpectation(OK);
-  element_readers_.push_back(reader);
-
-  reader = new MockUploadElementReader(kTestDataSize, true);
-  EXPECT_CALL(*reader, Init(_)).WillOnce(Return(ERR_FAILED));
-  element_readers_.push_back(reader);
+  scoped_ptr<MockUploadElementReader> reader2(
+      new MockUploadElementReader(kTestDataSize, true));
+  EXPECT_CALL(*reader2, Init(_)).WillOnce(Return(ERR_FAILED));
+  element_readers_.push_back(std::move(reader2));
 
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
 
   // Run Init().
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING, stream->Init(callback.callback()));
   EXPECT_EQ(ERR_FAILED, callback.WaitForResult());
 }
 
 // Read with a buffer whose size is same as the data.
 TEST_F(ElementsUploadDataStreamTest, ReadAsyncWithExactSizeBuffer) {
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
+  element_readers_.push_back(
+      make_scoped_ptr(new UploadBytesElementReader(kTestData, kTestDataSize)));
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
 
   ASSERT_EQ(OK, stream->Init(CompletionCallback()));
   EXPECT_TRUE(stream->IsInMemory());
   EXPECT_EQ(kTestDataSize, stream->size());
   EXPECT_EQ(0U, stream->position());
   EXPECT_FALSE(stream->IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestDataSize);
   int bytes_read = stream->Read(buf.get(), kTestDataSize, CompletionCallback());
   ASSERT_EQ(static_cast<int>(kTestDataSize), bytes_read);  // Not an error.
   EXPECT_EQ(kTestDataSize, stream->position());
   ASSERT_TRUE(stream->IsEOF());
 }
 
 // Async Read() with on-memory and not-on-memory readers.
 TEST_F(ElementsUploadDataStreamTest, ReadAsync) {
   // Create UploadDataStream with mock readers.
-  MockUploadElementReader* reader = NULL;
-
-  reader = new MockUploadElementReader(kTestDataSize, true);
+  scoped_ptr<MockUploadElementReader> reader(
+      new MockUploadElementReader(kTestDataSize, true));
   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
   reader->SetReadExpectation(kTestDataSize);
-  element_readers_.push_back(reader);
+  element_readers_.push_back(std::move(reader));
 
-  reader = new MockUploadElementReader(kTestDataSize, false);
-  reader->SetAsyncInitExpectation(OK);
-  reader->SetReadExpectation(kTestDataSize);
-  element_readers_.push_back(reader);
+  scoped_ptr<MockUploadElementReader> reader2(
+      new MockUploadElementReader(kTestDataSize, false));
+  reader2->SetAsyncInitExpectation(OK);
+  reader2->SetReadExpectation(kTestDataSize);
+  element_readers_.push_back(std::move(reader2));
 
-  reader = new MockUploadElementReader(kTestDataSize, true);
-  EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
-  reader->SetReadExpectation(kTestDataSize);
-  element_readers_.push_back(reader);
+  scoped_ptr<MockUploadElementReader> reader3(
+      new MockUploadElementReader(kTestDataSize, true));
+  EXPECT_CALL(*reader3, Init(_)).WillOnce(Return(OK));
+  reader3->SetReadExpectation(kTestDataSize);
+  element_readers_.push_back(std::move(reader3));
 
-  reader = new MockUploadElementReader(kTestDataSize, false);
-  reader->SetAsyncInitExpectation(OK);
-  reader->SetReadExpectation(kTestDataSize);
-  element_readers_.push_back(reader);
+  scoped_ptr<MockUploadElementReader> reader4(
+      new MockUploadElementReader(kTestDataSize, false));
+  reader4->SetAsyncInitExpectation(OK);
+  reader4->SetReadExpectation(kTestDataSize);
+  element_readers_.push_back(std::move(reader4));
 
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
 
   // Run Init().
   TestCompletionCallback init_callback;
   EXPECT_EQ(ERR_IO_PENDING, stream->Init(init_callback.callback()));
   EXPECT_EQ(OK, init_callback.WaitForResult());
 
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
 
   // Consume the first element.
   TestCompletionCallback read_callback1;
@@ skipping 16 matching lines @@
   EXPECT_EQ(static_cast<int>(kTestDataSize * 2),
             read_callback3.WaitForResult());
 }
 
 void ElementsUploadDataStreamTest::FileChangedHelper(
     const base::FilePath& file_path,
     const base::Time& time,
     bool error_expected) {
   // Don't use element_readers_ here, as this function is called twice, and
   // reusing element_readers_ is wrong.
-  ScopedVector<UploadElementReader> element_readers;
-  element_readers.push_back(new UploadFileElementReader(
-      base::ThreadTaskRunnerHandle::Get().get(), file_path, 1, 2, time));
+  std::vector<scoped_ptr<UploadElementReader>> element_readers;
+  element_readers.push_back(make_scoped_ptr(new UploadFileElementReader(
+      base::ThreadTaskRunnerHandle::Get().get(), file_path, 1, 2, time)));
 
   TestCompletionCallback init_callback;
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers), 0));
   ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback.callback()));
   int error_code = init_callback.WaitForResult();
   if (error_expected)
     ASSERT_EQ(ERR_UPLOAD_FILE_CHANGED, error_code);
   else
     ASSERT_EQ(OK, error_code);
 }
 
 TEST_F(ElementsUploadDataStreamTest, FileChanged) {
   base::FilePath temp_file_path;
@@ skipping 15 matching lines @@
 }
 
 TEST_F(ElementsUploadDataStreamTest, MultipleInit) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   // Prepare data.
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
   element_readers_.push_back(
-      new UploadFileElementReader(base::ThreadTaskRunnerHandle::Get().get(),
-                                  temp_file_path, 0, kuint64max, base::Time()));
+      make_scoped_ptr(new UploadBytesElementReader(kTestData, kTestDataSize)));
+  element_readers_.push_back(make_scoped_ptr(new UploadFileElementReader(
+      base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0, kuint64max,
+      base::Time())));
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
 
   std::string expected_data(kTestData, kTestData + kTestDataSize);
   expected_data += expected_data;
 
   // Call Init().
   TestCompletionCallback init_callback1;
   ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback1.callback()));
   ASSERT_EQ(OK, init_callback1.WaitForResult());
   EXPECT_FALSE(stream->IsEOF());
   EXPECT_EQ(kTestDataSize*2, stream->size());
@@ skipping 16 matching lines @@
 
 TEST_F(ElementsUploadDataStreamTest, MultipleInitAsync) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
   TestCompletionCallback test_callback;
 
   // Prepare data.
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
   element_readers_.push_back(
-      new UploadFileElementReader(base::ThreadTaskRunnerHandle::Get().get(),
-                                  temp_file_path, 0, kuint64max, base::Time()));
+      make_scoped_ptr(new UploadBytesElementReader(kTestData, kTestDataSize)));
+  element_readers_.push_back(make_scoped_ptr(new UploadFileElementReader(
+      base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0, kuint64max,
+      base::Time())));
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
 
   std::string expected_data(kTestData, kTestData + kTestDataSize);
   expected_data += expected_data;
 
   // Call Init().
   ASSERT_EQ(ERR_IO_PENDING, stream->Init(test_callback.callback()));
   EXPECT_EQ(OK, test_callback.WaitForResult());
   EXPECT_FALSE(stream->IsEOF());
   EXPECT_EQ(kTestDataSize*2, stream->size());
 
@@ skipping 13 matching lines @@
 }
 
 TEST_F(ElementsUploadDataStreamTest, InitToReset) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   // Prepare data.
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
   element_readers_.push_back(
-      new UploadFileElementReader(base::ThreadTaskRunnerHandle::Get().get(),
-                                  temp_file_path, 0, kuint64max, base::Time()));
+      make_scoped_ptr(new UploadBytesElementReader(kTestData, kTestDataSize)));
+  element_readers_.push_back(make_scoped_ptr(new UploadFileElementReader(
+      base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0, kuint64max,
+      base::Time())));
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
 
   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
   expected_data.insert(expected_data.end(), kTestData,
                        kTestData + kTestDataSize);
 
   // Call Init().
   TestCompletionCallback init_callback1;
   ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback1.callback()));
   EXPECT_EQ(OK, init_callback1.WaitForResult());
   EXPECT_FALSE(stream->IsEOF());
@@ skipping 29 matching lines @@
 }
 
 TEST_F(ElementsUploadDataStreamTest, InitDuringAsyncInit) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   // Prepare data.
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
   element_readers_.push_back(
-      new UploadFileElementReader(base::ThreadTaskRunnerHandle::Get().get(),
-                                  temp_file_path, 0, kuint64max, base::Time()));
+      make_scoped_ptr(new UploadBytesElementReader(kTestData, kTestDataSize)));
+  element_readers_.push_back(make_scoped_ptr(new UploadFileElementReader(
+      base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0, kuint64max,
+      base::Time())));
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
 
   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
   expected_data.insert(expected_data.end(), kTestData,
                        kTestData + kTestDataSize);
 
   // Start Init.
   TestCompletionCallback init_callback1;
   EXPECT_EQ(ERR_IO_PENDING, stream->Init(init_callback1.callback()));
 
   // Call Init again to cancel the previous init.
@@ skipping 19 matching lines @@
 }
 
 TEST_F(ElementsUploadDataStreamTest, InitDuringAsyncRead) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   // Prepare data.
-  element_readers_.push_back(new UploadBytesElementReader(
-      kTestData, kTestDataSize));
   element_readers_.push_back(
-      new UploadFileElementReader(base::ThreadTaskRunnerHandle::Get().get(),
-                                  temp_file_path, 0, kuint64max, base::Time()));
+      make_scoped_ptr(new UploadBytesElementReader(kTestData, kTestDataSize)));
+  element_readers_.push_back(make_scoped_ptr(new UploadFileElementReader(
+      base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0, kuint64max,
+      base::Time())));
   scoped_ptr<UploadDataStream> stream(
-      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+      new ElementsUploadDataStream(std::move(element_readers_), 0));
 
   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
   expected_data.insert(expected_data.end(), kTestData,
                        kTestData + kTestDataSize);
 
   // Call Init().
   TestCompletionCallback init_callback1;
   ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback1.callback()));
   EXPECT_EQ(OK, init_callback1.WaitForResult());
   EXPECT_FALSE(stream->IsEOF());
@@ skipping 24 matching lines @@
                 wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
   EXPECT_EQ(expected_data, buf2);
   EXPECT_TRUE(stream->IsEOF());
 
   // Make sure callbacks are not called for cancelled operations.
   EXPECT_FALSE(read_callback1.have_result());
 }
 
 }  // namespace net