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

net/proxy/proxy_service.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 <algorithm>
 #include <cmath>
 #include <utility>
 
@@ skipping 218 matching lines @@
 
 // Creates ProxyResolvers using a platform-specific implementation.
 class ProxyResolverFactoryForSystem : public MultiThreadedProxyResolverFactory {
  public:
   explicit ProxyResolverFactoryForSystem(size_t max_num_threads)
       : MultiThreadedProxyResolverFactory(max_num_threads,
                                           false /*expects_pac_bytes*/) {}
 
   std::unique_ptr<ProxyResolverFactory> CreateProxyResolverFactory() override {
 #if defined(OS_WIN)
-    return base::WrapUnique(new ProxyResolverFactoryWinHttp());
+    return base::MakeUnique<ProxyResolverFactoryWinHttp>();
 #elif defined(OS_MACOSX)
-    return base::WrapUnique(new ProxyResolverFactoryMac());
+    return base::MakeUnique<ProxyResolverFactoryMac>();
 #else
     NOTREACHED();
     return NULL;
 #endif
   }
 
   static bool IsSupported() {
 #if defined(OS_WIN) || defined(OS_MACOSX)
     return true;
 #else
@@ skipping 719 matching lines @@
   if (!ProxyResolverFactoryForSystem::IsSupported()) {
     VLOG(1) << "PAC support disabled because there is no system implementation";
     return CreateWithoutProxyResolver(std::move(proxy_config_service), net_log);
   }
 
   if (num_pac_threads == 0)
     num_pac_threads = kDefaultNumPacThreads;
 
   return base::WrapUnique(new ProxyService(
       std::move(proxy_config_service),
-      base::WrapUnique(new ProxyResolverFactoryForSystem(num_pac_threads)),
+      base::MakeUnique<ProxyResolverFactoryForSystem>(num_pac_threads),
       net_log));
 }
 
 // static
 std::unique_ptr<ProxyService> ProxyService::CreateWithoutProxyResolver(
     std::unique_ptr<ProxyConfigService> proxy_config_service,
     NetLog* net_log) {
   return base::WrapUnique(new ProxyService(
       std::move(proxy_config_service),
       base::WrapUnique(new ProxyResolverFactoryForNullResolver), net_log));
 }
 
 // static
 std::unique_ptr<ProxyService> ProxyService::CreateFixed(const ProxyConfig& pc) {
   // TODO(eroman): This isn't quite right, won't work if |pc| specifies
   //               a PAC script.
   return CreateUsingSystemProxyResolver(
-      base::WrapUnique(new ProxyConfigServiceFixed(pc)), 0, NULL);
+      base::MakeUnique<ProxyConfigServiceFixed>(pc), 0, NULL);
 }
 
 // static
 std::unique_ptr<ProxyService> ProxyService::CreateFixed(
     const std::string& proxy) {
   ProxyConfig proxy_config;
   proxy_config.proxy_rules().ParseFromString(proxy);
   return ProxyService::CreateFixed(proxy_config);
 }
 
@@ skipping 13 matching lines @@
 // static
 std::unique_ptr<ProxyService> ProxyService::CreateFixedFromPacResult(
     const std::string& pac_string) {
   // We need the settings to contain an "automatic" setting, otherwise the
   // ProxyResolver dependency we give it will never be used.
   std::unique_ptr<ProxyConfigService> proxy_config_service(
       new ProxyConfigServiceFixed(ProxyConfig::CreateAutoDetect()));
 
   return base::WrapUnique(new ProxyService(
       std::move(proxy_config_service),
-      base::WrapUnique(new ProxyResolverFactoryForPacResult(pac_string)),
-      NULL));
+      base::MakeUnique<ProxyResolverFactoryForPacResult>(pac_string), NULL));
 }
 
 int ProxyService::ResolveProxy(const GURL& raw_url,
                                const std::string& method,
                                ProxyInfo* result,
                                const CompletionCallback& callback,
                                PacRequest** pac_request,
                                ProxyDelegate* proxy_delegate,
                                const BoundNetLog& net_log) {
   DCHECK(!callback.is_null());
@@ skipping 472 matching lines @@
   ResetProxyConfig(false);
   ApplyProxyConfigIfAvailable();
 }
 
 // static
 std::unique_ptr<ProxyConfigService>
 ProxyService::CreateSystemProxyConfigService(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner) {
 #if defined(OS_WIN)
-  return base::WrapUnique(new ProxyConfigServiceWin());
+  return base::MakeUnique<ProxyConfigServiceWin>();
 #elif defined(OS_IOS)
-  return base::WrapUnique(new ProxyConfigServiceIOS());
+  return base::MakeUnique<ProxyConfigServiceIOS>();
 #elif defined(OS_MACOSX)
-  return base::WrapUnique(new ProxyConfigServiceMac(io_task_runner));
+  return base::MakeUnique<ProxyConfigServiceMac>(io_task_runner);
 #elif defined(OS_CHROMEOS)
   LOG(ERROR) << "ProxyConfigService for ChromeOS should be created in "
              << "profile_io_data.cc::CreateProxyConfigService and this should "
              << "be used only for examples.";
   return base::WrapUnique(new UnsetProxyConfigService);
 #elif defined(OS_LINUX)
   std::unique_ptr<ProxyConfigServiceLinux> linux_config_service(
       new ProxyConfigServiceLinux());
 
   // Assume we got called on the thread that runs the default glib
   // main loop, so the current thread is where we should be running
   // gconf calls from.
   scoped_refptr<base::SingleThreadTaskRunner> glib_thread_task_runner =
       base::ThreadTaskRunnerHandle::Get();
 
   // Synchronously fetch the current proxy config (since we are running on
   // glib_default_loop). Additionally register for notifications (delivered in
   // either |glib_default_loop| or |file_task_runner|) to keep us updated when
   // the proxy config changes.
   linux_config_service->SetupAndFetchInitialConfig(
       glib_thread_task_runner, io_task_runner, file_task_runner);
 
   return std::move(linux_config_service);
 #elif defined(OS_ANDROID)
-  return base::WrapUnique(new ProxyConfigServiceAndroid(
-      io_task_runner, base::ThreadTaskRunnerHandle::Get()));
+  return base::MakeUnique<ProxyConfigServiceAndroid>(
+      io_task_runner, base::ThreadTaskRunnerHandle::Get());
 #else
   LOG(WARNING) << "Failed to choose a system proxy settings fetcher "
                   "for this platform.";
-  return base::WrapUnique(new ProxyConfigServiceDirect());
+  return base::MakeUnique<ProxyConfigServiceDirect>();
 #endif
 }
 
 // static
 const ProxyService::PacPollPolicy* ProxyService::set_pac_script_poll_policy(
     const PacPollPolicy* policy) {
   return ProxyScriptDeciderPoller::set_policy(policy);
 }
 
 // static
@@ skipping 98 matching lines @@
   State previous_state = ResetProxyConfig(false);
   if (previous_state != STATE_NONE)
     ApplyProxyConfigIfAvailable();
 }
 
 void ProxyService::OnDNSChanged() {
   OnIPAddressChanged();
 }
 
 }  // namespace net