[net] Change factory methods for HostResolver and HostCache to return a scoped_ptr

chrome/browser/net/connection_tester.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 "chrome/browser/net/connection_tester.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 76 matching lines @@
            scoped_ptr<net::ProxyConfigService>* proxy_config_service,
            net::NetLog* net_log) {
     int rv;
 
     // Create a custom HostResolver for this experiment.
     scoped_ptr<net::HostResolver> host_resolver_tmp;
     rv = CreateHostResolver(experiment.host_resolver_experiment,
                             &host_resolver_tmp);
     if (rv != net::OK)
       return rv;  // Failure.
-    storage_.set_host_resolver(host_resolver_tmp.release());
+    storage_.set_host_resolver(host_resolver_tmp.Pass());
 
     // Create a custom ProxyService for this this experiment.
     scoped_ptr<net::ProxyService> experiment_proxy_service;
     rv = CreateProxyService(experiment.proxy_settings_experiment,
                             proxy_config_service, &experiment_proxy_service);
     if (rv != net::OK)
       return rv;  // Failure.
     storage_.set_proxy_service(experiment_proxy_service.release());
 
     // The rest of the dependencies are standard, and don't depend on the
@@ skipping 28 matching lines @@
  private:
   // Creates a host resolver for |experiment|. On success returns net::OK and
   // fills |host_resolver| with a new pointer. Otherwise returns a network
   // error code.
   int CreateHostResolver(
       ConnectionTester::HostResolverExperiment experiment,
       scoped_ptr<net::HostResolver>* host_resolver) {
     // Create a vanilla HostResolver that disables caching.
     const size_t kMaxJobs = 50u;
     const size_t kMaxRetryAttempts = 4u;
-    net::HostResolver* impl = net::CreateNonCachingSystemHostResolver(
+    *host_resolver = net::HostResolver::CreateSystemResolver(
         kMaxJobs,
         kMaxRetryAttempts,
+        false /* use_cache */,
+        false /* use_async */,
         NULL /* NetLog */);
 
-    host_resolver->reset(impl);
-
     // Modify it slightly based on the experiment being run.
     switch (experiment) {
       case ConnectionTester::HOST_RESOLVER_EXPERIMENT_PLAIN:
         return net::OK;
       case ConnectionTester::HOST_RESOLVER_EXPERIMENT_DISABLE_IPV6:
-        impl->SetDefaultAddressFamily(net::ADDRESS_FAMILY_IPV4);
+        (*host_resolver)->SetDefaultAddressFamily(net::ADDRESS_FAMILY_IPV4);
         return net::OK;
       case ConnectionTester::HOST_RESOLVER_EXPERIMENT_IPV6_PROBE: {
         // Note that we don't use impl->ProbeIPv6Support() since that finishes
         // asynchronously and may not take effect in time for the test.
         // So instead we will probe synchronously (might take 100-200 ms).
         net::AddressFamily family = net::TestIPv6Support().ipv6_supported ?
             net::ADDRESS_FAMILY_UNSPECIFIED : net::ADDRESS_FAMILY_IPV4;
-        impl->SetDefaultAddressFamily(family);
+        (*host_resolver)->SetDefaultAddressFamily(family);
         return net::OK;
       }
       default:
         NOTREACHED();
         return net::ERR_UNEXPECTED;

[darin (slow to review), 2012/10/09 17:38:34]

It looks like it is possible for this function to return an error and a non-null
HostResolver instance!!  That's generally a bad idea as it can create flaky
code.

I recommend changing to a pattern like this:

  scoped_ptr<net::HostResolver> result = ...Create...
  switch (experiment) {
    case ...
      break;
    case ...
      break;
    default:
      NOTREACHED();
      return net::ERR_UNEXPECTED;
  }
  host_resolver->swap(result);
  return net::OK;

[szym, 2012/10/09 21:40:43]

Done.

     }
   }
 
   // Creates a proxy service for |experiment|. On success returns net::OK
   // and fills |experiment_proxy_service| with a new pointer. Otherwise returns
   // a network error code.
   int CreateProxyService(
       ConnectionTester::ProxySettingsExperiment experiment,
       scoped_ptr<net::ProxyConfigService>* proxy_config_service,
       scoped_ptr<net::ProxyService>* experiment_proxy_service) {
@@ skipping 342 matching lines @@
 
   // Notify the delegate of completion.
   delegate_->OnCompletedConnectionTestExperiment(current, result);
 
   if (remaining_experiments_.empty()) {
     delegate_->OnCompletedConnectionTestSuite();
   } else {
     StartNextExperiment();
   }
 }