make ProxyService::CreateSystemProxyConfigService return scoped_ptrs

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 "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 901 matching lines @@
   ProxyConfig::ID config_id_;  // The config id when the resolve was started.
   ProxyConfigSource config_source_;  // The source of proxy settings.
   BoundNetLog net_log_;
   // Time when the request was created.  Stored here rather than in |results_|
   // because the time in |results_| will be cleared.
   TimeTicks creation_time_;
 };
 
 // ProxyService ---------------------------------------------------------------
 
-ProxyService::ProxyService(ProxyConfigService* config_service,
+ProxyService::ProxyService(scoped_ptr<ProxyConfigService> config_service,
                            scoped_ptr<ProxyResolverFactory> resolver_factory,
                            NetLog* net_log)
     : resolver_factory_(resolver_factory.Pass()),
       next_config_id_(1),
       current_state_(STATE_NONE),
       net_log_(net_log),
       stall_proxy_auto_config_delay_(
           TimeDelta::FromMilliseconds(kDelayAfterNetworkChangesMs)),
       quick_check_enabled_(true) {
   NetworkChangeNotifier::AddIPAddressObserver(this);
   NetworkChangeNotifier::AddDNSObserver(this);
-  ResetConfigService(config_service);
+  ResetConfigService(config_service.Pass());

[Randy Smith (Not in Mondays), 2015/09/18 20:14:55]

nit, suggestion: You might not need the .Pass() here, since config_service is
going out of scope.  The compiler's the ultimate arbiter, obviously.

[Charlie Harrison, 2015/09/21 16:47:04]

Compiler complains about these when Pass() is omitted. Unlike in the case where
you .Pass() the whole `return` expression, in this case maybe the compiler is
extra cautious, because you could be using config_service again e.g. as another
argument, etc.

 }
 
 // static
 scoped_ptr<ProxyService> ProxyService::CreateUsingSystemProxyResolver(
-    ProxyConfigService* proxy_config_service,
+    scoped_ptr<ProxyConfigService> proxy_config_service,
     size_t num_pac_threads,
     NetLog* net_log) {
   DCHECK(proxy_config_service);
 
   if (!ProxyResolverFactoryForSystem::IsSupported()) {
     VLOG(1) << "PAC support disabled because there is no system implementation";
-    return CreateWithoutProxyResolver(proxy_config_service, net_log);
+    return CreateWithoutProxyResolver(proxy_config_service.Pass(), net_log);

[Randy Smith (Not in Mondays), 2015/09/18 20:14:55]

same comment here and below (but I'm speculating).

   }
 
   if (num_pac_threads == 0)
     num_pac_threads = kDefaultNumPacThreads;
 
   return make_scoped_ptr(new ProxyService(
-      proxy_config_service,
+      proxy_config_service.Pass(),
       make_scoped_ptr(new ProxyResolverFactoryForSystem(num_pac_threads)),
       net_log));
 }
 
 // static
 scoped_ptr<ProxyService> ProxyService::CreateWithoutProxyResolver(
-    ProxyConfigService* proxy_config_service,
+    scoped_ptr<ProxyConfigService> proxy_config_service,
     NetLog* net_log) {
   return make_scoped_ptr(new ProxyService(
-      proxy_config_service,
+      proxy_config_service.Pass(),
       make_scoped_ptr(new ProxyResolverFactoryForNullResolver), net_log));
 }
 
 // static
 scoped_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(new ProxyConfigServiceFixed(pc),
-                                        0, NULL);
+  return CreateUsingSystemProxyResolver(
+      make_scoped_ptr(new ProxyConfigServiceFixed(pc)), 0, NULL);
 }
 
 // static
 scoped_ptr<ProxyService> ProxyService::CreateFixed(const std::string& proxy) {
   ProxyConfig proxy_config;
   proxy_config.proxy_rules().ParseFromString(proxy);
   return ProxyService::CreateFixed(proxy_config);
 }
 
 // static
 scoped_ptr<ProxyService> ProxyService::CreateDirect() {
   return CreateDirectWithNetLog(NULL);
 }
 
 scoped_ptr<ProxyService> ProxyService::CreateDirectWithNetLog(NetLog* net_log) {
   // Use direct connections.
   return make_scoped_ptr(new ProxyService(
-      new ProxyConfigServiceDirect,
+      make_scoped_ptr(new ProxyConfigServiceDirect),
       make_scoped_ptr(new ProxyResolverFactoryForNullResolver), net_log));
 }
 
 // static
 scoped_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.
   scoped_ptr<ProxyConfigService> proxy_config_service(
       new ProxyConfigServiceFixed(ProxyConfig::CreateAutoDetect()));
 
   return make_scoped_ptr(new ProxyService(
-      proxy_config_service.release(),
+      proxy_config_service.Pass(),
       make_scoped_ptr(new ProxyResolverFactoryForPacResult(pac_string)), NULL));
 }
 
 int ProxyService::ResolveProxy(const GURL& raw_url,
                                int load_flags,
                                ProxyInfo* result,
                                const CompletionCallback& callback,
                                PacRequest** pac_request,
                                NetworkDelegate* network_delegate,
                                const BoundNetLog& net_log) {
@@ skipping 449 matching lines @@
   resolver_.reset();
   config_ = ProxyConfig();
   if (reset_fetched_config)
     fetched_config_ = ProxyConfig();
   current_state_ = STATE_NONE;
 
   return previous_state;
 }
 
 void ProxyService::ResetConfigService(
-    ProxyConfigService* new_proxy_config_service) {
+    scoped_ptr<ProxyConfigService> new_proxy_config_service) {
   DCHECK(CalledOnValidThread());
   State previous_state = ResetProxyConfig(true);
 
   // Release the old configuration service.
   if (config_service_.get())
     config_service_->RemoveObserver(this);
 
   // Set the new configuration service.
-  config_service_.reset(new_proxy_config_service);
+  config_service_ = new_proxy_config_service.Pass();
   config_service_->AddObserver(this);
 
   if (previous_state != STATE_NONE)
     ApplyProxyConfigIfAvailable();
 }
 
 void ProxyService::ForceReloadProxyConfig() {
   DCHECK(CalledOnValidThread());
   ResetProxyConfig(false);
   ApplyProxyConfigIfAvailable();
 }
 
 // static
-ProxyConfigService* ProxyService::CreateSystemProxyConfigService(
+scoped_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 new ProxyConfigServiceWin();
+  return make_scoped_ptr(new ProxyConfigServiceWin());
 #elif defined(OS_IOS)
-  return new ProxyConfigServiceIOS();
+  return make_scoped_ptr(new ProxyConfigServiceIOS());
 #elif defined(OS_MACOSX)
-  return new ProxyConfigServiceMac(io_task_runner);
+  return make_scoped_ptr(new 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 new UnsetProxyConfigService;
+  return make_scoped_ptr(new UnsetProxyConfigService);
 #elif defined(OS_LINUX)
-  ProxyConfigServiceLinux* linux_config_service =
-      new ProxyConfigServiceLinux();
+  scoped_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 linux_config_service;
+  return linux_config_service.Pass();
 #elif defined(OS_ANDROID)
-  return new ProxyConfigServiceAndroid(io_task_runner,
-                                       base::ThreadTaskRunnerHandle::Get());
+  return make_scoped_ptr(new ProxyConfigServiceAndroid(
+      io_task_runner, base::ThreadTaskRunnerHandle::Get()));
 #else
   LOG(WARNING) << "Failed to choose a system proxy settings fetcher "
                   "for this platform.";
-  return new ProxyConfigServiceDirect();
+  return make_scoped_ptr(new 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