[Cronet] Replace base::MakeUnique with std::make_unique.

Per https://bugs.chromium.org/p/chromium/issues/detail?id=755727, as of C++14,
std::make_unique provides the same functionality as Base::MakeUnique, and is
preferred.

Bug: 755727
Cq-Include-Trybots: master.tryserver.chromium.android:android_cronet_tester;master.tryserver.chromium.mac:ios-simulator-cronet
Change-Id: Iaac534f4598872f56ddad67afcfaac4318883edf
Reviewed-on: https://chromium-review.googlesource.com/806595
Commit-Queue: Misha Efimov <mef@chromium.org>
Reviewed-by: Bence Béky <bnc@chromium.org>
Reviewed-by: Misha Efimov <mef@chromium.org>
Cr-Commit-Position: refs/heads/master@{#522186}

components/cronet/android/cronet_upload_data_stream_adapter.cc

@@ -4,6 +4,7 @@
 
 #include "components/cronet/android/cronet_upload_data_stream_adapter.h"
 
+#include <memory>
 #include <string>
 #include <utility>
 
@@ -11,7 +12,6 @@
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/cronet/android/cronet_url_request_adapter.h"
@@ -52,7 +52,7 @@ void CronetUploadDataStreamAdapter::Read(net::IOBuffer* buffer, int buf_len) {
   // ones used last time.
   if (!(buffer_ && buffer_->io_buffer()->data() == buffer->data() &&
         buffer_->io_buffer_len() == buf_len)) {
-    buffer_ = base::MakeUnique<ByteBufferWithIOBuffer>(env, buffer, buf_len);
+    buffer_ = std::make_unique<ByteBufferWithIOBuffer>(env, buffer, buf_len);
   }
   Java_CronetUploadDataStream_readData(env, jupload_data_stream_,
                                        buffer_->byte_buffer());

components/cronet/android/cronet_url_request_context_adapter.cc

@@ -26,7 +26,6 @@
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/statistics_recorder.h"
@@ -361,14 +360,14 @@ void CronetURLRequestContextAdapter::InitializeOnNetworkThread(
   if (config->enable_network_quality_estimator) {
     DCHECK(!network_quality_estimator_);
     std::unique_ptr<net::NetworkQualityEstimatorParams> nqe_params =
-        base::MakeUnique<net::NetworkQualityEstimatorParams>(
+        std::make_unique<net::NetworkQualityEstimatorParams>(
             std::map<std::string, std::string>());
     if (config->nqe_forced_effective_connection_type) {
       nqe_params->SetForcedEffectiveConnectionType(
           config->nqe_forced_effective_connection_type.value());
     }
 
-    network_quality_estimator_ = base::MakeUnique<net::NetworkQualityEstimator>(
+    network_quality_estimator_ = std::make_unique<net::NetworkQualityEstimator>(
         std::unique_ptr<net::ExternalEstimateProvider>(), std::move(nqe_params),
         g_net_log.Get().net_log());
     network_quality_estimator_->AddEffectiveConnectionTypeObserver(this);
@@ -819,7 +818,7 @@ static void JNI_CronetUrlRequestContext_AddQuicHint(
   URLRequestContextConfig* config =
       reinterpret_cast<URLRequestContextConfig*>(jurl_request_context_config);
   config->quic_hints.push_back(
-      base::MakeUnique<URLRequestContextConfig::QuicHint>(
+      std::make_unique<URLRequestContextConfig::QuicHint>(
           base::android::ConvertJavaStringToUTF8(env, jhost), jport,
           jalternate_port));
 }

components/cronet/cronet_prefs_manager.cc

@@ -4,6 +4,8 @@
 
 #include "components/cronet/cronet_prefs_manager.h"
 
+#include <memory>
+
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
@@ -227,7 +229,7 @@ CronetPrefsManager::CronetPrefsManager(
   factory.set_user_prefs(json_pref_store_);
   scoped_refptr<PrefRegistrySimple> registry(new PrefRegistrySimple());
   registry->RegisterDictionaryPref(kHttpServerPropertiesPref,
-                                   base::MakeUnique<base::DictionaryValue>());
+                                   std::make_unique<base::DictionaryValue>());
 
   if (enable_network_quality_estimator) {
     // Use lossy prefs to limit the overhead of reading/writing the prefs.
@@ -263,8 +265,8 @@ void CronetPrefsManager::SetupNqePersistence(
     net::NetworkQualityEstimator* nqe) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   network_qualities_prefs_manager_ =
-      base::MakeUnique<net::NetworkQualitiesPrefsManager>(
-          base::MakeUnique<NetworkQualitiesPrefDelegateImpl>(
+      std::make_unique<net::NetworkQualitiesPrefsManager>(
+          std::make_unique<NetworkQualitiesPrefDelegateImpl>(
               pref_service_.get()));
 
   network_qualities_prefs_manager_->InitializeOnNetworkThread(nqe);
@@ -276,7 +278,7 @@ void CronetPrefsManager::SetupHostCachePersistence(
     net::NetLog* net_log) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   host_cache_persistence_manager_ =
-      base::MakeUnique<HostCachePersistenceManager>(
+      std::make_unique<HostCachePersistenceManager>(
           host_cache, pref_service_.get(), kHostCachePref,
           base::TimeDelta::FromMilliseconds(host_cache_persistence_delay_ms),
           net_log);

components/cronet/host_cache_persistence_manager_unittest.cc

@@ -19,12 +19,12 @@ class HostCachePersistenceManagerTest : public testing::Test {
  protected:
   void SetUp() override {
     cache_ = net::HostCache::CreateDefaultCache();
-    pref_service_ = base::MakeUnique<TestingPrefServiceSimple>();
+    pref_service_ = std::make_unique<TestingPrefServiceSimple>();
     pref_service_->registry()->RegisterListPref(kPrefName);
   }
 
   void MakePersistenceManager(base::TimeDelta delay) {
-    persistence_manager_ = base::MakeUnique<HostCachePersistenceManager>(
+    persistence_manager_ = std::make_unique<HostCachePersistenceManager>(
         cache_.get(), pref_service_.get(), kPrefName, delay, nullptr);
   }
 

components/cronet/ios/Cronet.mm

@@ -11,7 +11,6 @@
 #include "base/logging.h"
 #include "base/mac/bundle_locations.h"
 #include "base/mac/scoped_block.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "components/cronet/ios/accept_languages_table.h"
@@ -132,7 +131,7 @@ class CronetHttpProtocolHandlerDelegate
     (cronet::CronetEnvironment*)cronetEnvironment {
   if (gEnableTestCertVerifierForTesting) {
     std::unique_ptr<TestCertVerifier> test_cert_verifier =
-        base::MakeUnique<TestCertVerifier>();
+        std::make_unique<TestCertVerifier>();
     cronetEnvironment->set_mock_cert_verifier(std::move(test_cert_verifier));
   }
   if (gMockCertVerifier) {
@@ -204,7 +203,7 @@ class CronetHttpProtocolHandlerDelegate
   }
 
   gQuicHints.push_back(
-      base::MakeUnique<cronet::URLRequestContextConfig::QuicHint>(
+      std::make_unique<cronet::URLRequestContextConfig::QuicHint>(
           quic_host, port, altPort));
 
   return YES;
@@ -267,7 +266,7 @@ class CronetHttpProtocolHandlerDelegate
     return NO;
   }
 
-  auto pkp = base::MakeUnique<cronet::URLRequestContextConfig::Pkp>(
+  auto pkp = std::make_unique<cronet::URLRequestContextConfig::Pkp>(
       base::SysNSStringToUTF8(host), includeSubdomains,
       base::Time::FromCFAbsoluteTime(
           [expirationDate timeIntervalSinceReferenceDate]));

components/cronet/ios/cronet_environment.mm

@@ -16,7 +16,6 @@
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/foundation_util.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/path_service.h"
@@ -386,7 +385,7 @@ void CronetEnvironment::InitializeOnNetworkThread() {
   [[NSHTTPCookieStorage sharedHTTPCookieStorage]
       setCookieAcceptPolicy:NSHTTPCookieAcceptPolicyAlways];
   std::unique_ptr<net::CookieStore> cookie_store =
-      base::MakeUnique<net::CookieStoreIOS>(
+      std::make_unique<net::CookieStoreIOS>(
           [NSHTTPCookieStorage sharedHTTPCookieStorage]);
   context_builder.SetCookieAndChannelIdStores(std::move(cookie_store), nullptr);
 

components/cronet/ios/empty.cc

@@ -3,4 +3,4 @@
 // found in the LICENSE file.
 
 // An empty C++ file that is needed to trigger the usage of clang++ instead of
-// clang.
+// clang.
\ No newline at end of file

components/cronet/ios/test/test_server.cc

@@ -4,12 +4,12 @@
 
 #include "components/cronet/ios/test/test_server.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ -41,7 +41,7 @@ std::unique_ptr<net::test_server::HttpResponse> EchoHeaderInRequest(
   auto it = request.headers.find(header_name);
   if (it != request.headers.end())
     header_value = it->second;
-  auto http_response = base::MakeUnique<net::test_server::BasicHttpResponse>();
+  auto http_response = std::make_unique<net::test_server::BasicHttpResponse>();
   http_response->set_code(net::HTTP_OK);
   http_response->set_content(header_value);
   return std::move(http_response);
@@ -54,7 +54,7 @@ std::unique_ptr<net::test_server::HttpResponse> UseEncodingInResponse(
                           base::CompareCase::INSENSITIVE_ASCII));
 
   encoding = request.relative_url.substr(strlen(kUseEncodingPath));
-  auto http_response = base::MakeUnique<net::test_server::BasicHttpResponse>();
+  auto http_response = std::make_unique<net::test_server::BasicHttpResponse>();
   if (!encoding.compare("brotli")) {
     const char quickfoxCompressed[] = {
         0x0b, 0x15, -0x80, 0x54, 0x68, 0x65, 0x20, 0x71, 0x75, 0x69, 0x63, 0x6b,
@@ -76,7 +76,7 @@ std::unique_ptr<net::test_server::HttpResponse> EchoResponseBody(
   DCHECK(base::StartsWith(request.relative_url, kEchoRequestBodyPath,
                           base::CompareCase::INSENSITIVE_ASCII));
   std::string request_content = request.content;
-  auto http_response = base::MakeUnique<net::test_server::BasicHttpResponse>();
+  auto http_response = std::make_unique<net::test_server::BasicHttpResponse>();
   http_response->set_code(net::HTTP_OK);
   http_response->set_content(request_content);
   return http_response;
@@ -90,7 +90,7 @@ std::unique_ptr<net::test_server::HttpResponse> ReturnBigDataInResponse(
   int64_t data_size;
   CHECK(base::StringToInt64(base::StringPiece(data_size_str), &data_size));
   CHECK(data_size == static_cast<int64_t>(g_big_data_body.Get().size()));
-  return base::MakeUnique<net::test_server::RawHttpResponse>(
+  return std::make_unique<net::test_server::RawHttpResponse>(
       std::string(), g_big_data_body.Get());
 }
 
@@ -100,7 +100,7 @@ std::unique_ptr<net::test_server::HttpResponse> SetAndEchoCookieInResponse(
   DCHECK(base::StartsWith(request.relative_url, kSetCookiePath,
                           base::CompareCase::INSENSITIVE_ASCII));
   cookie_line = request.relative_url.substr(strlen(kSetCookiePath));
-  auto http_response = base::MakeUnique<net::test_server::BasicHttpResponse>();
+  auto http_response = std::make_unique<net::test_server::BasicHttpResponse>();
   http_response->set_code(net::HTTP_OK);
   http_response->set_content(cookie_line);
   http_response->AddCustomHeader("Set-Cookie", cookie_line);
@@ -129,7 +129,7 @@ std::unique_ptr<net::test_server::HttpResponse> CronetTestRequestHandler(
                        base::CompareCase::INSENSITIVE_ASCII)) {
     return EchoResponseBody(request);
   }
-  return base::MakeUnique<net::test_server::BasicHttpResponse>();
+  return std::make_unique<net::test_server::BasicHttpResponse>();
 }
 
 }  // namespace
@@ -139,7 +139,7 @@ namespace cronet {
 /* static */
 bool TestServer::Start() {
   DCHECK(!g_test_server.get());
-  g_test_server = base::MakeUnique<net::EmbeddedTestServer>(
+  g_test_server = std::make_unique<net::EmbeddedTestServer>(
       net::EmbeddedTestServer::TYPE_HTTP);
   g_test_server->RegisterRequestHandler(base::Bind(&CronetTestRequestHandler));
   CHECK(g_test_server->Start());

components/cronet/url_request_context_config.cc

@@ -8,7 +8,6 @@
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
@@ -502,7 +501,7 @@ void URLRequestContextConfig::ConfigureURLRequestContextBuilder(
   if (mock_cert_verifier) {
     // Because |context_builder| expects CachingCertVerifier, wrap
     // |mock_cert_verifier| into a CachingCertVerifier.
-    cert_verifier = base::MakeUnique<net::CachingCertVerifier>(
+    cert_verifier = std::make_unique<net::CachingCertVerifier>(
         std::move(mock_cert_verifier));
   } else {
     // net::CertVerifier::CreateDefault() returns a CachingCertVerifier.
@@ -512,9 +511,9 @@ void URLRequestContextConfig::ConfigureURLRequestContextBuilder(
   // Certificate Transparency is intentionally ignored in Cronet.
   // See //net/docs/certificate-transparency.md for more details.
   context_builder->set_ct_verifier(
-      base::MakeUnique<net::DoNothingCTVerifier>());
+      std::make_unique<net::DoNothingCTVerifier>());
   context_builder->set_ct_policy_enforcer(
-      base::MakeUnique<DoNothingCTPolicyEnforcer>());
+      std::make_unique<DoNothingCTPolicyEnforcer>());
   // TODO(mef): Use |config| to set cookies.
 }
 
@@ -523,7 +522,7 @@ URLRequestContextConfigBuilder::~URLRequestContextConfigBuilder() {}
 
 std::unique_ptr<URLRequestContextConfig>
 URLRequestContextConfigBuilder::Build() {
-  return base::MakeUnique<URLRequestContextConfig>(
+  return std::make_unique<URLRequestContextConfig>(
       enable_quic, quic_user_agent_id, enable_spdy, enable_brotli, http_cache,
       http_cache_max_size, load_disable_cache, storage_path, user_agent,
       experimental_options, std::move(mock_cert_verifier),

components/cronet/url_request_context_config_unittest.cc

@@ -4,7 +4,6 @@
 
 #include "components/cronet/url_request_context_config.h"
 
-#include "base/memory/ptr_util.h"
 #include "base/test/scoped_task_environment.h"
 #include "base/values.h"
 #include "net/cert/cert_verifier.h"
@@ -71,7 +70,7 @@ TEST(URLRequestContextConfigTest, TestExperimentalOptionParsing) {
   EXPECT_FALSE(config.effective_experimental_options->HasKey("UnknownOption"));
   // Set a ProxyConfigService to avoid DCHECK failure when building.
   builder.set_proxy_config_service(
-      base::MakeUnique<net::ProxyConfigServiceFixed>(
+      std::make_unique<net::ProxyConfigServiceFixed>(
           net::ProxyConfig::CreateDirect()));
   std::unique_ptr<net::URLRequestContext> context(builder.Build());
   const net::HttpNetworkSession::Params* params =
@@ -155,7 +154,7 @@ TEST(URLRequestContextConfigTest, SetQuicConnectionMigrationOptions) {
   config.ConfigureURLRequestContextBuilder(&builder, &net_log);
   // Set a ProxyConfigService to avoid DCHECK failure when building.
   builder.set_proxy_config_service(
-      base::MakeUnique<net::ProxyConfigServiceFixed>(
+      std::make_unique<net::ProxyConfigServiceFixed>(
           net::ProxyConfig::CreateDirect()));
   std::unique_ptr<net::URLRequestContext> context(builder.Build());
   const net::HttpNetworkSession::Params* params =
@@ -207,7 +206,7 @@ TEST(URLRequestContextConfigTest, SetQuicConnectionMigrationV2Options) {
   config.ConfigureURLRequestContextBuilder(&builder, &net_log);
   // Set a ProxyConfigService to avoid DCHECK failure when building.
   builder.set_proxy_config_service(
-      base::MakeUnique<net::ProxyConfigServiceFixed>(
+      std::make_unique<net::ProxyConfigServiceFixed>(
           net::ProxyConfig::CreateDirect()));
   std::unique_ptr<net::URLRequestContext> context(builder.Build());
   const net::HttpNetworkSession::Params* params =
@@ -257,7 +256,7 @@ TEST(URLRequestContextConfigTest, SetQuicHostWhitelist) {
   config.ConfigureURLRequestContextBuilder(&builder, &net_log);
   // Set a ProxyConfigService to avoid DCHECK failure when building.
   builder.set_proxy_config_service(
-      base::MakeUnique<net::ProxyConfigServiceFixed>(
+      std::make_unique<net::ProxyConfigServiceFixed>(
           net::ProxyConfig::CreateDirect()));
   std::unique_ptr<net::URLRequestContext> context(builder.Build());
   const net::HttpNetworkSession::Params* params =
@@ -310,7 +309,7 @@ TEST(URLRequestContextConfigTest, SetQuicMaxTimeBeforeCryptoHandshake) {
   config.ConfigureURLRequestContextBuilder(&builder, &net_log);
   // Set a ProxyConfigService to avoid DCHECK failure when building.
   builder.set_proxy_config_service(
-      base::MakeUnique<net::ProxyConfigServiceFixed>(
+      std::make_unique<net::ProxyConfigServiceFixed>(
           net::ProxyConfig::CreateDirect()));
   std::unique_ptr<net::URLRequestContext> context(builder.Build());
   const net::HttpNetworkSession::Params* params =