Replace base::MakeUnique with std::make_unique in net/.

base/memory/ptr_util.h includes will be cleaned up later.

Bug: 755727
Change-Id: Ibaf46f05c9b02b76f9a91e819984b087a8c0d434
Reviewed-on: https://chromium-review.googlesource.com/627300
Commit-Queue: Jeremy Roman <jbroman@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Bence Béky <bnc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#498123}

net/base/chunked_upload_data_stream.cc

@@ -49,7 +49,7 @@ void ChunkedUploadDataStream::AppendData(
   if (data_len > 0) {
     DCHECK(data);
     upload_data_.push_back(
-        base::MakeUnique<std::vector<char>>(data, data + data_len));
+        std::make_unique<std::vector<char>>(data, data + data_len));
   }
   all_data_appended_ = is_done;
 

net/base/elements_upload_data_stream_unittest.cc

@@ -164,7 +164,7 @@ TEST_F(ElementsUploadDataStreamTest, EmptyUploadData) {
 
 TEST_F(ElementsUploadDataStreamTest, ConsumeAllBytes) {
   element_readers_.push_back(
-      base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize));
+      std::make_unique<UploadBytesElementReader>(kTestData, kTestDataSize));
   std::unique_ptr<UploadDataStream> stream(
       new ElementsUploadDataStream(std::move(element_readers_), 0));
   ASSERT_THAT(stream->Init(CompletionCallback(), NetLogWithSource()), IsOk());
