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

net/url_request/url_request_context_builder.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/url_request/url_request_context_builder.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 153 matching lines @@
  private:
   std::string user_agent_;
   base::Thread cache_thread_;
   base::Thread file_thread_;
   URLRequestContextStorage storage_;
   DISALLOW_COPY_AND_ASSIGN(BasicURLRequestContext);
 };
 
 }  // namespace
 
-URLRequestContextBuilder::HostResolverParams::HostResolverParams()
-    : parallelism(HostResolver::kDefaultParallelism),
-      retry_attempts(HostResolver::kDefaultRetryAttempts) {}
-URLRequestContextBuilder::HostResolverParams::~HostResolverParams() {}
-
 URLRequestContextBuilder::HttpCacheParams::HttpCacheParams()
     : type(IN_MEMORY),
       max_size(0) {}
 URLRequestContextBuilder::HttpCacheParams::~HttpCacheParams() {}
 
 URLRequestContextBuilder::HttpNetworkSessionParams::HttpNetworkSessionParams()
     : ignore_certificate_errors(false),
       host_mapping_rules(NULL),
       http_pipelining_enabled(false),
       testing_fixed_http_port(0),
@@ skipping 17 matching lines @@
 
 URLRequestContext* URLRequestContextBuilder::Build() {
   BasicURLRequestContext* context = new BasicURLRequestContext;
   URLRequestContextStorage* storage = context->storage();
 
   context->set_user_agent(user_agent_);
 
   BasicNetworkDelegate* network_delegate = new BasicNetworkDelegate;
   storage->set_network_delegate(network_delegate);
 
-  net::HostResolver* host_resolver = net::CreateSystemHostResolver(
-      host_resolver_params_.parallelism,
-      host_resolver_params_.retry_attempts,
-      NULL /* no NetLog */);
-  storage->set_host_resolver(host_resolver);
+  storage->set_host_resolver(net::HostResolver::CreateDefaultResolver(NULL));
 
   if (ftp_enabled_) {
-    storage->set_ftp_transaction_factory(new FtpNetworkLayer(host_resolver));
+    storage->set_ftp_transaction_factory(
+        new FtpNetworkLayer(context->host_resolver()));
   }
 
   context->StartFileThread();
 
   // TODO(willchan): Switch to using this code when
   // ProxyService::CreateSystemProxyConfigService()'s signature doesn't suck.
 #if defined(OS_LINUX)
   ProxyConfigService* proxy_config_service = proxy_config_service_.release();
 #else
   ProxyConfigService* proxy_config_service =
       ProxyService::CreateSystemProxyConfigService(
           base::ThreadTaskRunnerHandle::Get(),
           context->file_message_loop());
 #endif  // defined(OS_LINUX)
   storage->set_proxy_service(
       ProxyService::CreateUsingSystemProxyResolver(
           proxy_config_service,
           4,  // TODO(willchan): Find a better constant somewhere.
           context->net_log()));
   storage->set_ssl_config_service(new net::SSLConfigServiceDefaults);
   storage->set_http_auth_handler_factory(
-      net::HttpAuthHandlerRegistryFactory::CreateDefault(host_resolver));
+      net::HttpAuthHandlerRegistryFactory::CreateDefault(
+          context->host_resolver()));
   storage->set_cookie_store(new CookieMonster(NULL, NULL));
   storage->set_transport_security_state(new net::TransportSecurityState());
   storage->set_http_server_properties(new net::HttpServerPropertiesImpl);
   storage->set_cert_verifier(CertVerifier::CreateDefault());
 
   net::HttpNetworkSession::Params network_session_params;
-  network_session_params.host_resolver = host_resolver;
+  network_session_params.host_resolver = context->host_resolver();
   network_session_params.cert_verifier = context->cert_verifier();
   network_session_params.transport_security_state =
       context->transport_security_state();
   network_session_params.proxy_service = context->proxy_service();
   network_session_params.ssl_config_service =
       context->ssl_config_service();
   network_session_params.http_auth_handler_factory =
       context->http_auth_handler_factory();
   network_session_params.network_delegate =
       context->network_delegate();
@@ skipping 39 matching lines @@
     http_transaction_factory = new HttpNetworkLayer(network_session);
   }
   storage->set_http_transaction_factory(http_transaction_factory);
 
   // TODO(willchan): Support sdch.
 
   return context;
 }
 
 }  // namespace net