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

net/proxy/proxy_service_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/proxy/proxy_service.h"
 
 #include <cstdarg>
 #include <string>
 #include <vector>
 
@@ skipping 346 matching lines @@
     urls.push_back(url3);
   return GetRequestsForURLs(resolver.cancelled_requests(), urls);
 }
 
 }  // namespace
 
 TEST_F(ProxyServiceTest, Direct) {
   MockAsyncProxyResolverFactory* factory =
       new MockAsyncProxyResolverFactory(false);
   ProxyService service(
-      base::WrapUnique(new MockProxyConfigService(ProxyConfig::CreateDirect())),
+      base::MakeUnique<MockProxyConfigService>(ProxyConfig::CreateDirect()),
       base::WrapUnique(factory), nullptr);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
   TestCompletionCallback callback;
   BoundTestNetLog log;
   int rv = service.ResolveProxy(url, std::string(), &info, callback.callback(),
                                 nullptr, nullptr, log.bound());
   EXPECT_THAT(rv, IsOk());
@@ skipping 15 matching lines @@
       NetLogEventPhase::NONE));
   EXPECT_TRUE(LogContainsEndEvent(entries, 2, NetLogEventType::PROXY_SERVICE));
 }
 
 TEST_F(ProxyServiceTest, OnResolveProxyCallbackAddProxy) {
   ProxyConfig config;
   config.proxy_rules().ParseFromString("foopy1:8080");
   config.set_auto_detect(false);
   config.proxy_rules().bypass_rules.ParseFromString("*.org");
 
-  ProxyService service(base::WrapUnique(new MockProxyConfigService(config)),
+  ProxyService service(base::MakeUnique<MockProxyConfigService>(config),
                        nullptr, nullptr);
 
   GURL url("http://www.google.com/");
   GURL bypass_url("http://internet.org");
 
   ProxyInfo info;
   TestCompletionCallback callback;
   BoundTestNetLog log;
 
   // First, warm up the ProxyService.
@@ skipping 35 matching lines @@
 
 TEST_F(ProxyServiceTest, OnResolveProxyCallbackRemoveProxy) {
   // Same as OnResolveProxyCallbackAddProxy, but verify that the
   // ProxyDelegate's behavior is stateless across invocations after it
   // *removes* a proxy.
   ProxyConfig config;
   config.proxy_rules().ParseFromString("foopy1:8080");
   config.set_auto_detect(false);
   config.proxy_rules().bypass_rules.ParseFromString("*.org");
 
-  ProxyService service(base::WrapUnique(new MockProxyConfigService(config)),
+  ProxyService service(base::MakeUnique<MockProxyConfigService>(config),
                        nullptr, nullptr);
 
   GURL url("http://www.google.com/");
   GURL bypass_url("http://internet.org");
 
   ProxyInfo info;
   TestCompletionCallback callback;
   BoundTestNetLog log;
 
   // First, warm up the ProxyService.
@@ skipping 594 matching lines @@
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
 
   MockAsyncProxyResolverFactory* factory =
       new MockAsyncProxyResolverFactory(true);
 
   ProxyService service(base::WrapUnique(config_service),
                        base::WrapUnique(factory), nullptr);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(
-      fetcher, base::WrapUnique(new DoNothingDhcpProxyScriptFetcher()));
+      fetcher, base::MakeUnique<DoNothingDhcpProxyScriptFetcher>());
 
   // Start resolve request.
   GURL url("http://www.google.com/");
   ProxyInfo info;
   TestCompletionCallback callback;
   int rv = service.ResolveProxy(url, std::string(), &info, callback.callback(),
                                 nullptr, nullptr, BoundNetLog());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Check that nothing has been sent to the proxy resolver factory yet.
@@ skipping 598 matching lines @@
 TEST_F(ProxyServiceTest, ProxyBypassList) {
   // Test that the proxy bypass rules are consulted.
 
   TestCompletionCallback callback[2];
   ProxyInfo info[2];
   ProxyConfig config;
   config.proxy_rules().ParseFromString("foopy1:8080;foopy2:9090");
   config.set_auto_detect(false);
   config.proxy_rules().bypass_rules.ParseFromString("*.org");
 
-  ProxyService service(base::WrapUnique(new MockProxyConfigService(config)),
+  ProxyService service(base::MakeUnique<MockProxyConfigService>(config),
                        nullptr, nullptr);
 
   int rv;
   GURL url1("http://www.webkit.org");
   GURL url2("http://www.webkit.com");
 
   // Request for a .org domain should bypass proxy.
   rv = service.ResolveProxy(url1, std::string(), &info[0],
                             callback[0].callback(), nullptr, nullptr,
                             BoundNetLog());
@@ skipping 20 matching lines @@
        config.proxy_rules().proxies_for_http.GetAll()) {
     proxy_list.AddProxyServer(proxy_server);
     if (proxy_server == config.proxy_rules().proxies_for_http.Get())
       continue;
 
     additional_bad_proxies.push_back(proxy_server);
   }
 
   EXPECT_EQ(3u, additional_bad_proxies.size());
 
-  ProxyService service(base::WrapUnique(new MockProxyConfigService(config)),
+  ProxyService service(base::MakeUnique<MockProxyConfigService>(config),
                        nullptr, nullptr);
   ProxyInfo proxy_info;
   proxy_info.UseProxyList(proxy_list);
   const ProxyRetryInfoMap& retry_info = service.proxy_retry_info();
   service.MarkProxiesAsBadUntil(proxy_info, base::TimeDelta::FromSeconds(1),
                                 additional_bad_proxies, BoundNetLog());
   ASSERT_EQ(4u, retry_info.size());
   for (const ProxyServer& proxy_server :
        config.proxy_rules().proxies_for_http.GetAll()) {
     ProxyRetryInfoMap::const_iterator i =
         retry_info.find(proxy_server.host_port_pair().ToString());
     ASSERT_TRUE(i != retry_info.end());
   }
 }
 
 TEST_F(ProxyServiceTest, PerProtocolProxyTests) {
   ProxyConfig config;
   config.proxy_rules().ParseFromString("http=foopy1:8080;https=foopy2:8080");
   config.set_auto_detect(false);
   {
-    ProxyService service(base::WrapUnique(new MockProxyConfigService(config)),
+    ProxyService service(base::MakeUnique<MockProxyConfigService>(config),
                          nullptr, nullptr);
     GURL test_url("http://www.msn.com");
     ProxyInfo info;
     TestCompletionCallback callback;
     int rv = service.ResolveProxy(test_url, std::string(), &info,
                                   callback.callback(), nullptr, nullptr,
                                   BoundNetLog());
     EXPECT_THAT(rv, IsOk());
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
   }
   {
-    ProxyService service(base::WrapUnique(new MockProxyConfigService(config)),
+    ProxyService service(base::MakeUnique<MockProxyConfigService>(config),
                          nullptr, nullptr);
     GURL test_url("ftp://ftp.google.com");
     ProxyInfo info;
     TestCompletionCallback callback;
     int rv = service.ResolveProxy(test_url, std::string(), &info,
                                   callback.callback(), nullptr, nullptr,
                                   BoundNetLog());
     EXPECT_THAT(rv, IsOk());
     EXPECT_TRUE(info.is_direct());
     EXPECT_EQ("direct://", info.proxy_server().ToURI());
   }
   {
-    ProxyService service(base::WrapUnique(new MockProxyConfigService(config)),
+    ProxyService service(base::MakeUnique<MockProxyConfigService>(config),
                          nullptr, nullptr);
     GURL test_url("https://webbranch.techcu.com");
     ProxyInfo info;
     TestCompletionCallback callback;
     int rv = service.ResolveProxy(test_url, std::string(), &info,
                                   callback.callback(), nullptr, nullptr,
                                   BoundNetLog());
     EXPECT_THAT(rv, IsOk());
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("foopy2:8080", info.proxy_server().ToURI());
   }
   {
     config.proxy_rules().ParseFromString("foopy1:8080");
-    ProxyService service(base::WrapUnique(new MockProxyConfigService(config)),
+    ProxyService service(base::MakeUnique<MockProxyConfigService>(config),
                          nullptr, nullptr);
     GURL test_url("http://www.microsoft.com");
     ProxyInfo info;
     TestCompletionCallback callback;
     int rv = service.ResolveProxy(test_url, std::string(), &info,
                                   callback.callback(), nullptr, nullptr,
                                   BoundNetLog());
     EXPECT_THAT(rv, IsOk());
     EXPECT_FALSE(info.is_direct());
     EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
   }
 }
 
 TEST_F(ProxyServiceTest, ProxyConfigSourcePropagates) {
   // Test that the proxy config source is set correctly when resolving proxies
   // using manual proxy rules. Namely, the config source should only be set if
   // any of the rules were applied.
   {
     ProxyConfig config;
     config.set_source(PROXY_CONFIG_SOURCE_TEST);
     config.proxy_rules().ParseFromString("https=foopy2:8080");
-    ProxyService service(base::WrapUnique(new MockProxyConfigService(config)),
+    ProxyService service(base::MakeUnique<MockProxyConfigService>(config),
                          nullptr, nullptr);
     GURL test_url("http://www.google.com");
     ProxyInfo info;
     TestCompletionCallback callback;
     int rv = service.ResolveProxy(test_url, std::string(), &info,
                                   callback.callback(), nullptr, nullptr,
                                   BoundNetLog());
     ASSERT_THAT(rv, IsOk());
     // Should be SOURCE_TEST, even if there are no HTTP proxies configured.
     EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
   }
   {
     ProxyConfig config;
     config.set_source(PROXY_CONFIG_SOURCE_TEST);
     config.proxy_rules().ParseFromString("https=foopy2:8080");
-    ProxyService service(base::WrapUnique(new MockProxyConfigService(config)),
+    ProxyService service(base::MakeUnique<MockProxyConfigService>(config),
                          nullptr, nullptr);
     GURL test_url("https://www.google.com");
     ProxyInfo info;
     TestCompletionCallback callback;
     int rv = service.ResolveProxy(test_url, std::string(), &info,
                                   callback.callback(), nullptr, nullptr,
                                   BoundNetLog());
     ASSERT_THAT(rv, IsOk());
     // Used the HTTPS proxy. So source should be TEST.
     EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
   }
   {
     ProxyConfig config;
     config.set_source(PROXY_CONFIG_SOURCE_TEST);
-    ProxyService service(base::WrapUnique(new MockProxyConfigService(config)),
+    ProxyService service(base::MakeUnique<MockProxyConfigService>(config),
                          nullptr, nullptr);
     GURL test_url("http://www.google.com");
     ProxyInfo info;
     TestCompletionCallback callback;
     int rv = service.ResolveProxy(test_url, std::string(), &info,
                                   callback.callback(), nullptr, nullptr,
                                   BoundNetLog());
     ASSERT_THAT(rv, IsOk());
     // ProxyConfig is empty. Source should still be TEST.
     EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
@@ skipping 742 matching lines @@
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
             factory->pending_requests()[0]->script_data()->url());
 }
 
 TEST_F(ProxyServiceTest, ResetProxyConfigService) {
   ProxyConfig config1;
   config1.proxy_rules().ParseFromString("foopy1:8080");
   config1.set_auto_detect(false);
-  ProxyService service(base::WrapUnique(new MockProxyConfigService(config1)),
+  ProxyService service(base::MakeUnique<MockProxyConfigService>(config1),
                        nullptr, nullptr);
 
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(GURL("http://request1"), std::string(), &info,
                                 callback1.callback(), nullptr, nullptr,
                                 BoundNetLog());
   EXPECT_THAT(rv, IsOk());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   ProxyConfig config2;
   config2.proxy_rules().ParseFromString("foopy2:8080");
   config2.set_auto_detect(false);
-  service.ResetConfigService(
-      base::WrapUnique(new MockProxyConfigService(config2)));
+  service.ResetConfigService(base::MakeUnique<MockProxyConfigService>(config2));
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(GURL("http://request2"), std::string(), &info,
                             callback2.callback(), nullptr, nullptr,
                             BoundNetLog());
   EXPECT_THAT(rv, IsOk());
   EXPECT_EQ("foopy2:8080", info.proxy_server().ToURI());
 }
 
 // Test that when going from a configuration that required PAC to one
 // that does NOT, we unset the variable |should_use_proxy_resolver_|.
@@ skipping 56 matching lines @@
   MockAsyncProxyResolverFactory* factory =
       new MockAsyncProxyResolverFactory(true);
 
   TestNetLog log;
 
   ProxyService service(base::WrapUnique(config_service),
                        base::WrapUnique(factory), &log);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(
-      fetcher, base::WrapUnique(new DoNothingDhcpProxyScriptFetcher()));
+      fetcher, base::MakeUnique<DoNothingDhcpProxyScriptFetcher>());
 
   // Disable the "wait after IP address changes" hack, so this unit-test can
   // complete quickly.
   service.set_stall_proxy_auto_config_delay(base::TimeDelta());
 
   // Start 1 request.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(GURL("http://request1"), std::string(), &info1,
@@ skipping 949 matching lines @@
         GURL(test.sanitized_url_unstripped),
         helper.SanitizeUrl(raw_url, ProxyService::SanitizeUrlPolicy::UNSAFE));
 
     EXPECT_EQ(
         GURL(test.sanitized_url),
         helper.SanitizeUrl(raw_url, ProxyService::SanitizeUrlPolicy::SAFE));
   }
 }
 
 }  // namespace net