[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::URLRequestContextBuilder()
     : ftp_enabled_(false),
       http_cache_enabled_(true) {}
 URLRequestContextBuilder::~URLRequestContextBuilder() {}
 
 #if defined(OS_LINUX)
 void URLRequestContextBuilder::set_proxy_config_service(
     ProxyConfigService* proxy_config_service) {
   proxy_config_service_.reset(proxy_config_service);
 }
 #endif  // defined(OS_LINUX)
 
 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).release());
 
   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());
 
   HttpTransactionFactory* http_transaction_factory = NULL;
   if (http_cache_enabled_) {
     HttpCache::BackendFactory* http_cache_backend = NULL;
     if (http_cache_params_.type == HttpCacheParams::DISK) {
       context->StartCacheThread();
@@ skipping 40 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