Remove ScopedVector from ElementsUploadDataStream

net/spdy/spdy_network_transaction_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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
-#include "base/memory/scoped_vector.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "base/test/test_file_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/auth.h"
 #include "net/base/chunked_upload_data_stream.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/request_priority.h"
 #include "net/base/test_data_directory.h"
@@ skipping 430 matching lines @@
       get_request_.url = GURL(GetDefaultUrl());
       get_request_.load_flags = 0;
       get_request_.extra_headers.SetHeader("User-Agent", "Chrome");
       get_request_initialized_ = true;
     }
     return get_request_;
   }
 
   const HttpRequestInfo& CreatePostRequest() {
     if (!post_request_initialized_) {
-      ScopedVector<UploadElementReader> element_readers;
-      element_readers.push_back(
-          new UploadBytesElementReader(kUploadData, kUploadDataSize));
+      std::vector<scoped_ptr<UploadElementReader>> element_readers;
+      element_readers.push_back(make_scoped_ptr(
+          new UploadBytesElementReader(kUploadData, kUploadDataSize)));
       upload_data_stream_.reset(
-          new ElementsUploadDataStream(element_readers.Pass(), 0));
+          new ElementsUploadDataStream(std::move(element_readers), 0));
 
       post_request_.method = "POST";
       post_request_.url = GURL(GetDefaultUrl());
       post_request_.upload_data_stream = upload_data_stream_.get();
       post_request_initialized_ = true;
     }
     return post_request_;
   }
 
   const HttpRequestInfo& CreateFilePostRequest() {
     if (!post_request_initialized_) {
       base::FilePath file_path;
       CHECK(base::CreateTemporaryFileInDir(temp_dir_.path(), &file_path));
       CHECK_EQ(static_cast<int>(kUploadDataSize),
                base::WriteFile(file_path, kUploadData, kUploadDataSize));
 
-      ScopedVector<UploadElementReader> element_readers;
-      element_readers.push_back(new UploadFileElementReader(
+      std::vector<scoped_ptr<UploadElementReader>> element_readers;
+      element_readers.push_back(make_scoped_ptr(new UploadFileElementReader(
           base::ThreadTaskRunnerHandle::Get().get(), file_path, 0,
-          kUploadDataSize, base::Time()));
+          kUploadDataSize, base::Time())));
       upload_data_stream_.reset(
-          new ElementsUploadDataStream(element_readers.Pass(), 0));
+          new ElementsUploadDataStream(std::move(element_readers), 0));
 
       post_request_.method = "POST";
       post_request_.url = GURL(GetDefaultUrl());
       post_request_.upload_data_stream = upload_data_stream_.get();
       post_request_initialized_ = true;
     }
     return post_request_;
   }
 
   const HttpRequestInfo& CreateUnreadableFilePostRequest() {
     if (post_request_initialized_)
       return post_request_;
 
     base::FilePath file_path;
     CHECK(base::CreateTemporaryFileInDir(temp_dir_.path(), &file_path));
     CHECK_EQ(static_cast<int>(kUploadDataSize),
              base::WriteFile(file_path, kUploadData, kUploadDataSize));
     CHECK(base::MakeFileUnreadable(file_path));
 
-    ScopedVector<UploadElementReader> element_readers;
-    element_readers.push_back(new UploadFileElementReader(
+    std::vector<scoped_ptr<UploadElementReader>> element_readers;
+    element_readers.push_back(make_scoped_ptr(new UploadFileElementReader(
         base::ThreadTaskRunnerHandle::Get().get(), file_path, 0,
-        kUploadDataSize, base::Time()));
+        kUploadDataSize, base::Time())));
     upload_data_stream_.reset(
-        new ElementsUploadDataStream(element_readers.Pass(), 0));
+        new ElementsUploadDataStream(std::move(element_readers), 0));
 
     post_request_.method = "POST";
     post_request_.url = GURL(GetDefaultUrl());
     post_request_.upload_data_stream = upload_data_stream_.get();
     post_request_initialized_ = true;
     return post_request_;
   }
 
   const HttpRequestInfo& CreateComplexPostRequest() {
     if (!post_request_initialized_) {
       const int kFileRangeOffset = 1;
       const int kFileRangeLength = 3;
       CHECK_LT(kFileRangeOffset + kFileRangeLength, kUploadDataSize);
 
       base::FilePath file_path;
       CHECK(base::CreateTemporaryFileInDir(temp_dir_.path(), &file_path));
       CHECK_EQ(static_cast<int>(kUploadDataSize),
                base::WriteFile(file_path, kUploadData, kUploadDataSize));
 
-      ScopedVector<UploadElementReader> element_readers;
-      element_readers.push_back(
-          new UploadBytesElementReader(kUploadData, kFileRangeOffset));
-      element_readers.push_back(new UploadFileElementReader(
+      std::vector<scoped_ptr<UploadElementReader>> element_readers;
+      element_readers.push_back(make_scoped_ptr(
+          new UploadBytesElementReader(kUploadData, kFileRangeOffset)));
+      element_readers.push_back(make_scoped_ptr(new UploadFileElementReader(
           base::ThreadTaskRunnerHandle::Get().get(), file_path,
-          kFileRangeOffset, kFileRangeLength, base::Time()));
-      element_readers.push_back(new UploadBytesElementReader(
+          kFileRangeOffset, kFileRangeLength, base::Time())));
+      element_readers.push_back(make_scoped_ptr(new UploadBytesElementReader(
           kUploadData + kFileRangeOffset + kFileRangeLength,
-          kUploadDataSize - (kFileRangeOffset + kFileRangeLength)));
+          kUploadDataSize - (kFileRangeOffset + kFileRangeLength))));
       upload_data_stream_.reset(
-          new ElementsUploadDataStream(element_readers.Pass(), 0));
+          new ElementsUploadDataStream(std::move(element_readers), 0));
 
       post_request_.method = "POST";
       post_request_.url = GURL(GetDefaultUrl());
       post_request_.upload_data_stream = upload_data_stream_.get();
       post_request_initialized_ = true;
     }
     return post_request_;
   }
 
   const HttpRequestInfo& CreateChunkedPostRequest() {
@@ skipping 1386 matching lines @@
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a simple POST works.
 TEST_P(SpdyNetworkTransactionTest, EmptyPost) {
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
   // Create an empty UploadDataStream.
-  ScopedVector<UploadElementReader> element_readers;
-  ElementsUploadDataStream stream(element_readers.Pass(), 0);
+  std::vector<scoped_ptr<UploadElementReader>> element_readers;
+  ElementsUploadDataStream stream(std::move(element_readers), 0);
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL(GetDefaultUrl());
   request.upload_data_stream = &stream;
 
   const uint64 kContentLength = 0;
 
   scoped_ptr<SpdyHeaderBlock> req_block(
@@ skipping 3875 matching lines @@
     CreateMockRead(*window_update, 8),     // kDeltaWindowSize * 4
     CreateMockRead(*window_update, 9),
     CreateMockRead(*resp, 10),
     CreateMockRead(*body_end, 11),
     MockRead(ASYNC, 0, 0, 12)  // EOF
   };
 
   DeterministicSocketData data(reads, arraysize(reads),
                                writes, arraysize(writes));
 
-  ScopedVector<UploadElementReader> element_readers;
+  std::vector<scoped_ptr<UploadElementReader>> element_readers;
   for (int i = 0; i < kFrameCount; ++i) {
-    element_readers.push_back(
-        new UploadBytesElementReader(content->c_str(), content->size()));
+    element_readers.push_back(make_scoped_ptr(
+        new UploadBytesElementReader(content->c_str(), content->size())));
   }
-  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL(GetDefaultUrl());
   request.upload_data_stream = &upload_data_stream;
 
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.SetDeterministic();
@@ skipping 188 matching lines @@
   scoped_ptr<SpdyFrame> window_update(
       spdy_util_.ConstructSpdyWindowUpdate(1, kDeltaWindowSize));
   MockRead reads[] = {
     CreateMockRead(*window_update, 1),
     MockRead(ASYNC, 0, 4)  // EOF
   };
 
   DeterministicSocketData data(reads, arraysize(reads),
                                writes, arraysize(writes));
 
-  ScopedVector<UploadElementReader> element_readers;
+  std::vector<scoped_ptr<UploadElementReader>> element_readers;
   for (int i = 0; i < kFrameCount; ++i) {
-    element_readers.push_back(
-        new UploadBytesElementReader(content->c_str(), content->size()));
+    element_readers.push_back(make_scoped_ptr(
+        new UploadBytesElementReader(content->c_str(), content->size())));
   }
-  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL(GetDefaultUrl());
   request.upload_data_stream = &upload_data_stream;
 
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.SetDeterministic();
@@ skipping 82 matching lines @@
       CreateMockRead(*window_update, i + 3),
       // Now the last write will occur.
       CreateMockRead(*reply, i + 5),
       CreateMockRead(*body2, i + 6),
       CreateMockRead(*body3, i + 7),
       MockRead(ASYNC, 0, i + 8)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes.get(), num_writes);
 
-  ScopedVector<UploadElementReader> element_readers;
+  std::vector<scoped_ptr<UploadElementReader>> element_readers;
   std::string upload_data_string(initial_window_size, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
-  element_readers.push_back(new UploadBytesElementReader(
-      upload_data_string.c_str(), upload_data_string.size()));
-  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  element_readers.push_back(make_scoped_ptr(new UploadBytesElementReader(
+      upload_data_string.c_str(), upload_data_string.size())));
+  ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL(GetDefaultUrl());
   request.upload_data_stream = &upload_data_stream;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.AddData(&data);
   helper.RunPreTestSetup();
 
@@ skipping 89 matching lines @@
   reads.push_back(CreateMockRead(*reply, i++));
   reads.push_back(CreateMockRead(*body2, i++));
   reads.push_back(CreateMockRead(*body3, i++));
   reads.push_back(MockRead(ASYNC, 0, i++));  // EOF
 
   // Force all writes to happen before any read, last write will not
   // actually queue a frame, due to window size being 0.
   DeterministicSocketData data(vector_as_array(&reads), reads.size(),
                                vector_as_array(&writes), writes.size());
 
-  ScopedVector<UploadElementReader> element_readers;
+  std::vector<scoped_ptr<UploadElementReader>> element_readers;
   std::string upload_data_string(initial_window_size, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
-  element_readers.push_back(new UploadBytesElementReader(
-      upload_data_string.c_str(), upload_data_string.size()));
-  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  element_readers.push_back(make_scoped_ptr(new UploadBytesElementReader(
+      upload_data_string.c_str(), upload_data_string.size())));
+  ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL(GetDefaultUrl());
   request.upload_data_stream = &upload_data_stream;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.SetDeterministic();
   helper.RunPreTestSetup();
   helper.AddDeterministicData(&data);
@@ skipping 95 matching lines @@
   reads.push_back(CreateMockRead(*reply, i++));
   reads.push_back(CreateMockRead(*body2, i++));
   reads.push_back(CreateMockRead(*body3, i++));
   reads.push_back(MockRead(ASYNC, 0, i++));  // EOF
 
   // Force all writes to happen before any read, last write will not
   // actually queue a frame, due to window size being 0.
   DeterministicSocketData data(vector_as_array(&reads), reads.size(),
                                vector_as_array(&writes), writes.size());
 
-  ScopedVector<UploadElementReader> element_readers;
+  std::vector<scoped_ptr<UploadElementReader>> element_readers;
   std::string upload_data_string(initial_window_size, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
-  element_readers.push_back(new UploadBytesElementReader(
-      upload_data_string.c_str(), upload_data_string.size()));
-  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  element_readers.push_back(make_scoped_ptr(new UploadBytesElementReader(
+      upload_data_string.c_str(), upload_data_string.size())));
+  ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL(GetDefaultUrl());
   request.upload_data_stream = &upload_data_stream;
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.SetDeterministic();
   helper.RunPreTestSetup();
   helper.AddDeterministicData(&data);
@@ skipping 231 matching lines @@
 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   scoped_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(ssl_provider.Pass());
 }
 
 }  // namespace net