Re-write many calls to WrapUnique() with MakeUnique()

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 <cmath>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 274 matching lines @@
       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_) {
       std::vector<std::unique_ptr<UploadElementReader>> element_readers;
-      element_readers.push_back(base::WrapUnique(
-          new UploadBytesElementReader(kUploadData, kUploadDataSize)));
+      element_readers.push_back(base::MakeUnique<UploadBytesElementReader>(
+          kUploadData, kUploadDataSize));
       upload_data_stream_.reset(
           new ElementsUploadDataStream(std::move(element_readers), 0));
 
       post_request_.method = "POST";
       post_request_.url = default_url_;
       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));
 
       std::vector<std::unique_ptr<UploadElementReader>> element_readers;
-      element_readers.push_back(base::WrapUnique(new UploadFileElementReader(
+      element_readers.push_back(base::MakeUnique<UploadFileElementReader>(
           base::ThreadTaskRunnerHandle::Get().get(), file_path, 0,
-          kUploadDataSize, base::Time())));
+          kUploadDataSize, base::Time()));
       upload_data_stream_.reset(
           new ElementsUploadDataStream(std::move(element_readers), 0));
 
       post_request_.method = "POST";
       post_request_.url = default_url_;
       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));
 
     std::vector<std::unique_ptr<UploadElementReader>> element_readers;
-    element_readers.push_back(base::WrapUnique(new UploadFileElementReader(
+    element_readers.push_back(base::MakeUnique<UploadFileElementReader>(
         base::ThreadTaskRunnerHandle::Get().get(), file_path, 0,
-        kUploadDataSize, base::Time())));
+        kUploadDataSize, base::Time()));
     upload_data_stream_.reset(
         new ElementsUploadDataStream(std::move(element_readers), 0));
 
     post_request_.method = "POST";
     post_request_.url = default_url_;
     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));
 
       std::vector<std::unique_ptr<UploadElementReader>> element_readers;
-      element_readers.push_back(base::WrapUnique(
-          new UploadBytesElementReader(kUploadData, kFileRangeOffset)));
-      element_readers.push_back(base::WrapUnique(new UploadFileElementReader(
+      element_readers.push_back(base::MakeUnique<UploadBytesElementReader>(
+          kUploadData, kFileRangeOffset));
+      element_readers.push_back(base::MakeUnique<UploadFileElementReader>(
           base::ThreadTaskRunnerHandle::Get().get(), file_path,
-          kFileRangeOffset, kFileRangeLength, base::Time())));
-      element_readers.push_back(base::WrapUnique(new UploadBytesElementReader(
+          kFileRangeOffset, kFileRangeLength, base::Time()));
+      element_readers.push_back(base::MakeUnique<UploadBytesElementReader>(
           kUploadData + kFileRangeOffset + kFileRangeLength,
-          kUploadDataSize - (kFileRangeOffset + kFileRangeLength))));
+          kUploadDataSize - (kFileRangeOffset + kFileRangeLength)));
       upload_data_stream_.reset(
           new ElementsUploadDataStream(std::move(element_readers), 0));
 
       post_request_.method = "POST";
       post_request_.url = default_url_;
       post_request_.upload_data_stream = upload_data_stream_.get();
       post_request_initialized_ = true;
     }
     return post_request_;
   }
@@ skipping 5966 matching lines @@
 TEST_F(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   std::unique_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(std::move(ssl_provider));
 }
 
 }  // namespace net