@@ -189,7 +189,7 @@ TEST_F(ElementsUploadDataStreamTest, File) {
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
-  element_readers_.push_back(base::MakeUnique<UploadFileElementReader>(
+  element_readers_.push_back(std::make_unique<UploadFileElementReader>(
       base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0,
       std::numeric_limits<uint64_t>::max(), base::Time()));
 
@@ -226,7 +226,7 @@ TEST_F(ElementsUploadDataStreamTest, FileSmallerThanLength) {
   UploadFileElementReader::ScopedOverridingContentLengthForTests
       overriding_content_length(kFakeSize);
 
-  element_readers_.push_back(base::MakeUnique<UploadFileElementReader>(
+  element_readers_.push_back(std::make_unique<UploadFileElementReader>(
       base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0,
       std::numeric_limits<uint64_t>::max(), base::Time()));
 
@@ -269,7 +269,7 @@ TEST_F(ElementsUploadDataStreamTest, ReadErrorSync) {
 
   // This element is ignored because of the error from the previous reader.
   element_readers_.push_back(
-      base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize));
+      std::make_unique<UploadBytesElementReader>(kTestData, kTestDataSize));
 
   std::unique_ptr<UploadDataStream> stream(
       new ElementsUploadDataStream(std::move(element_readers_), 0));
@@ -304,7 +304,7 @@ TEST_F(ElementsUploadDataStreamTest, ReadErrorAsync) {
 
   // This element is ignored because of the error from the previous reader.
   element_readers_.push_back(
-      base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize));
+      std::make_unique<UploadBytesElementReader>(kTestData, kTestDataSize));
 
   std::unique_ptr<UploadDataStream> stream(
       new ElementsUploadDataStream(std::move(element_readers_), 0));
@@ -343,12 +343,12 @@ TEST_F(ElementsUploadDataStreamTest, FileAndBytes) {
 
   const uint64_t kFileRangeOffset = 1;
   const uint64_t kFileRangeLength = 4;
-  element_readers_.push_back(base::MakeUnique<UploadFileElementReader>(
+  element_readers_.push_back(std::make_unique<UploadFileElementReader>(
       base::ThreadTaskRunnerHandle::Get().get(), temp_file_path,
       kFileRangeOffset, kFileRangeLength, base::Time()));
 
   element_readers_.push_back(
-      base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize));
+      std::make_unique<UploadBytesElementReader>(kTestData, kTestDataSize));
 
   const uint64_t kStreamSize = kTestDataSize + kFileRangeLength;
   TestCompletionCallback init_callback;
@@ -539,7 +539,7 @@ void ElementsUploadDataStreamTest::FileChangedHelper(
   // Don't use element_readers_ here, as this function is called twice, and
   // reusing element_readers_ is wrong.
   std::vector<std::unique_ptr<UploadElementReader>> element_readers;
-  element_readers.push_back(base::MakeUnique<UploadFileElementReader>(
+  element_readers.push_back(std::make_unique<UploadFileElementReader>(
       base::ThreadTaskRunnerHandle::Get().get(), file_path, 1, 2, time));
 
   TestCompletionCallback init_callback;
@@ -582,8 +582,8 @@ TEST_F(ElementsUploadDataStreamTest, MultipleInit) {
 
   // Prepare data.
   element_readers_.push_back(
-      base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize));
-  element_readers_.push_back(base::MakeUnique<UploadFileElementReader>(
+      std::make_unique<UploadBytesElementReader>(kTestData, kTestDataSize));
+  element_readers_.push_back(std::make_unique<UploadFileElementReader>(
       base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0,
       std::numeric_limits<uint64_t>::max(), base::Time()));
   std::unique_ptr<UploadDataStream> stream(
@@ -627,8 +627,8 @@ TEST_F(ElementsUploadDataStreamTest, MultipleInitAsync) {
 
   // Prepare data.
   element_readers_.push_back(
-      base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize));
-  element_readers_.push_back(base::MakeUnique<UploadFileElementReader>(
+      std::make_unique<UploadBytesElementReader>(kTestData, kTestDataSize));
+  element_readers_.push_back(std::make_unique<UploadFileElementReader>(
       base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0,
       std::numeric_limits<uint64_t>::max(), base::Time()));
   std::unique_ptr<UploadDataStream> stream(
@@ -669,8 +669,8 @@ TEST_F(ElementsUploadDataStreamTest, InitToReset) {
 
   // Prepare data.
   element_readers_.push_back(
-      base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize));
-  element_readers_.push_back(base::MakeUnique<UploadFileElementReader>(
+      std::make_unique<UploadBytesElementReader>(kTestData, kTestDataSize));
+  element_readers_.push_back(std::make_unique<UploadFileElementReader>(
       base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0,
       std::numeric_limits<uint64_t>::max(), base::Time()));
   std::unique_ptr<UploadDataStream> stream(
@@ -727,8 +727,8 @@ TEST_F(ElementsUploadDataStreamTest, InitDuringAsyncInit) {
 
   // Prepare data.
   element_readers_.push_back(
-      base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize));
-  element_readers_.push_back(base::MakeUnique<UploadFileElementReader>(
+      std::make_unique<UploadBytesElementReader>(kTestData, kTestDataSize));
+  element_readers_.push_back(std::make_unique<UploadFileElementReader>(
       base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0,
       std::numeric_limits<uint64_t>::max(), base::Time()));
   std::unique_ptr<UploadDataStream> stream(
@@ -775,8 +775,8 @@ TEST_F(ElementsUploadDataStreamTest, InitDuringAsyncRead) {
 
   // Prepare data.
   element_readers_.push_back(
-      base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize));
-  element_readers_.push_back(base::MakeUnique<UploadFileElementReader>(
+      std::make_unique<UploadBytesElementReader>(kTestData, kTestDataSize));
+  element_readers_.push_back(std::make_unique<UploadFileElementReader>(
       base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0,
       std::numeric_limits<uint64_t>::max(), base::Time()));
   std::unique_ptr<UploadDataStream> stream(

net/base/file_stream.cc

@@ -13,11 +13,11 @@
 namespace net {
 
 FileStream::FileStream(const scoped_refptr<base::TaskRunner>& task_runner)
-    : context_(base::MakeUnique<Context>(task_runner)) {}
+    : context_(std::make_unique<Context>(task_runner)) {}
 
 FileStream::FileStream(base::File file,
                        const scoped_refptr<base::TaskRunner>& task_runner)
-    : context_(base::MakeUnique<Context>(std::move(file), task_runner)) {}
+    : context_(std::make_unique<Context>(std::move(file), task_runner)) {}
 
 FileStream::~FileStream() {
   context_.release()->Orphan();

net/base/network_activity_monitor_unittest.cc

@@ -96,7 +96,7 @@ void IncrementBytesSent(uint64_t bytes) {
 TEST_F(NetworkActivityMontiorTest, Threading) {
   std::vector<std::unique_ptr<base::Thread>> threads;
   for (size_t i = 0; i < 3; ++i) {
-    threads.push_back(base::MakeUnique<base::Thread>(base::SizeTToString(i)));
+    threads.push_back(std::make_unique<base::Thread>(base::SizeTToString(i)));
     ASSERT_TRUE(threads.back()->Start());
   }
 

net/base/network_change_notifier_mac.cc

@@ -49,10 +49,10 @@ NetworkChangeNotifierMac::NetworkChangeNotifierMac()
       connection_type_initialized_(false),
       initial_connection_type_cv_(&connection_type_lock_),
       forwarder_(this),
-      dns_config_service_thread_(base::MakeUnique<DnsConfigServiceThread>()) {
+      dns_config_service_thread_(std::make_unique<DnsConfigServiceThread>()) {
   // Must be initialized after the rest of this object, as it may call back into
   // SetInitialConnectionType().
-  config_watcher_ = base::MakeUnique<NetworkConfigWatcherMac>(&forwarder_);
+  config_watcher_ = std::make_unique<NetworkConfigWatcherMac>(&forwarder_);
   dns_config_service_thread_->StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
 }

net/base/network_interfaces_getifaddrs.cc

@@ -225,7 +225,7 @@ bool GetNetworkList(NetworkInterfaceList* networks, int policy) {
   std::unique_ptr<internal::IPAttributesGetter> ip_attributes_getter;
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
-  ip_attributes_getter = base::MakeUnique<internal::IPAttributesGetterMac>();
+  ip_attributes_getter = std::make_unique<internal::IPAttributesGetterMac>();
 #endif
 
   bool result = internal::IfaddrsToNetworkInterfaceList(

net/base/network_throttle_manager_impl.cc

@@ -154,7 +154,7 @@ NetworkThrottleManagerImpl::NetworkThrottleManagerImpl()
     : lifetime_median_estimate_(PercentileEstimator::kMedianPercentile,
                                 kInitialMedianInMs),
       outstanding_recomputation_timer_(
-          base::MakeUnique<base::Timer>(false /* retain_user_task */,
+          std::make_unique<base::Timer>(false /* retain_user_task */,
                                         false /* is_repeating */)),
       tick_clock_(new base::DefaultTickClock()),
       weak_ptr_factory_(this) {}
@@ -191,7 +191,7 @@ void NetworkThrottleManagerImpl::SetTickClockForTesting(
     std::unique_ptr<base::TickClock> tick_clock) {
   tick_clock_ = std::move(tick_clock);
   DCHECK(!outstanding_recomputation_timer_->IsRunning());
-  outstanding_recomputation_timer_ = base::MakeUnique<base::Timer>(
+  outstanding_recomputation_timer_ = std::make_unique<base::Timer>(
       false /* retain_user_task */, false /* is_repeating */,
       tick_clock_.get());
 }

net/cert/caching_cert_verifier_unittest.cc

@@ -51,7 +51,7 @@ class MockCacheVisitor : public CachingCertVerifier::CacheVisitor {
 
 class CachingCertVerifierTest : public ::testing::Test {
  public:
-  CachingCertVerifierTest() : verifier_(base::MakeUnique<MockCertVerifier>()) {}
+  CachingCertVerifierTest() : verifier_(std::make_unique<MockCertVerifier>()) {}
   ~CachingCertVerifierTest() override {}
 
  protected:

net/cert/cert_verifier.cc

@@ -81,8 +81,8 @@ std::unique_ptr<CertVerifier> CertVerifier::CreateDefault() {
   NOTIMPLEMENTED();
   return std::unique_ptr<CertVerifier>();
 #else
-  return base::MakeUnique<CachingCertVerifier>(
-      base::MakeUnique<MultiThreadedCertVerifier>(
+  return std::make_unique<CachingCertVerifier>(
+      std::make_unique<MultiThreadedCertVerifier>(
           CertVerifyProc::CreateDefault()));
 #endif
 }

net/cert/cert_verify_proc_android_unittest.cc

@@ -66,19 +66,19 @@ std::unique_ptr<CertNetFetcher::Request> CreateMockRequestFromX509Certificate(
     const scoped_refptr<X509Certificate>& cert) {
   std::string der;
   EXPECT_TRUE(X509Certificate::GetDEREncoded(cert->os_cert_handle(), &der));
-  return base::MakeUnique<TestCertNetFetcherRequest>(
+  return std::make_unique<TestCertNetFetcherRequest>(
       error, std::vector<uint8_t>(der.data(), der.data() + der.length()));
 }
 
 std::unique_ptr<CertNetFetcher::Request> CreateMockRequestWithError(
     Error error) {
-  return base::MakeUnique<TestCertNetFetcherRequest>(error,
+  return std::make_unique<TestCertNetFetcherRequest>(error,
                                                      std::vector<uint8_t>({}));
 }
 
 std::unique_ptr<CertNetFetcher::Request>
 CreateMockRequestWithInvalidCertificate() {
-  return base::MakeUnique<TestCertNetFetcherRequest>(
+  return std::make_unique<TestCertNetFetcherRequest>(
       OK, std::vector<uint8_t>({1, 2, 3}));
 }
 

net/cert/internal/cert_error_params.cc

@@ -103,7 +103,7 @@ std::unique_ptr<CertErrorParams> CreateCertErrorParams1Der(
     const char* name,
     const der::Input& der) {
   DCHECK(name);
-  return base::MakeUnique<CertErrorParams2Der>(name, der, nullptr,
+  return std::make_unique<CertErrorParams2Der>(name, der, nullptr,
                                                der::Input());
 }
 
@@ -114,13 +114,13 @@ std::unique_ptr<CertErrorParams> CreateCertErrorParams2Der(
     const der::Input& der2) {
   DCHECK(name1);
   DCHECK(name2);
-  return base::MakeUnique<CertErrorParams2Der>(name1, der1, name2, der2);
+  return std::make_unique<CertErrorParams2Der>(name1, der1, name2, der2);
 }
 
 std::unique_ptr<CertErrorParams> CreateCertErrorParams1SizeT(const char* name,
                                                              size_t value) {
   DCHECK(name);
-  return base::MakeUnique<CertErrorParams1SizeT>(name, value);
+  return std::make_unique<CertErrorParams1SizeT>(name, value);
 }
 
 NET_EXPORT std::unique_ptr<CertErrorParams> CreateCertErrorParams2SizeT(
@@ -130,7 +130,7 @@ NET_EXPORT std::unique_ptr<CertErrorParams> CreateCertErrorParams2SizeT(
     size_t value2) {
   DCHECK(name1);
   DCHECK(name2);
-  return base::MakeUnique<CertErrorParams2SizeT>(name1, value1, name2, value2);
+  return std::make_unique<CertErrorParams2SizeT>(name1, value1, name2, value2);
 }
 
 }  // namespace net

net/cert/internal/cert_issuer_source_aia_unittest.cc

@@ -105,15 +105,15 @@ class MockCertNetFetcherRequest : public CertNetFetcher::Request {
 
 // Creates a CertNetFetcher::Request that completes with an error.
 std::unique_ptr<CertNetFetcher::Request> CreateMockRequest(Error error) {
-  return base::MakeUnique<MockCertNetFetcherRequest>(error,
+  return std::make_unique<MockCertNetFetcherRequest>(error,
                                                      std::vector<uint8_t>());
 }
 
 // Creates a CertNetFetcher::Request that completes with the specified error
 // code and bytes.
 std::unique_ptr<CertNetFetcher::Request> CreateMockRequest(
     const std::vector<uint8_t>& bytes) {
-  return base::MakeUnique<MockCertNetFetcherRequest>(OK, bytes);
+  return std::make_unique<MockCertNetFetcherRequest>(OK, bytes);
 }
 
 // CertIssuerSourceAia does not return results for SyncGetIssuersOf.

net/cert/internal/path_builder.cc

@@ -487,7 +487,7 @@ void CertPathIter::DoGetNextIssuerComplete() {
         break;
       }
 
-      cur_path_.Append(base::MakeUnique<CertIssuersIter>(
+      cur_path_.Append(std::make_unique<CertIssuersIter>(
           std::move(next_issuer_.cert), &cert_issuer_sources_, trust_store_));
       next_issuer_ = IssuerEntry();
       DVLOG(1) << "CertPathIter cur_path_ = " << cur_path_.PathDebugString();
@@ -613,7 +613,7 @@ void CertPathBuilder::DoGetNextPathComplete() {
   }
 
   // Verify the entire certificate chain.
-  auto result_path = base::MakeUnique<ResultPath>();
+  auto result_path = std::make_unique<ResultPath>();
   result_path->path = next_path_;
   VerifyCertificateChain(
       result_path->path.certs, result_path->path.last_cert_trust, delegate_,

net/cert/internal/signature_algorithm.cc

@@ -682,7 +682,7 @@ std::unique_ptr<SignatureAlgorithm> SignatureAlgorithm::CreateRsaPss(
     uint32_t salt_length) {
   return base::WrapUnique(new SignatureAlgorithm(
       SignatureAlgorithmId::RsaPss, digest,
-      base::MakeUnique<RsaPssParameters>(mgf1_hash, salt_length)));
+      std::make_unique<RsaPssParameters>(mgf1_hash, salt_length)));
 }
 
 const RsaPssParameters* SignatureAlgorithm::ParamsForRsaPss() const {

net/cert/internal/system_trust_store.cc

@@ -97,7 +97,7 @@ class SystemTrustStoreNSS : public BaseSystemTrustStore {
 }  // namespace
 
 std::unique_ptr<SystemTrustStore> CreateSslSystemTrustStore() {
-  return base::MakeUnique<SystemTrustStoreNSS>();
+  return std::make_unique<SystemTrustStoreNSS>();
 }
 
 #elif defined(OS_MACOSX) && !defined(OS_IOS)
@@ -130,7 +130,7 @@ class SystemTrustStoreMac : public BaseSystemTrustStore {
 };
 
 std::unique_ptr<SystemTrustStore> CreateSslSystemTrustStore() {
-  return base::MakeUnique<SystemTrustStoreMac>();
+  return std::make_unique<SystemTrustStoreMac>();
 }
 #else
 
@@ -144,7 +144,7 @@ class DummySystemTrustStore : public BaseSystemTrustStore {
 };
 
 std::unique_ptr<SystemTrustStore> CreateSslSystemTrustStore() {
-  return base::MakeUnique<DummySystemTrustStore>();
+  return std::make_unique<DummySystemTrustStore>();
 }
 #endif
 

net/cert/multi_threaded_cert_verifier.cc

@@ -357,7 +357,7 @@ int MultiThreadedCertVerifier::Verify(const RequestParams& params,
   } else {
     // Need to make a new job.
     std::unique_ptr<CertVerifierJob> new_job =
-        base::MakeUnique<CertVerifierJob>(params, net_log.net_log(), this);
+        std::make_unique<CertVerifierJob>(params, net_log.net_log(), this);
 
     if (!new_job->Start(verify_proc_, crl_set)) {
       // TODO(wtc): log to the NetLog.

net/cert/test_root_certs_nss.cc

@@ -56,7 +56,7 @@ bool TestRootCerts::Add(X509Certificate* certificate) {
   }
 
   trust_cache_.push_back(
-      base::MakeUnique<TrustEntry>(std::move(cert_handle), original_trust));
+      std::make_unique<TrustEntry>(std::move(cert_handle), original_trust));
   return true;
 }
 

net/cert_net/cert_net_fetcher_impl.cc

@@ -803,7 +803,7 @@ class CertNetFetcherImpl : public CertNetFetcher {
       request_core->SignalImmediateError();
     }
 
-    return base::MakeUnique<CertNetFetcherRequestImpl>(std::move(request_core));
+    return std::make_unique<CertNetFetcherRequestImpl>(std::move(request_core));
   }
 
  private:

net/cert_net/cert_net_fetcher_impl_unittest.cc

@@ -66,12 +66,12 @@ class RequestContext : public URLRequestContext {
     session_context.proxy_service = proxy_service();
     session_context.ssl_config_service = ssl_config_service();
     session_context.http_server_properties = http_server_properties();
-    storage_.set_http_network_session(base::MakeUnique<HttpNetworkSession>(
+    storage_.set_http_network_session(std::make_unique<HttpNetworkSession>(
         HttpNetworkSession::Params(), session_context));
-    storage_.set_http_transaction_factory(base::MakeUnique<HttpCache>(
+    storage_.set_http_transaction_factory(std::make_unique<HttpCache>(
         storage_.http_network_session(), HttpCache::DefaultBackend::InMemory(0),
         false /* is_main_cache */));
-    storage_.set_job_factory(base::MakeUnique<URLRequestJobFactoryImpl>());
+    storage_.set_job_factory(std::make_unique<URLRequestJobFactoryImpl>());
   }
 
   ~RequestContext() override { AssertNoURLRequests(); }

net/cookies/canonical_cookie.cc

@@ -242,7 +242,7 @@ std::unique_ptr<CanonicalCookie> CanonicalCookie::Create(
     return nullptr;
   }
 
-  std::unique_ptr<CanonicalCookie> cc(base::MakeUnique<CanonicalCookie>(
+  std::unique_ptr<CanonicalCookie> cc(std::make_unique<CanonicalCookie>(
       parsed_cookie.Name(), parsed_cookie.Value(), cookie_domain, cookie_path,
       creation_time, cookie_expires, creation_time, parsed_cookie.IsSecure(),
       parsed_cookie.IsHttpOnly(), parsed_cookie.SameSite(),