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

chrome/browser/io_thread.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/io_thread.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 98 matching lines @@
   }
 
  private:
   virtual ~SystemURLRequestContext() {
 #if defined(USE_NSS)
     net::SetURLRequestContextForNSSHttpIO(NULL);
 #endif  // defined(USE_NSS)
   }
 };
 
-net::HostResolver* CreateGlobalHostResolver(net::NetLog* net_log) {
+scoped_ptr<net::HostResolver> CreateGlobalHostResolver(net::NetLog* net_log) {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   bool allow_async_dns_field_trial = true;
 
-  size_t parallelism = net::HostResolver::kDefaultParallelism;
+  net::HostResolver::Options options;
+  options.enable_caching = true;
+  options.max_concurrent_resolves = net::HostResolver::kDefaultParallelism;

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

nit: Shouldn't the Options struct have a constructor that initializes
max_concurrent_resolves to kDefaultParallelism?  I don't think everyone should
have to replicate this line of code.

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

It already does have a default constructor which does all that. I removed the
explicit initialization.

 
   // Use the concurrency override from the command-line, if any.
   if (command_line.HasSwitch(switches::kHostResolverParallelism)) {
     allow_async_dns_field_trial = false;
     std::string s =
         command_line.GetSwitchValueASCII(switches::kHostResolverParallelism);
 
     // Parse the switch (it should be a positive integer formatted as decimal).
     int n;
     if (base::StringToInt(s, &n) && n > 0) {
-      parallelism = static_cast<size_t>(n);
+      options.max_concurrent_resolves = static_cast<size_t>(n);
     } else {
       LOG(ERROR) << "Invalid switch for host resolver parallelism: " << s;
     }
   }
 
-  size_t retry_attempts = net::HostResolver::kDefaultRetryAttempts;
+  options.max_retry_attempts = net::HostResolver::kDefaultRetryAttempts;

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

ditto.  seems like Options constructor should initialize this.

 
   // Use the retry attempts override from the command-line, if any.
   if (command_line.HasSwitch(switches::kHostResolverRetryAttempts)) {
     allow_async_dns_field_trial = false;
     std::string s =
         command_line.GetSwitchValueASCII(switches::kHostResolverRetryAttempts);
     // Parse the switch (it should be a non-negative integer).
     int n;
     if (base::StringToInt(s, &n) && n >= 0) {
-      retry_attempts = static_cast<size_t>(n);
+      options.max_retry_attempts = static_cast<size_t>(n);
     } else {
       LOG(ERROR) << "Invalid switch for host resolver retry attempts: " << s;
     }
   }
 
-  net::HostResolver* global_host_resolver = NULL;
-  bool use_async = false;
+  options.enable_async = false;
   if (command_line.HasSwitch(switches::kEnableAsyncDns)) {
     allow_async_dns_field_trial = false;
-    use_async = true;
+    options.enable_async = true;
   } else if (command_line.HasSwitch(switches::kDisableAsyncDns)) {
     allow_async_dns_field_trial = false;
-    use_async = false;
+    options.enable_async = false;
   }
 
   if (allow_async_dns_field_trial)
-    use_async = chrome_browser_net::ConfigureAsyncDnsFieldTrial();
+    options.enable_async = chrome_browser_net::ConfigureAsyncDnsFieldTrial();
 
-  if (use_async) {
-    global_host_resolver =
-        net::CreateAsyncHostResolver(parallelism, retry_attempts, net_log);
-  } else {
-    global_host_resolver =
-        net::CreateSystemHostResolver(parallelism, retry_attempts, net_log);
-  }
+  scoped_ptr<net::HostResolver> global_host_resolver(
+      net::HostResolver::CreateSystemResolver(options, net_log));
 
   // Determine if we should disable IPv6 support.
   if (!command_line.HasSwitch(switches::kEnableIPv6)) {
     if (command_line.HasSwitch(switches::kDisableIPv6)) {
       global_host_resolver->SetDefaultAddressFamily(net::ADDRESS_FAMILY_IPV4);
     } else {
       global_host_resolver->ProbeIPv6Support();
     }
   }
 
   // If hostname remappings were specified on the command-line, layer these
   // rules on top of the real host resolver. This allows forwarding all requests
   // through a designated test server.
   if (!command_line.HasSwitch(switches::kHostResolverRules))
-    return global_host_resolver;
+    return global_host_resolver.PassAs<net::HostResolver>();
 
-  net::MappedHostResolver* remapped_resolver =
-      new net::MappedHostResolver(global_host_resolver);
+  scoped_ptr<net::MappedHostResolver> remapped_resolver(
+      new net::MappedHostResolver(global_host_resolver.Pass()));
   remapped_resolver->SetRulesFromString(
       command_line.GetSwitchValueASCII(switches::kHostResolverRules));
-  return remapped_resolver;
+  return remapped_resolver.PassAs<net::HostResolver>();
 }
 
 // TODO(willchan): Remove proxy script fetcher context since it's not necessary
 // now that I got rid of refcounting URLRequestContexts.
 // See IOThread::Globals for details.
 net::URLRequestContext*
 ConstructProxyScriptFetcherContext(IOThread::Globals* globals,
                                    net::NetLog* net_log) {
   net::URLRequestContext* context = new URLRequestContextWithUserAgent;
   context->set_net_log(net_log);
@@ skipping 231 matching lines @@
       NULL,
       NULL,
       NULL,
       NULL,
       &system_enable_referrers_,
       NULL,
       NULL);
   if (command_line.HasSwitch(switches::kDisableExtensionsHttpThrottling))
     network_delegate->NeverThrottleRequests();
   globals_->system_network_delegate.reset(network_delegate);
-  globals_->host_resolver.reset(
-      CreateGlobalHostResolver(net_log_));
+  globals_->host_resolver = CreateGlobalHostResolver(net_log_);
   globals_->cert_verifier.reset(net::CertVerifier::CreateDefault());
   globals_->transport_security_state.reset(new net::TransportSecurityState());
   globals_->ssl_config_service = GetSSLConfigService();
   if (command_line.HasSwitch(switches::kSpdyProxyOrigin)) {
     spdyproxy_origin_ =
         command_line.GetSwitchValueASCII(switches::kSpdyProxyOrigin);
   }
   globals_->http_auth_handler_factory.reset(CreateDefaultAuthHandlerFactory(
       globals_->host_resolver.get()));
   globals_->http_server_properties.reset(new net::HttpServerPropertiesImpl);
@@ skipping 269 matching lines @@
       new net::HttpNetworkLayer(
           new net::HttpNetworkSession(system_params)));
   globals_->system_ftp_transaction_factory.reset(
       new net::FtpNetworkLayer(globals_->host_resolver.get()));
   globals_->system_request_context.reset(
       ConstructSystemRequestContext(globals_, net_log_));
 
   sdch_manager_->set_sdch_fetcher(
       new SdchDictionaryFetcher(system_url_request_context_getter_.get()));
 }