[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(
-        kMaxJobs,
-        kMaxRetryAttempts,
-        NULL /* NetLog */);
-
-    host_resolver->reset(impl);
+    net::HostResolver::Options options;
+    options.max_concurrent_resolves = kMaxJobs;
+    options.max_retry_attempts = kMaxRetryAttempts;
+    options.enable_caching = false;
+    options.enable_async = false;
+    scoped_ptr<net::HostResolver> resolver(
+        net::HostResolver::CreateSystemResolver(options, NULL /* NetLog */));
 
     // Modify it slightly based on the experiment being run.
     switch (experiment) {
       case ConnectionTester::HOST_RESOLVER_EXPERIMENT_PLAIN:
-        return net::OK;
+        break;
       case ConnectionTester::HOST_RESOLVER_EXPERIMENT_DISABLE_IPV6:
-        impl->SetDefaultAddressFamily(net::ADDRESS_FAMILY_IPV4);
-        return net::OK;
+        resolver->SetDefaultAddressFamily(net::ADDRESS_FAMILY_IPV4);
+        break;
       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);
-        return net::OK;
+        resolver->SetDefaultAddressFamily(family);
+        break;
       }
       default:
         NOTREACHED();
         return net::ERR_UNEXPECTED;
     }
+    (*host_resolver).swap(resolver);

[darin (slow to review), 2012/10/22 17:27:17]

host_resolver->swap(resolver);

[szym, 2012/10/22 17:48:43]

Done.

+    return net::OK;
   }
 
   // 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) {
     if (CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 341 matching lines @@
 
   // Notify the delegate of completion.
   delegate_->OnCompletedConnectionTestExperiment(current, result);
 
   if (remaining_experiments_.empty()) {
     delegate_->OnCompletedConnectionTestSuite();
   } else {
     StartNextExperiment();
   }
 }