diff options
31 files changed, 184 insertions, 247 deletions
diff --git a/chrome/browser/io_thread.cc b/chrome/browser/io_thread.cc index b8b3c90..08ed80c 100644 --- a/chrome/browser/io_thread.cc +++ b/chrome/browser/io_thread.cc @@ -116,12 +116,12 @@ class SystemURLRequestContext : public URLRequestContextWithUserAgent { } }; -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; // Use the concurrency override from the command-line, if any. if (command_line.HasSwitch(switches::kHostResolverParallelism)) { @@ -132,14 +132,12 @@ net::HostResolver* CreateGlobalHostResolver(net::NetLog* net_log) { // 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; - // Use the retry attempts override from the command-line, if any. if (command_line.HasSwitch(switches::kHostResolverRetryAttempts)) { allow_async_dns_field_trial = false; @@ -148,32 +146,25 @@ net::HostResolver* CreateGlobalHostResolver(net::NetLog* net_log) { // 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; 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(); - - if (use_async) { - global_host_resolver = - net::CreateAsyncHostResolver(parallelism, retry_attempts, net_log); - } else { - global_host_resolver = - net::CreateSystemHostResolver(parallelism, retry_attempts, net_log); - } + options.enable_async = chrome_browser_net::ConfigureAsyncDnsFieldTrial(); + + 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)) { @@ -188,13 +179,13 @@ net::HostResolver* CreateGlobalHostResolver(net::NetLog* net_log) { // 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 @@ -446,8 +437,7 @@ void IOThread::Init() { 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(); diff --git a/chrome/browser/net/connection_tester.cc b/chrome/browser/net/connection_tester.cc index 6940462..a8aadfe 100644 --- a/chrome/browser/net/connection_tester.cc +++ b/chrome/browser/net/connection_tester.cc @@ -94,7 +94,7 @@ class ExperimentURLRequestContext : public net::URLRequestContext { &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; @@ -143,33 +143,36 @@ class ExperimentURLRequestContext : public net::URLRequestContext { // 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); + return net::OK; } // Creates a proxy service for |experiment|. On success returns net::OK diff --git a/chrome/service/net/service_url_request_context.cc b/chrome/service/net/service_url_request_context.cc index a7ab6f2..e05b7b9 100644 --- a/chrome/service/net/service_url_request_context.cc +++ b/chrome/service/net/service_url_request_context.cc @@ -110,10 +110,7 @@ ServiceURLRequestContext::ServiceURLRequestContext( net::ProxyConfigService* net_proxy_config_service) : user_agent_(user_agent), ALLOW_THIS_IN_INITIALIZER_LIST(storage_(this)) { - storage_.set_host_resolver( - net::CreateSystemHostResolver(net::HostResolver::kDefaultParallelism, - net::HostResolver::kDefaultRetryAttempts, - NULL)); + storage_.set_host_resolver(net::HostResolver::CreateDefaultResolver(NULL)); storage_.set_proxy_service(net::ProxyService::CreateUsingSystemProxyResolver( net_proxy_config_service, 0u, NULL)); storage_.set_cert_verifier(net::CertVerifier::CreateDefault()); diff --git a/content/shell/shell_url_request_context_getter.cc b/content/shell/shell_url_request_context_getter.cc index f612fa5..9300dc6 100644 --- a/content/shell/shell_url_request_context_getter.cc +++ b/content/shell/shell_url_request_context_getter.cc @@ -71,10 +71,9 @@ net::URLRequestContext* ShellURLRequestContextGetter::GetURLRequestContext() { url_request_context_->set_accept_language("en-us,en"); url_request_context_->set_accept_charset("iso-8859-1,*,utf-8"); - storage_->set_host_resolver( - net::CreateSystemHostResolver(net::HostResolver::kDefaultParallelism, - net::HostResolver::kDefaultRetryAttempts, - NULL)); + scoped_ptr<net::HostResolver> host_resolver( + net::HostResolver::CreateDefaultResolver(NULL)); + storage_->set_cert_verifier(net::CertVerifier::CreateDefault()); // TODO(jam): use v8 if possible, look at chrome code. storage_->set_proxy_service( @@ -84,8 +83,7 @@ net::URLRequestContext* ShellURLRequestContextGetter::GetURLRequestContext() { NULL)); storage_->set_ssl_config_service(new net::SSLConfigServiceDefaults); storage_->set_http_auth_handler_factory( - net::HttpAuthHandlerFactory::CreateDefault( - url_request_context_->host_resolver())); + net::HttpAuthHandlerFactory::CreateDefault(host_resolver.get())); storage_->set_http_server_properties(new net::HttpServerPropertiesImpl); FilePath cache_path = base_path_.Append(FILE_PATH_LITERAL("Cache")); @@ -98,8 +96,6 @@ net::URLRequestContext* ShellURLRequestContextGetter::GetURLRequestContext() { BrowserThread::CACHE)); net::HttpNetworkSession::Params network_session_params; - network_session_params.host_resolver = - url_request_context_->host_resolver(); network_session_params.cert_verifier = url_request_context_->cert_verifier(); network_session_params.server_bound_cert_service = @@ -129,13 +125,18 @@ net::URLRequestContext* ShellURLRequestContextGetter::GetURLRequestContext() { network_session_params.testing_fixed_https_port = value; } if (command_line.HasSwitch(switches::kHostResolverRules)) { - mapped_host_resolver_.reset( - new net::MappedHostResolver(network_session_params.host_resolver)); - mapped_host_resolver_->SetRulesFromString( + scoped_ptr<net::MappedHostResolver> mapped_host_resolver( + new net::MappedHostResolver(host_resolver.Pass())); + mapped_host_resolver->SetRulesFromString( command_line.GetSwitchValueASCII(switches::kHostResolverRules)); - network_session_params.host_resolver = mapped_host_resolver_.get(); + host_resolver = mapped_host_resolver.Pass(); } + // Give |storage_| ownership at the end in case it's |mapped_host_resolver|. + storage_->set_host_resolver(host_resolver.Pass()); + network_session_params.host_resolver = + url_request_context_->host_resolver(); + net::HttpCache* main_cache = new net::HttpCache( network_session_params, main_backend); storage_->set_http_transaction_factory(main_cache); diff --git a/content/shell/shell_url_request_context_getter.h b/content/shell/shell_url_request_context_getter.h index 8f61d8b..957f046 100644 --- a/content/shell/shell_url_request_context_getter.h +++ b/content/shell/shell_url_request_context_getter.h @@ -51,7 +51,6 @@ class ShellURLRequestContextGetter : public net::URLRequestContextGetter { scoped_ptr<net::NetworkDelegate> network_delegate_; scoped_ptr<net::URLRequestContextStorage> storage_; scoped_ptr<net::URLRequestContext> url_request_context_; - scoped_ptr<net::MappedHostResolver> mapped_host_resolver_; DISALLOW_COPY_AND_ASSIGN(ShellURLRequestContextGetter); }; diff --git a/jingle/notifier/communicator/single_login_attempt_unittest.cc b/jingle/notifier/communicator/single_login_attempt_unittest.cc index 9076015..7b35c3c 100644 --- a/jingle/notifier/communicator/single_login_attempt_unittest.cc +++ b/jingle/notifier/communicator/single_login_attempt_unittest.cc @@ -73,7 +73,8 @@ class FakeDelegate : public SingleLoginAttempt::Delegate { class MyTestURLRequestContext : public TestURLRequestContext { public: MyTestURLRequestContext() : TestURLRequestContext(true) { - context_storage_.set_host_resolver(new net::HangingHostResolver()); + context_storage_.set_host_resolver( + scoped_ptr<net::HostResolver>(new net::HangingHostResolver())); Init(); } virtual ~MyTestURLRequestContext() {} diff --git a/net/base/host_cache.cc b/net/base/host_cache.cc index 9d74646..5221fca 100644 --- a/net/base/host_cache.cc +++ b/net/base/host_cache.cc @@ -79,7 +79,7 @@ const HostCache::EntryMap& HostCache::entries() const { } // static -HostCache* HostCache::CreateDefaultCache() { +scoped_ptr<HostCache> HostCache::CreateDefaultCache() { #if defined(OS_CHROMEOS) // Increase HostCache size for the duration of the async DNS field trial. // http://crbug.com/143454 @@ -88,7 +88,7 @@ HostCache* HostCache::CreateDefaultCache() { #else static const size_t kMaxHostCacheEntries = 100; #endif - return new HostCache(kMaxHostCacheEntries); + return make_scoped_ptr(new HostCache(kMaxHostCacheEntries)); } } // namespace net diff --git a/net/base/host_cache.h b/net/base/host_cache.h index 2a3aedc..3826045 100644 --- a/net/base/host_cache.h +++ b/net/base/host_cache.h @@ -9,6 +9,7 @@ #include <string> #include "base/gtest_prod_util.h" +#include "base/memory/scoped_ptr.h" #include "base/threading/non_thread_safe.h" #include "base/time.h" #include "net/base/address_family.h" @@ -92,7 +93,7 @@ class NET_EXPORT HostCache : NON_EXPORTED_BASE(public base::NonThreadSafe) { const EntryMap& entries() const; // Creates a default cache. - static HostCache* CreateDefaultCache(); + static scoped_ptr<HostCache> CreateDefaultCache(); private: FRIEND_TEST_ALL_PREFIXES(HostCacheTest, NoCache); diff --git a/net/base/host_resolver.cc b/net/base/host_resolver.cc index 3e86aff..15228a6 100644 --- a/net/base/host_resolver.cc +++ b/net/base/host_resolver.cc @@ -4,8 +4,31 @@ #include "net/base/host_resolver.h" +#include "net/base/host_cache.h" +#include "net/base/host_resolver_impl.h" +#include "net/dns/dns_client.h" +#include "net/dns/dns_config_service.h" + namespace net { +namespace { + +// Maximum of 6 concurrent resolver threads (excluding retries). +// Some routers (or resolvers) appear to start to provide host-not-found if +// too many simultaneous resolutions are pending. This number needs to be +// further optimized, but 8 is what FF currently does. We found some routers +// that limit this to 6, so we're temporarily holding it at that level. +const size_t kDefaultMaxProcTasks = 6u; + +} // namespace + +HostResolver::Options::Options() + : max_concurrent_resolves(kDefaultParallelism), + max_retry_attempts(kDefaultRetryAttempts), + enable_caching(true), + enable_async(false) { +} + HostResolver::RequestInfo::RequestInfo(const HostPortPair& host_port_pair) : host_port_pair_(host_port_pair), address_family_(ADDRESS_FAMILY_UNSPECIFIED), @@ -33,6 +56,41 @@ base::Value* HostResolver::GetDnsConfigAsValue() const { return NULL; } +// static +scoped_ptr<HostResolver> +HostResolver::CreateSystemResolver(const Options& options, NetLog* net_log) { + size_t max_concurrent_resolves = options.max_concurrent_resolves; + if (max_concurrent_resolves == kDefaultParallelism) + max_concurrent_resolves = kDefaultMaxProcTasks; + + scoped_ptr<HostCache> cache; + if (options.enable_caching) + cache = HostCache::CreateDefaultCache(); + scoped_ptr<DnsClient> dns_client; + if (options.enable_async) { +#if !defined(ENABLE_BUILT_IN_DNS) + NOTREACHED(); + return scoped_ptr<HostResolver>(); +#else + dns_client = DnsClient::CreateClient(net_log); +#endif + } + + return scoped_ptr<HostResolver>(new HostResolverImpl( + cache.Pass(), + PrioritizedDispatcher::Limits(NUM_PRIORITIES, + max_concurrent_resolves), + HostResolverImpl::ProcTaskParams(NULL, options.max_retry_attempts), + dns_client.Pass(), + net_log)); +} + +// static +scoped_ptr<HostResolver> +HostResolver::CreateDefaultResolver(NetLog* net_log) { + return CreateSystemResolver(Options(), net_log); +} + HostResolver::HostResolver() { } diff --git a/net/base/host_resolver.h b/net/base/host_resolver.h index 58a5044..367a01a 100644 --- a/net/base/host_resolver.h +++ b/net/base/host_resolver.h @@ -7,6 +7,7 @@ #include <string> +#include "base/memory/scoped_ptr.h" #include "net/base/address_family.h" #include "net/base/completion_callback.h" #include "net/base/host_port_pair.h" @@ -37,6 +38,23 @@ class NetLog; // goes out of scope). class NET_EXPORT HostResolver { public: + // |max_concurrent_resolves| is how many resolve requests will be allowed to + // run in parallel. Pass HostResolver::kDefaultParallelism to choose a + // default value. + // |max_retry_attempts| is the maximum number of times we will retry for host + // resolution. Pass HostResolver::kDefaultRetryAttempts to choose a default + // value. + // |enable_caching| controls whether a HostCache is used. + // |enable_async| controls whether a DnsClient is used. + struct NET_EXPORT Options { + Options(); + + size_t max_concurrent_resolves; + size_t max_retry_attempts; + bool enable_caching; + bool enable_async; + }; + // The parameters for doing a Resolve(). A hostname and port are required, // the rest are optional (and have reasonable defaults). class NET_EXPORT RequestInfo { @@ -95,14 +113,13 @@ class NET_EXPORT HostResolver { // Opaque type used to cancel a request. typedef void* RequestHandle; - // This value can be passed into CreateSystemHostResolver as the + // This value can be passed into CreateSystemResolver as the // |max_concurrent_resolves| parameter. It will select a default level of // concurrency. static const size_t kDefaultParallelism = 0; - // This value can be passed into CreateSystemHostResolver as the - // |max_retry_attempts| parameter. This is the maximum number of times we - // will retry for host resolution. + // This value can be passed into CreateSystemResolver as the + // |max_retry_attempts| parameter. static const size_t kDefaultRetryAttempts = -1; // If any completion callbacks are pending when the resolver is destroyed, @@ -168,6 +185,16 @@ class NET_EXPORT HostResolver { // ownership of the returned Value. virtual base::Value* GetDnsConfigAsValue() const; + // Creates a HostResolver implementation that queries the underlying system. + // (Except if a unit-test has changed the global HostResolverProc using + // ScopedHostResolverProc to intercept requests to the system). + static scoped_ptr<HostResolver> CreateSystemResolver( + const Options& options, + NetLog* net_log); + + // As above, but uses default parameters. + static scoped_ptr<HostResolver> CreateDefaultResolver(NetLog* net_log); + protected: HostResolver(); @@ -175,37 +202,6 @@ class NET_EXPORT HostResolver { DISALLOW_COPY_AND_ASSIGN(HostResolver); }; -// Creates a HostResolver implementation that queries the underlying system. -// (Except if a unit-test has changed the global HostResolverProc using -// ScopedHostResolverProc to intercept requests to the system). -// |max_concurrent_resolves| is how many resolve requests will be allowed to -// run in parallel. Pass HostResolver::kDefaultParallelism to choose a -// default value. -// |max_retry_attempts| is the maximum number of times we will retry for host -// resolution. Pass HostResolver::kDefaultRetryAttempts to choose a default -// value. -// The created HostResolver uses an instance of DnsConfigService to retrieve -// system DNS configuration. -// This resolver should not be used in test context. Instead, use -// MockHostResolver from net/base/mock_host_resolver.h. -NET_EXPORT HostResolver* CreateSystemHostResolver( - size_t max_concurrent_resolves, - size_t max_retry_attempts, - NetLog* net_log); - -// As above, but the created HostResolver does not use a cache. -NET_EXPORT HostResolver* CreateNonCachingSystemHostResolver( - size_t max_concurrent_resolves, - size_t max_retry_attempts, - NetLog* net_log); - -// As above, but the HostResolver will use the asynchronous DNS client in -// DnsTransaction, which will be configured using DnsConfigService to match -// the system DNS settings. If the client fails, the resolver falls back to -// the global HostResolverProc. -NET_EXPORT HostResolver* CreateAsyncHostResolver(size_t max_concurrent_resolves, - size_t max_retry_attempts, - NetLog* net_log); } // namespace net #endif // NET_BASE_HOST_RESOLVER_H_ diff --git a/net/base/host_resolver_impl.cc b/net/base/host_resolver_impl.cc index 7f785b2..16074b8 100644 --- a/net/base/host_resolver_impl.cc +++ b/net/base/host_resolver_impl.cc @@ -63,13 +63,6 @@ const unsigned kCacheEntryTTLSeconds = 60; // Default TTL for unsuccessful resolutions with ProcTask. const unsigned kNegativeCacheEntryTTLSeconds = 0; -// Maximum of 6 concurrent resolver threads (excluding retries). -// Some routers (or resolvers) appear to start to provide host-not-found if -// too many simultaneous resolutions are pending. This number needs to be -// further optimized, but 8 is what FF currently does. We found some routers -// that limit this to 6, so we're temporarily holding it at that level. -static const size_t kDefaultMaxProcTasks = 6u; - // We use a separate histogram name for each platform to facilitate the // display of error codes by their symbolic name (since each platform has // different mappings). @@ -409,69 +402,7 @@ class PriorityTracker { size_t counts_[NUM_PRIORITIES]; }; -//----------------------------------------------------------------------------- - -HostResolver* CreateHostResolver(size_t max_concurrent_resolves, - size_t max_retry_attempts, - HostCache* cache, - scoped_ptr<DnsClient> dns_client, - NetLog* net_log) { - if (max_concurrent_resolves == HostResolver::kDefaultParallelism) - max_concurrent_resolves = kDefaultMaxProcTasks; - - // TODO(szym): Add experiments with reserved slots for higher priority - // requests. - - PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, max_concurrent_resolves); - - HostResolverImpl* resolver = new HostResolverImpl( - cache, - limits, - HostResolverImpl::ProcTaskParams(NULL, max_retry_attempts), - dns_client.Pass(), - net_log); - - return resolver; -} - -} // anonymous namespace - -//----------------------------------------------------------------------------- - -HostResolver* CreateSystemHostResolver(size_t max_concurrent_resolves, - size_t max_retry_attempts, - NetLog* net_log) { - return CreateHostResolver(max_concurrent_resolves, - max_retry_attempts, - HostCache::CreateDefaultCache(), - scoped_ptr<DnsClient>(NULL), - net_log); -} - -HostResolver* CreateNonCachingSystemHostResolver(size_t max_concurrent_resolves, - size_t max_retry_attempts, - NetLog* net_log) { - return CreateHostResolver(max_concurrent_resolves, - max_retry_attempts, - NULL, - scoped_ptr<DnsClient>(NULL), - net_log); -} - -HostResolver* CreateAsyncHostResolver(size_t max_concurrent_resolves, - size_t max_retry_attempts, - NetLog* net_log) { -#if !defined(ENABLE_BUILT_IN_DNS) - NOTREACHED(); - return NULL; -#else - return CreateHostResolver(max_concurrent_resolves, - max_retry_attempts, - HostCache::CreateDefaultCache(), - DnsClient::CreateClient(net_log), - net_log); -#endif // !defined(ENABLE_BUILT_IN_DNS) -} +} // namespace //----------------------------------------------------------------------------- @@ -1675,12 +1606,12 @@ HostResolverImpl::ProcTaskParams::ProcTaskParams( HostResolverImpl::ProcTaskParams::~ProcTaskParams() {} HostResolverImpl::HostResolverImpl( - HostCache* cache, + scoped_ptr<HostCache> cache, const PrioritizedDispatcher::Limits& job_limits, const ProcTaskParams& proc_params, scoped_ptr<DnsClient> dns_client, NetLog* net_log) - : cache_(cache), + : cache_(cache.Pass()), dispatcher_(job_limits), max_queued_jobs_(job_limits.total_jobs * 100u), proc_params_(proc_params), diff --git a/net/base/host_resolver_impl.h b/net/base/host_resolver_impl.h index 8d0f781..1bc9b69 100644 --- a/net/base/host_resolver_impl.h +++ b/net/base/host_resolver_impl.h @@ -115,7 +115,7 @@ class NET_EXPORT HostResolverImpl // // |net_log| must remain valid for the life of the HostResolverImpl. // TODO(szym): change to scoped_ptr<HostCache>. - HostResolverImpl(HostCache* cache, + HostResolverImpl(scoped_ptr<HostCache> cache, const PrioritizedDispatcher::Limits& job_limits, const ProcTaskParams& proc_params, scoped_ptr<DnsClient> dns_client, diff --git a/net/base/host_resolver_impl_unittest.cc b/net/base/host_resolver_impl_unittest.cc index 527e91b..0bad1d3 100644 --- a/net/base/host_resolver_impl_unittest.cc +++ b/net/base/host_resolver_impl_unittest.cc @@ -435,7 +435,7 @@ class HostResolverImplTest : public testing::Test { HostCache::CreateDefaultCache(), DefaultLimits(), DefaultParams(proc_), - scoped_ptr<DnsClient>(NULL), + scoped_ptr<DnsClient>(), NULL)); } @@ -449,7 +449,7 @@ class HostResolverImplTest : public testing::Test { HostCache::CreateDefaultCache(), limits, params, - scoped_ptr<DnsClient>(NULL), + scoped_ptr<DnsClient>(), NULL)); } @@ -758,10 +758,10 @@ TEST_F(HostResolverImplTest, StartWithinCallback) { // Turn off caching for this host resolver. resolver_.reset(new HostResolverImpl( - NULL, + scoped_ptr<HostCache>(), DefaultLimits(), DefaultParams(proc_), - scoped_ptr<DnsClient>(NULL), + scoped_ptr<DnsClient>(), NULL)); for (size_t i = 0; i < 4; ++i) { @@ -1198,7 +1198,7 @@ TEST_F(HostResolverImplTest, MultipleAttempts) { new HostResolverImpl(HostCache::CreateDefaultCache(), DefaultLimits(), params, - scoped_ptr<DnsClient>(NULL), + scoped_ptr<DnsClient>(), NULL)); // Resolve "host1". diff --git a/net/base/mapped_host_resolver.cc b/net/base/mapped_host_resolver.cc index 020861c..dce9558 100644 --- a/net/base/mapped_host_resolver.cc +++ b/net/base/mapped_host_resolver.cc @@ -12,8 +12,8 @@ namespace net { -MappedHostResolver::MappedHostResolver(HostResolver* impl) - : impl_(impl) { +MappedHostResolver::MappedHostResolver(scoped_ptr<HostResolver> impl) + : impl_(impl.Pass()) { } MappedHostResolver::~MappedHostResolver() { diff --git a/net/base/mapped_host_resolver.h b/net/base/mapped_host_resolver.h index d1edf45..3073c97 100644 --- a/net/base/mapped_host_resolver.h +++ b/net/base/mapped_host_resolver.h @@ -21,8 +21,8 @@ namespace net { class NET_EXPORT MappedHostResolver : public HostResolver { public: // Creates a MappedHostResolver that forwards all of its requests through - // |impl|. It takes ownership of |impl|. - explicit MappedHostResolver(HostResolver* impl); + // |impl|. + explicit MappedHostResolver(scoped_ptr<HostResolver> impl); virtual ~MappedHostResolver(); // Adds a rule to this mapper. The format of the rule can be one of: diff --git a/net/base/mapped_host_resolver_unittest.cc b/net/base/mapped_host_resolver_unittest.cc index 5ea95c0..7ff2e6ec 100644 --- a/net/base/mapped_host_resolver_unittest.cc +++ b/net/base/mapped_host_resolver_unittest.cc @@ -24,7 +24,7 @@ std::string FirstAddress(const AddressList& address_list) { TEST(MappedHostResolverTest, Inclusion) { // Create a mock host resolver, with specific hostname to IP mappings. - MockHostResolver* resolver_impl(new MockHostResolver()); + scoped_ptr<MockHostResolver> resolver_impl(new MockHostResolver()); resolver_impl->rules()->AddSimulatedFailure("*google.com"); resolver_impl->rules()->AddRule("baz.com", "192.168.1.5"); resolver_impl->rules()->AddRule("foo.com", "192.168.1.8"); @@ -32,7 +32,7 @@ TEST(MappedHostResolverTest, Inclusion) { // Create a remapped resolver that uses |resolver_impl|. scoped_ptr<MappedHostResolver> resolver( - new MappedHostResolver(resolver_impl)); + new MappedHostResolver(resolver_impl.PassAs<HostResolver>())); int rv; AddressList address_list; @@ -88,13 +88,13 @@ TEST(MappedHostResolverTest, Inclusion) { // Tests that exclusions are respected. TEST(MappedHostResolverTest, Exclusion) { // Create a mock host resolver, with specific hostname to IP mappings. - MockHostResolver* resolver_impl(new MockHostResolver()); + scoped_ptr<MockHostResolver> resolver_impl(new MockHostResolver()); resolver_impl->rules()->AddRule("baz", "192.168.1.5"); resolver_impl->rules()->AddRule("www.google.com", "192.168.1.3"); // Create a remapped resolver that uses |resolver_impl|. scoped_ptr<MappedHostResolver> resolver( - new MappedHostResolver(resolver_impl)); + new MappedHostResolver(resolver_impl.PassAs<HostResolver>())); int rv; AddressList address_list; @@ -129,13 +129,13 @@ TEST(MappedHostResolverTest, Exclusion) { TEST(MappedHostResolverTest, SetRulesFromString) { // Create a mock host resolver, with specific hostname to IP mappings. - MockHostResolver* resolver_impl(new MockHostResolver()); + scoped_ptr<MockHostResolver> resolver_impl(new MockHostResolver()); resolver_impl->rules()->AddRule("baz", "192.168.1.7"); resolver_impl->rules()->AddRule("bar", "192.168.1.9"); // Create a remapped resolver that uses |resolver_impl|. scoped_ptr<MappedHostResolver> resolver( - new MappedHostResolver(resolver_impl)); + new MappedHostResolver(resolver_impl.PassAs<HostResolver>())); int rv; AddressList address_list; @@ -167,7 +167,8 @@ TEST(MappedHostResolverTest, SetRulesFromString) { // Parsing bad rules should silently discard the rule (and never crash). TEST(MappedHostResolverTest, ParseInvalidRules) { - scoped_ptr<MappedHostResolver> resolver(new MappedHostResolver(NULL)); + scoped_ptr<MappedHostResolver> resolver( + new MappedHostResolver(scoped_ptr<HostResolver>())); EXPECT_FALSE(resolver->AddRuleFromString("xyz")); EXPECT_FALSE(resolver->AddRuleFromString("")); diff --git a/net/curvecp/test_client.cc b/net/curvecp/test_client.cc index f5ad5ca..67bd7b8 100644 --- a/net/curvecp/test_client.cc +++ b/net/curvecp/test_client.cc @@ -46,7 +46,7 @@ bool TestClient::Start(const HostPortPair& server_host_port_pair, bytes_to_read_ = bytes_to_send_ = bytes_to_send; scoped_ptr<HostResolver> system_host_resolver( - CreateSystemHostResolver(1, 0, NULL)); + HostResolver::CreateDefaultResolver(NULL)); SingleRequestHostResolver host_resolver(system_host_resolver.get()); HostResolver::RequestInfo request(server_host_port_pair); AddressList addresses; diff --git a/net/proxy/proxy_script_fetcher_impl_unittest.cc b/net/proxy/proxy_script_fetcher_impl_unittest.cc index c12f829..39d223c 100644 --- a/net/proxy/proxy_script_fetcher_impl_unittest.cc +++ b/net/proxy/proxy_script_fetcher_impl_unittest.cc @@ -73,7 +73,7 @@ class RequestContext : public URLRequestContext { public: RequestContext() : ALLOW_THIS_IN_INITIALIZER_LIST(storage_(this)) { ProxyConfig no_proxy; - storage_.set_host_resolver(new MockHostResolver); + storage_.set_host_resolver(scoped_ptr<HostResolver>(new MockHostResolver)); storage_.set_cert_verifier(new MockCertVerifier); storage_.set_proxy_service(ProxyService::CreateFixed(no_proxy)); storage_.set_ssl_config_service(new SSLConfigServiceDefaults); diff --git a/net/spdy/spdy_test_util_spdy2.cc b/net/spdy/spdy_test_util_spdy2.cc index e5cbac2..476d73c 100644 --- a/net/spdy/spdy_test_util_spdy2.cc +++ b/net/spdy/spdy_test_util_spdy2.cc @@ -968,7 +968,7 @@ HttpNetworkSession* SpdySessionDependencies::SpdyCreateSessionDeterministic( SpdyURLRequestContext::SpdyURLRequestContext() : ALLOW_THIS_IN_INITIALIZER_LIST(storage_(this)) { - storage_.set_host_resolver(new MockHostResolver()); + storage_.set_host_resolver(scoped_ptr<HostResolver>(new MockHostResolver)); storage_.set_cert_verifier(new MockCertVerifier); storage_.set_proxy_service(ProxyService::CreateDirect()); storage_.set_ssl_config_service(new SSLConfigServiceDefaults); diff --git a/net/spdy/spdy_test_util_spdy3.cc b/net/spdy/spdy_test_util_spdy3.cc index e84ccdf..508a74b 100644 --- a/net/spdy/spdy_test_util_spdy3.cc +++ b/net/spdy/spdy_test_util_spdy3.cc @@ -1003,7 +1003,7 @@ HttpNetworkSession* SpdySessionDependencies::SpdyCreateSessionDeterministic( SpdyURLRequestContext::SpdyURLRequestContext() : ALLOW_THIS_IN_INITIALIZER_LIST(storage_(this)) { - storage_.set_host_resolver(new MockHostResolver()); + storage_.set_host_resolver(scoped_ptr<HostResolver>(new MockHostResolver)); storage_.set_cert_verifier(new MockCertVerifier); storage_.set_proxy_service(ProxyService::CreateDirect()); storage_.set_ssl_config_service(new SSLConfigServiceDefaults); diff --git a/net/test/base_test_server.cc b/net/test/base_test_server.cc index 7ca7f7f..d13d57c 100644 --- a/net/test/base_test_server.cc +++ b/net/test/base_test_server.cc @@ -168,10 +168,7 @@ std::string BaseTestServer::GetScheme() const { bool BaseTestServer::GetAddressList(AddressList* address_list) const { DCHECK(address_list); - scoped_ptr<HostResolver> resolver( - CreateSystemHostResolver(HostResolver::kDefaultParallelism, - HostResolver::kDefaultRetryAttempts, - NULL)); + scoped_ptr<HostResolver> resolver(HostResolver::CreateDefaultResolver(NULL)); HostResolver::RequestInfo info(host_port_pair_); TestCompletionCallback callback; int rv = resolver->Resolve(info, address_list, callback.callback(), NULL, diff --git a/net/tools/fetch/fetch_client.cc b/net/tools/fetch/fetch_client.cc index b69b2c9..cfb86ab 100644 --- a/net/tools/fetch/fetch_client.cc +++ b/net/tools/fetch/fetch_client.cc @@ -141,10 +141,7 @@ int main(int argc, char** argv) { MessageLoop loop(MessageLoop::TYPE_IO); scoped_ptr<net::HostResolver> host_resolver( - net::CreateSystemHostResolver(net::HostResolver::kDefaultParallelism, - net::HostResolver::kDefaultRetryAttempts, - NULL)); - + net::HostResolver::CreateDefaultResolver(NULL)); scoped_ptr<net::CertVerifier> cert_verifier( net::CertVerifier::CreateDefault()); scoped_ptr<net::ProxyService> proxy_service( diff --git a/net/url_request/url_request_context_builder.cc b/net/url_request/url_request_context_builder.cc index 8c0eea3..6e0cc2e 100644 --- a/net/url_request/url_request_context_builder.cc +++ b/net/url_request/url_request_context_builder.cc @@ -171,11 +171,6 @@ class BasicURLRequestContext : public URLRequestContext { } // namespace -URLRequestContextBuilder::HostResolverParams::HostResolverParams() - : parallelism(HostResolver::kDefaultParallelism), - retry_attempts(HostResolver::kDefaultRetryAttempts) {} -URLRequestContextBuilder::HostResolverParams::~HostResolverParams() {} - URLRequestContextBuilder::HttpCacheParams::HttpCacheParams() : type(IN_MEMORY), max_size(0) {} @@ -213,14 +208,11 @@ URLRequestContext* URLRequestContextBuilder::Build() { 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(); @@ -242,14 +234,15 @@ URLRequestContext* URLRequestContextBuilder::Build() { 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(); diff --git a/net/url_request/url_request_context_builder.h b/net/url_request/url_request_context_builder.h index ddbca53..34a9bf8 100644 --- a/net/url_request/url_request_context_builder.h +++ b/net/url_request/url_request_context_builder.h @@ -31,18 +31,6 @@ class URLRequestContext; class NET_EXPORT URLRequestContextBuilder { public: - struct NET_EXPORT HostResolverParams { - HostResolverParams(); - ~HostResolverParams(); - - // The limit on the number of parallel host resolutions. - size_t parallelism; - - // When the host resolution is taking too long, we'll retry this many times, - // in a backing off manner. - size_t retry_attempts; - }; - struct NET_EXPORT HttpCacheParams { enum Type { IN_MEMORY, @@ -89,12 +77,6 @@ class NET_EXPORT URLRequestContextBuilder { user_agent_ = user_agent; } - // Allows for overriding the default HostResolver params. - void set_host_resolver_params( - const HostResolverParams& host_resolver_params) { - host_resolver_params_ = host_resolver_params; - } - // By default it's disabled. void set_ftp_enabled(bool enable) { ftp_enabled_ = enable; @@ -115,7 +97,6 @@ class NET_EXPORT URLRequestContextBuilder { private: std::string user_agent_; bool ftp_enabled_; - HostResolverParams host_resolver_params_; bool http_cache_enabled_; HttpCacheParams http_cache_params_; HttpNetworkSessionParams http_network_session_params_; diff --git a/net/url_request/url_request_context_storage.cc b/net/url_request/url_request_context_storage.cc index 2a75db2..12ea031 100644 --- a/net/url_request/url_request_context_storage.cc +++ b/net/url_request/url_request_context_storage.cc @@ -35,9 +35,10 @@ void URLRequestContextStorage::set_net_log(NetLog* net_log) { net_log_.reset(net_log); } -void URLRequestContextStorage::set_host_resolver(HostResolver* host_resolver) { - context_->set_host_resolver(host_resolver); - host_resolver_.reset(host_resolver); +void URLRequestContextStorage::set_host_resolver( + scoped_ptr<HostResolver> host_resolver) { + context_->set_host_resolver(host_resolver.get()); + host_resolver_ = host_resolver.Pass(); } void URLRequestContextStorage::set_cert_verifier(CertVerifier* cert_verifier) { diff --git a/net/url_request/url_request_context_storage.h b/net/url_request/url_request_context_storage.h index f792d8e..bc040b2 100644 --- a/net/url_request/url_request_context_storage.h +++ b/net/url_request/url_request_context_storage.h @@ -41,10 +41,10 @@ class NET_EXPORT URLRequestContextStorage { ~URLRequestContextStorage(); // These setters will set both the member variables and call the setter on the - // URLRequestContext object. + // URLRequestContext object. In all cases, ownership is passed to |this|. void set_net_log(NetLog* net_log); - void set_host_resolver(HostResolver* host_resolver); + void set_host_resolver(scoped_ptr<HostResolver> host_resolver); void set_cert_verifier(CertVerifier* cert_verifier); void set_server_bound_cert_service( ServerBoundCertService* server_bound_cert_service); diff --git a/net/url_request/url_request_test_util.cc b/net/url_request/url_request_test_util.cc index 5bf0883..33ea742 100644 --- a/net/url_request/url_request_test_util.cc +++ b/net/url_request/url_request_test_util.cc @@ -61,7 +61,8 @@ void TestURLRequestContext::Init() { initialized_ = true; if (!host_resolver()) - context_storage_.set_host_resolver(new net::MockCachingHostResolver()); + context_storage_.set_host_resolver( + scoped_ptr<net::HostResolver>(new net::MockCachingHostResolver())); if (!proxy_service()) context_storage_.set_proxy_service(net::ProxyService::CreateDirect()); if (!cert_verifier()) diff --git a/remoting/host/url_request_context.cc b/remoting/host/url_request_context.cc index 83ba3e9..6563939 100644 --- a/remoting/host/url_request_context.cc +++ b/remoting/host/url_request_context.cc @@ -83,9 +83,7 @@ URLRequestContext::URLRequestContext( : ALLOW_THIS_IN_INITIALIZER_LIST(storage_(this)) { scoped_ptr<VlogNetLog> net_log(new VlogNetLog()); storage_.set_host_resolver( - net::CreateSystemHostResolver(net::HostResolver::kDefaultParallelism, - net::HostResolver::kDefaultRetryAttempts, - net_log.get())); + net::HostResolver::CreateDefaultResolver(net_log.get())); storage_.set_proxy_service(net::ProxyService::CreateUsingSystemProxyResolver( proxy_config_service.release(), 0u, net_log.get())); storage_.set_cert_verifier(net::CertVerifier::CreateDefault()); diff --git a/sync/tools/sync_client.cc b/sync/tools/sync_client.cc index 01da983..96be8a3 100644 --- a/sync/tools/sync_client.cc +++ b/sync/tools/sync_client.cc @@ -105,10 +105,7 @@ class MyTestURLRequestContext : public TestURLRequestContext { public: MyTestURLRequestContext() : TestURLRequestContext(true) { context_storage_.set_host_resolver( - net::CreateSystemHostResolver( - net::HostResolver::kDefaultParallelism, - net::HostResolver::kDefaultRetryAttempts, - NULL)); + net::HostResolver::CreateDefaultResolver(NULL)); context_storage_.set_transport_security_state( new net::TransportSecurityState()); Init(); diff --git a/sync/tools/sync_listen_notifications.cc b/sync/tools/sync_listen_notifications.cc index 73d78e3..d8cc213 100644 --- a/sync/tools/sync_listen_notifications.cc +++ b/sync/tools/sync_listen_notifications.cc @@ -118,10 +118,7 @@ class MyTestURLRequestContext : public TestURLRequestContext { public: MyTestURLRequestContext() : TestURLRequestContext(true) { context_storage_.set_host_resolver( - net::CreateSystemHostResolver( - net::HostResolver::kDefaultParallelism, - net::HostResolver::kDefaultRetryAttempts, - NULL)); + net::HostResolver::CreateDefaultResolver(NULL)); context_storage_.set_transport_security_state( new net::TransportSecurityState()); Init(); diff --git a/webkit/tools/test_shell/test_shell_request_context.cc b/webkit/tools/test_shell/test_shell_request_context.cc index 8fef578..0ab9839 100644 --- a/webkit/tools/test_shell/test_shell_request_context.cc +++ b/webkit/tools/test_shell/test_shell_request_context.cc @@ -77,10 +77,7 @@ void TestShellRequestContext::Init( net::ProxyService::CreateSystemProxyConfigService( base::ThreadTaskRunnerHandle::Get(), NULL)); #endif - storage_.set_host_resolver( - net::CreateSystemHostResolver(net::HostResolver::kDefaultParallelism, - net::HostResolver::kDefaultRetryAttempts, - NULL)); + storage_.set_host_resolver(net::HostResolver::CreateDefaultResolver(NULL)); storage_.set_cert_verifier(net::CertVerifier::CreateDefault()); storage_.set_proxy_service(net::ProxyService::CreateUsingSystemProxyResolver( proxy_config_service.release(), 0, NULL)); |