From 9ded7fe4958b9449544392133e101200bb009d62 Mon Sep 17 00:00:00 2001 From: Eric Orth Date: Fri, 22 Mar 2019 16:32:38 +0000 Subject: [PATCH] Prepare for per-context resolvers with new creation methods Rewrote the standard HostResolver::Create...Resolver() methods. There are now two general methods, one that takes a shared HostResolverManager pointer, and one that creates a "standalone" resolver, matching current behavior. Took the opportunity to combine the behaviors of CreateDefault and CreateSystem since C++11 default args are a cleaner way to set default options (at least for static methods like these). Added TODOs to all the non-test and non-standalone tools that will need to be converted to calling the creation with shared manager, but such conversions are left to subsequent CLs. TBR=seantopping@chromium.org,eugenebut@chromium.org,dimich@chromium.org,mmenke@chromium.org Bug: 934402 Change-Id: I126b61db55b61ebd75b7b6f526b31ef0f0a02404 Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1531391 Commit-Queue: Eric Orth Reviewed-by: Paul Jensen Cr-Commit-Position: refs/heads/master@{#643385} --- chrome/browser/io_thread.cc | 6 ++- .../browser/url_request_context_factory.cc | 4 +- components/cronet/ios/cronet_environment.mm | 4 +- .../cronet/stale_host_resolver_unittest.cc | 2 +- .../cronet/url_request_context_config.cc | 6 ++- google_apis/gcm/tools/mcs_probe.cc | 5 +- ios/components/io_thread/ios_io_thread.mm | 5 +- .../shell/shell_url_request_context_getter.mm | 2 +- .../web_view_url_request_context_getter.mm | 2 +- net/dns/context_host_resolver.cc | 51 +++++++++++------- net/dns/context_host_resolver.h | 15 ++++-- net/dns/host_resolver.cc | 54 ++++++++++++------- net/dns/host_resolver.h | 48 ++++++++++------- ...network_quality_estimator_util_unittest.cc | 3 +- net/socket/socks_client_socket_unittest.cc | 2 +- .../spawned_test_server/base_test_server.cc | 2 +- net/tools/quic/synchronous_host_resolver.cc | 2 +- .../http_with_dns_over_https_unittest.cc | 3 +- .../url_request_context_builder.cc | 8 ++- net/url_request/url_request_context_builder.h | 3 +- services/network/host_resolver_unittest.cc | 22 ++++---- services/network/network_context.cc | 5 +- services/network/network_context_unittest.cc | 14 ++++- services/network/network_service.cc | 6 ++- 24 files changed, 171 insertions(+), 103 deletions(-) diff --git a/chrome/browser/io_thread.cc b/chrome/browser/io_thread.cc index 38dc13a304f344..0ec363046fc274 100644 --- a/chrome/browser/io_thread.cc +++ b/chrome/browser/io_thread.cc @@ -153,8 +153,10 @@ std::unique_ptr CreateGlobalHostResolver( std::string host_mapping_rules = command_line.GetSwitchValueASCII(network::switches::kHostResolverRules); - return net::HostResolver::CreateSystemResolver(net::HostResolver::Options(), - net_log, host_mapping_rules); + // TODO(crbug.com/934402): Use a shared HostResolverManager instead of a + // global HostResolver. + return net::HostResolver::CreateStandaloneResolver( + net_log, net::HostResolver::Options(), host_mapping_rules); } } // namespace diff --git a/chromecast/browser/url_request_context_factory.cc b/chromecast/browser/url_request_context_factory.cc index be5491ae2420ae..bd76b7ebdab23c 100644 --- a/chromecast/browser/url_request_context_factory.cc +++ b/chromecast/browser/url_request_context_factory.cc @@ -233,7 +233,9 @@ void URLRequestContextFactory::InitializeSystemContextDependencies() { if (system_dependencies_initialized_) return; - host_resolver_ = net::HostResolver::CreateDefaultResolver(NULL); + // TODO(crbug.com/934402): Use a shared HostResolverManager instead of a + // global HostResolver. + host_resolver_ = net::HostResolver::CreateStandaloneResolver(nullptr); cert_verifier_ = net::CertVerifier::CreateDefault(); ssl_config_service_.reset(new net::SSLConfigServiceDefaults); transport_security_state_.reset(new net::TransportSecurityState()); diff --git a/components/cronet/ios/cronet_environment.mm b/components/cronet/ios/cronet_environment.mm index ea6839135f5c3d..d3a97e40f7ee63 100644 --- a/components/cronet/ios/cronet_environment.mm +++ b/components/cronet/ios/cronet_environment.mm @@ -359,9 +359,11 @@ bool IsNetLogPathValid(const base::FilePath& path) { effective_experimental_options_ = std::move(config->effective_experimental_options); + // TODO(crbug.com/934402): Use a shared HostResolverManager instead of a + // global HostResolver. std::unique_ptr mapped_host_resolver( new net::MappedHostResolver( - net::HostResolver::CreateDefaultResolver(nullptr))); + net::HostResolver::CreateStandaloneResolver(nullptr))); if (!config->storage_path.empty()) { cronet_prefs_manager_ = std::make_unique( diff --git a/components/cronet/stale_host_resolver_unittest.cc b/components/cronet/stale_host_resolver_unittest.cc index 74db118ac90fbc..8287e14f95b48f 100644 --- a/components/cronet/stale_host_resolver_unittest.cc +++ b/components/cronet/stale_host_resolver_unittest.cc @@ -176,7 +176,7 @@ class StaleHostResolverTest : public testing::Test { CreateMockInnerResolverWithDnsClient( std::unique_ptr dns_client) { std::unique_ptr inner_resolver( - net::HostResolver::CreateDefaultResolverImpl(nullptr)); + net::HostResolver::CreateStandaloneContextResolver(nullptr)); net::ProcTaskParams proc_params(mock_proc_.get(), 1u); inner_resolver->SetProcParamsForTesting(proc_params); diff --git a/components/cronet/url_request_context_config.cc b/components/cronet/url_request_context_config.cc index ccbfd7f966f8ce..aebd97a1988a60 100644 --- a/components/cronet/url_request_context_config.cc +++ b/components/cronet/url_request_context_config.cc @@ -672,13 +672,15 @@ void URLRequestContextConfig::ParseAndSetExperimentalOptions( disable_ipv6_on_wifi) { CHECK(net_log) << "All DNS-related experiments require NetLog."; std::unique_ptr host_resolver; + // TODO(crbug.com/934402): Consider using a shared HostResolverManager for + // Cronet HostResolvers. if (stale_dns_enable) { DCHECK(!disable_ipv6_on_wifi); host_resolver.reset(new StaleHostResolver( - net::HostResolver::CreateDefaultResolverImpl(net_log), + net::HostResolver::CreateStandaloneContextResolver(net_log), stale_dns_options)); } else { - host_resolver = net::HostResolver::CreateDefaultResolver(net_log); + host_resolver = net::HostResolver::CreateStandaloneResolver(net_log); } if (disable_ipv6_on_wifi) host_resolver->SetNoIPv6OnWifi(true); diff --git a/google_apis/gcm/tools/mcs_probe.cc b/google_apis/gcm/tools/mcs_probe.cc index d28951a277aa92..99794e4b9a08e3 100644 --- a/google_apis/gcm/tools/mcs_probe.cc +++ b/google_apis/gcm/tools/mcs_probe.cc @@ -212,7 +212,6 @@ class MCSProbe { std::unique_ptr url_request_context_; net::NetLog net_log_; std::unique_ptr logger_; - std::unique_ptr host_resolver_; MCSProbeAuthPreferences http_auth_preferences_; std::unique_ptr http_auth_handler_factory_; @@ -339,13 +338,13 @@ void MCSProbe::InitializeNetworkState() { logger_->StartObserving(&net_log_, capture_mode); } - host_resolver_ = net::HostResolver::CreateDefaultResolver(&net_log_); http_auth_handler_factory_ = net::HttpAuthHandlerRegistryFactory::Create( &http_auth_preferences_, std::vector{net::kBasicAuthScheme}); net::URLRequestContextBuilder builder; builder.set_net_log(&net_log_); - builder.set_shared_host_resolver(host_resolver_.get()); + builder.set_host_resolver( + net::HostResolver::CreateStandaloneResolver(&net_log_)); builder.set_shared_http_auth_handler_factory( http_auth_handler_factory_.get()); builder.set_proxy_resolution_service( diff --git a/ios/components/io_thread/ios_io_thread.mm b/ios/components/io_thread/ios_io_thread.mm index 2e85b7daf00eee..6214e2aaa07d63 100644 --- a/ios/components/io_thread/ios_io_thread.mm +++ b/ios/components/io_thread/ios_io_thread.mm @@ -99,9 +99,10 @@ net::NetLog* net_log) { TRACE_EVENT0("startup", "IOSIOThread::CreateGlobalHostResolver"); + // TODO(crbug.com/934402): Use a shared HostResolverManager instead of a + // single global HostResolver for iOS. std::unique_ptr global_host_resolver = - net::HostResolver::CreateSystemResolver(net::HostResolver::Options(), - net_log); + net::HostResolver::CreateStandaloneResolver(net_log); return global_host_resolver; } diff --git a/ios/web/shell/shell_url_request_context_getter.mm b/ios/web/shell/shell_url_request_context_getter.mm index af9fc2648df214..e0ab2d384c1854 100644 --- a/ios/web/shell/shell_url_request_context_getter.mm +++ b/ios/web/shell/shell_url_request_context_getter.mm @@ -118,7 +118,7 @@ new net::HttpServerPropertiesImpl())); std::unique_ptr host_resolver( - net::HostResolver::CreateDefaultResolver( + net::HostResolver::CreateStandaloneResolver( url_request_context_->net_log())); storage_->set_http_auth_handler_factory( net::HttpAuthHandlerFactory::CreateDefault()); diff --git a/ios/web_view/internal/web_view_url_request_context_getter.mm b/ios/web_view/internal/web_view_url_request_context_getter.mm index 98f3bd3a1b0e03..0e6cfb0ca83a7c 100644 --- a/ios/web_view/internal/web_view_url_request_context_getter.mm +++ b/ios/web_view/internal/web_view_url_request_context_getter.mm @@ -122,7 +122,7 @@ new net::HttpServerPropertiesImpl())); std::unique_ptr host_resolver( - net::HostResolver::CreateDefaultResolver( + net::HostResolver::CreateStandaloneResolver( url_request_context_->net_log())); storage_->set_http_auth_handler_factory( net::HttpAuthHandlerFactory::CreateDefault()); diff --git a/net/dns/context_host_resolver.cc b/net/dns/context_host_resolver.cc index 7802c133a9b71f..7bf56d4d47ec11 100644 --- a/net/dns/context_host_resolver.cc +++ b/net/dns/context_host_resolver.cc @@ -6,6 +6,7 @@ #include +#include "base/logging.h" #include "base/strings/string_piece.h" #include "base/time/tick_clock.h" #include "net/dns/dns_client.h" @@ -15,94 +16,104 @@ namespace net { +ContextHostResolver::ContextHostResolver(HostResolverManager* manager) + : manager_(manager) { + DCHECK(manager_); +} + ContextHostResolver::ContextHostResolver( - std::unique_ptr impl) - : impl_(std::move(impl)) {} + std::unique_ptr owned_manager) + : manager_(owned_manager.get()), owned_manager_(std::move(owned_manager)) { + DCHECK(manager_); +} -ContextHostResolver::~ContextHostResolver() = default; +ContextHostResolver::~ContextHostResolver() { + if (owned_manager_) + DCHECK_EQ(owned_manager_.get(), manager_); +} std::unique_ptr ContextHostResolver::CreateRequest( const HostPortPair& host, const NetLogWithSource& source_net_log, const base::Optional& optional_parameters) { - return impl_->CreateRequest(host, source_net_log, optional_parameters); + return manager_->CreateRequest(host, source_net_log, optional_parameters); } std::unique_ptr ContextHostResolver::CreateMdnsListener(const HostPortPair& host, DnsQueryType query_type) { - return impl_->CreateMdnsListener(host, query_type); + return manager_->CreateMdnsListener(host, query_type); } void ContextHostResolver::SetDnsClientEnabled(bool enabled) { - impl_->SetDnsClientEnabled(enabled); + manager_->SetDnsClientEnabled(enabled); } HostCache* ContextHostResolver::GetHostCache() { - return impl_->GetHostCache(); + return manager_->GetHostCache(); } bool ContextHostResolver::HasCached(base::StringPiece hostname, HostCache::Entry::Source* source_out, HostCache::EntryStaleness* stale_out, bool* secure_out) const { - return impl_->HasCached(hostname, source_out, stale_out, secure_out); + return manager_->HasCached(hostname, source_out, stale_out, secure_out); } std::unique_ptr ContextHostResolver::GetDnsConfigAsValue() const { - return impl_->GetDnsConfigAsValue(); + return manager_->GetDnsConfigAsValue(); } void ContextHostResolver::SetNoIPv6OnWifi(bool no_ipv6_on_wifi) { - impl_->SetNoIPv6OnWifi(no_ipv6_on_wifi); + manager_->SetNoIPv6OnWifi(no_ipv6_on_wifi); } bool ContextHostResolver::GetNoIPv6OnWifi() { - return impl_->GetNoIPv6OnWifi(); + return manager_->GetNoIPv6OnWifi(); } void ContextHostResolver::SetDnsConfigOverrides( const DnsConfigOverrides& overrides) { - impl_->SetDnsConfigOverrides(overrides); + manager_->SetDnsConfigOverrides(overrides); } void ContextHostResolver::SetRequestContext( URLRequestContext* request_context) { - impl_->SetRequestContext(request_context); + manager_->SetRequestContext(request_context); } const std::vector* ContextHostResolver::GetDnsOverHttpsServersForTesting() const { - return impl_->GetDnsOverHttpsServersForTesting(); + return manager_->GetDnsOverHttpsServersForTesting(); } size_t ContextHostResolver::LastRestoredCacheSize() const { - return impl_->LastRestoredCacheSize(); + return manager_->LastRestoredCacheSize(); } size_t ContextHostResolver::CacheSize() const { - return impl_->CacheSize(); + return manager_->CacheSize(); } void ContextHostResolver::SetProcParamsForTesting( const ProcTaskParams& proc_params) { - impl_->set_proc_params_for_test(proc_params); + manager_->set_proc_params_for_test(proc_params); } void ContextHostResolver::SetDnsClientForTesting( std::unique_ptr dns_client) { - impl_->SetDnsClient(std::move(dns_client)); + manager_->SetDnsClient(std::move(dns_client)); } void ContextHostResolver::SetBaseDnsConfigForTesting( const DnsConfig& base_config) { - impl_->SetBaseDnsConfigForTesting(base_config); + manager_->SetBaseDnsConfigForTesting(base_config); } void ContextHostResolver::SetTickClockForTesting( const base::TickClock* tick_clock) { - impl_->SetTickClockForTesting(tick_clock); + manager_->SetTickClockForTesting(tick_clock); } } // namespace net diff --git a/net/dns/context_host_resolver.h b/net/dns/context_host_resolver.h index fddfaa2e564814..8bc4535032e1a6 100644 --- a/net/dns/context_host_resolver.h +++ b/net/dns/context_host_resolver.h @@ -8,6 +8,7 @@ #include #include +#include "base/macros.h" #include "net/base/net_export.h" #include "net/dns/host_resolver.h" @@ -33,8 +34,11 @@ struct ProcTaskParams; class NET_EXPORT ContextHostResolver : public HostResolver { public: // Creates a ContextHostResolver that forwards all of its requests through - // |impl|. - explicit ContextHostResolver(std::unique_ptr impl); + // |manager|. + explicit ContextHostResolver(HostResolverManager* manager); + // Same except the created resolver will own its own HostResolverManager. + explicit ContextHostResolver( + std::unique_ptr owned_manager); ~ContextHostResolver() override; // HostResolver methods: @@ -72,9 +76,10 @@ class NET_EXPORT ContextHostResolver : public HostResolver { void SetTickClockForTesting(const base::TickClock* tick_clock); private: - // TODO(crbug.com/934402): Make this a non-owned pointer to the singleton - // resolver. - std::unique_ptr impl_; + HostResolverManager* const manager_; + std::unique_ptr owned_manager_; + + DISALLOW_COPY_AND_ASSIGN(ContextHostResolver); }; } // namespace net diff --git a/net/dns/host_resolver.cc b/net/dns/host_resolver.cc index 4b9a108b16e041..9db6e630b67204 100644 --- a/net/dns/host_resolver.cc +++ b/net/dns/host_resolver.cc @@ -97,9 +97,17 @@ HostResolver::Options::Options() enable_caching(true) {} std::unique_ptr HostResolver::Factory::CreateResolver( + HostResolverManager* manager, + base::StringPiece host_mapping_rules) { + return HostResolver::CreateResolver(manager, host_mapping_rules); +} + +std::unique_ptr HostResolver::Factory::CreateStandaloneResolver( + NetLog* net_log, const Options& options, - NetLog* net_log) { - return CreateSystemResolver(options, net_log); + base::StringPiece host_mapping_rules) { + return HostResolver::CreateStandaloneResolver(net_log, options, + host_mapping_rules); } HostResolver::~HostResolver() = default; @@ -143,12 +151,12 @@ HostResolver::GetDnsOverHttpsServersForTesting() const { } // static -std::unique_ptr HostResolver::CreateSystemResolver( - const Options& options, - NetLog* net_log, +std::unique_ptr HostResolver::CreateResolver( + HostResolverManager* manager, base::StringPiece host_mapping_rules) { - std::unique_ptr resolver = - CreateSystemResolverImpl(options, net_log); + DCHECK(manager); + + auto resolver = std::make_unique(manager); if (host_mapping_rules.empty()) return resolver; @@ -159,23 +167,29 @@ std::unique_ptr HostResolver::CreateSystemResolver( } // static -std::unique_ptr HostResolver::CreateSystemResolverImpl( - const Options& options, - NetLog* net_log) { - return std::make_unique( - std::make_unique(options, net_log)); -} +std::unique_ptr HostResolver::CreateStandaloneResolver( + NetLog* net_log, + base::Optional options, + base::StringPiece host_mapping_rules) { + auto resolver = std::make_unique( + std::make_unique( + std::move(options).value_or(Options()), net_log)); -// static -std::unique_ptr HostResolver::CreateDefaultResolver( - NetLog* net_log) { - return CreateSystemResolver(Options(), net_log); + if (host_mapping_rules.empty()) + return resolver; + auto remapped_resolver = + std::make_unique(std::move(resolver)); + remapped_resolver->SetRulesFromString(host_mapping_rules); + return remapped_resolver; } // static -std::unique_ptr HostResolver::CreateDefaultResolverImpl( - NetLog* net_log) { - return CreateSystemResolverImpl(Options(), net_log); +std::unique_ptr +HostResolver::CreateStandaloneContextResolver(NetLog* net_log, + base::Optional options) { + return std::make_unique( + std::make_unique( + std::move(options).value_or(Options()), net_log)); } // static diff --git a/net/dns/host_resolver.h b/net/dns/host_resolver.h index f7927fdf9c20ef..609d81548769ad 100644 --- a/net/dns/host_resolver.h +++ b/net/dns/host_resolver.h @@ -12,6 +12,7 @@ #include #include +#include "base/macros.h" #include "base/optional.h" #include "base/strings/string_piece.h" #include "net/base/address_family.h" @@ -34,6 +35,7 @@ class AddressList; class ContextHostResolver; class DnsClient; struct DnsConfigOverrides; +class HostResolverManager; class NetLog; class NetLogWithSource; class URLRequestContext; @@ -133,9 +135,16 @@ class NET_EXPORT HostResolver { public: virtual ~Factory() = default; - // See HostResolver::CreateSystemResolver. - virtual std::unique_ptr CreateResolver(const Options& options, - NetLog* net_log); + // See HostResolver::CreateResolver. + virtual std::unique_ptr CreateResolver( + HostResolverManager* manager, + base::StringPiece host_mapping_rules); + + // See HostResolver::CreateStandaloneResolver. + virtual std::unique_ptr CreateStandaloneResolver( + NetLog* net_log, + const Options& options, + base::StringPiece host_mapping_rules); }; // Parameter-grouping struct for additional optional parameters for @@ -293,28 +302,29 @@ class NET_EXPORT HostResolver { virtual const std::vector* GetDnsOverHttpsServersForTesting() 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). + // Creates a new HostResolver. |manager| must outlive the returned resolver. // // If |mapping_rules| is non-empty, the mapping rules will be applied to // requests. See MappedHostResolver for details. - static std::unique_ptr CreateSystemResolver( - const Options& options, - NetLog* net_log, + static std::unique_ptr CreateResolver( + HostResolverManager* manager, base::StringPiece host_mapping_rules = ""); - // Same, but explicitly returns the implementing ContextHostResolver. Only - // used by tests. - static std::unique_ptr CreateSystemResolverImpl( - const Options& options, - NetLog* net_log); - // As above, but uses default parameters. - static std::unique_ptr CreateDefaultResolver(NetLog* net_log); + // Creates a HostResolver independent of any global HostResolverManager. Only + // for tests and standalone tools not part of the browser. + // + // If |mapping_rules| is non-empty, the mapping rules will be applied to + // requests. See MappedHostResolver for details. + static std::unique_ptr CreateStandaloneResolver( + NetLog* net_log, + base::Optional options = base::nullopt, + base::StringPiece host_mapping_rules = ""); // Same, but explicitly returns the implementing ContextHostResolver. Only - // used by tests and by StaleHostResolver in Cronet. - static std::unique_ptr CreateDefaultResolverImpl( - NetLog* net_log); + // used by tests and by StaleHostResolver in Cronet. No mapping rules can be + // applied because doing so requires wrapping the ContextHostResolver. + static std::unique_ptr CreateStandaloneContextResolver( + NetLog* net_log, + base::Optional options = base::nullopt); // Helpers for interacting with HostCache and ProcResolver. static AddressFamily DnsQueryTypeToAddressFamily(DnsQueryType query_type); diff --git a/net/nqe/network_quality_estimator_util_unittest.cc b/net/nqe/network_quality_estimator_util_unittest.cc index 83aeb010dd23e9..2e5453eaae3c3d 100644 --- a/net/nqe/network_quality_estimator_util_unittest.cc +++ b/net/nqe/network_quality_estimator_util_unittest.cc @@ -122,7 +122,8 @@ TEST(NetworkQualityEstimatorUtilTest, Localhost) { // Use actual HostResolver since MockCachingHostResolver does not determine // the correct answer for localhosts. std::unique_ptr resolver = - HostResolver::CreateDefaultResolverImpl(net_log_ptr->bound().net_log()); + HostResolver::CreateStandaloneContextResolver( + net_log_ptr->bound().net_log()); scoped_refptr rules( new net::RuleBasedHostResolverProc(nullptr)); diff --git a/net/socket/socks_client_socket_unittest.cc b/net/socket/socks_client_socket_unittest.cc index 13838e89afaffc..099e9b688c080c 100644 --- a/net/socket/socks_client_socket_unittest.cc +++ b/net/socket/socks_client_socket_unittest.cc @@ -421,7 +421,7 @@ TEST_F(SOCKSClientSocketTest, NoIPv6RealResolver) { const char kHostName[] = "::1"; std::unique_ptr host_resolver( - HostResolver::CreateSystemResolver(HostResolver::Options(), nullptr)); + HostResolver::CreateStandaloneResolver(nullptr)); user_sock_ = BuildMockSocket(base::span(), base::span(), host_resolver.get(), kHostName, 80, nullptr); diff --git a/net/test/spawned_test_server/base_test_server.cc b/net/test/spawned_test_server/base_test_server.cc index 1236b8be41cdac..4636590d886fc3 100644 --- a/net/test/spawned_test_server/base_test_server.cc +++ b/net/test/spawned_test_server/base_test_server.cc @@ -354,7 +354,7 @@ bool BaseTestServer::GetAddressList(AddressList* address_list) const { DCHECK(address_list); std::unique_ptr resolver( - HostResolver::CreateDefaultResolver(nullptr)); + HostResolver::CreateStandaloneResolver(nullptr)); // Limit the lookup to IPv4 (DnsQueryType::A). When started with the default // address of kLocalhost, testserver.py only supports IPv4. diff --git a/net/tools/quic/synchronous_host_resolver.cc b/net/tools/quic/synchronous_host_resolver.cc index 8bd0b9f57c8a8e..43e5847c8323fd 100644 --- a/net/tools/quic/synchronous_host_resolver.cc +++ b/net/tools/quic/synchronous_host_resolver.cc @@ -64,7 +64,7 @@ void ResolverThread::Run() { options.max_concurrent_resolves = 6; options.max_retry_attempts = 3u; std::unique_ptr resolver = - net::HostResolver::CreateSystemResolver(options, &net_log); + net::HostResolver::CreateStandaloneResolver(&net_log, options); HostPortPair host_port_pair(host_, 80); std::unique_ptr request = diff --git a/net/url_request/http_with_dns_over_https_unittest.cc b/net/url_request/http_with_dns_over_https_unittest.cc index e0149eb56fcfcb..6e47d6b39d1669 100644 --- a/net/url_request/http_with_dns_over_https_unittest.cc +++ b/net/url_request/http_with_dns_over_https_unittest.cc @@ -8,6 +8,7 @@ #include "net/dns/dns_client.h" #include "net/dns/dns_config.h" #include "net/dns/dns_transaction.h" +#include "net/dns/host_resolver.h" #include "net/dns/host_resolver_proc.h" #include "net/http/http_stream_factory_test_util.h" #include "net/log/net_log.h" @@ -48,7 +49,7 @@ class TestHostResolverProc : public HostResolverProc { class HttpWithDnsOverHttpsTest : public TestWithScopedTaskEnvironment { public: HttpWithDnsOverHttpsTest() - : resolver_(HostResolver::CreateDefaultResolverImpl(nullptr)), + : resolver_(HostResolver::CreateStandaloneContextResolver(nullptr)), request_context_(true), doh_server_(EmbeddedTestServer::Type::TYPE_HTTPS), test_server_(EmbeddedTestServer::Type::TYPE_HTTPS), diff --git a/net/url_request/url_request_context_builder.cc b/net/url_request/url_request_context_builder.cc index eff048b8fa2b97..daa34f92e208d9 100644 --- a/net/url_request/url_request_context_builder.cc +++ b/net/url_request/url_request_context_builder.cc @@ -424,11 +424,15 @@ std::unique_ptr URLRequestContextBuilder::Build() { DCHECK(host_mapping_rules_.empty()); storage->set_host_resolver(std::move(host_resolver_)); } else if (shared_host_resolver_) { + // TODO(crbug.com/934402): Use a shared HostResolverManager instead of a + // global HostResolver. DCHECK(host_mapping_rules_.empty()); context->set_host_resolver(shared_host_resolver_); } else { - storage->set_host_resolver(HostResolver::CreateSystemResolver( - HostResolver::Options(), context->net_log(), host_mapping_rules_)); + // TODO(crbug.com/934402): Make setting a resolver or manager required, so + // the builder should never have to create a standalone resolver. + storage->set_host_resolver(HostResolver::CreateStandaloneResolver( + context->net_log(), HostResolver::Options(), host_mapping_rules_)); } if (ssl_config_service_) { diff --git a/net/url_request/url_request_context_builder.h b/net/url_request/url_request_context_builder.h index daf2595db8f3d8..3dc5883eba045a 100644 --- a/net/url_request/url_request_context_builder.h +++ b/net/url_request/url_request_context_builder.h @@ -237,7 +237,8 @@ class NET_EXPORT URLRequestContextBuilder { // set their own NetLog::Observers instead. void set_net_log(NetLog* net_log) { net_log_ = net_log; } - // By default host_resolver is constructed with CreateDefaultResolver. + // By default host_resolver is constructed with + // HostResolver::CreateStandaloneResolver(). void set_host_resolver(std::unique_ptr host_resolver); // If set to non-empty, the mapping rules will be applied to requests to the // created host resolver. See MappedHostResolver for details. Should not be diff --git a/services/network/host_resolver_unittest.cc b/services/network/host_resolver_unittest.cc index 4b920d05d4761b..4743d5b82b4d69 100644 --- a/services/network/host_resolver_unittest.cc +++ b/services/network/host_resolver_unittest.cc @@ -249,7 +249,7 @@ TEST_F(HostResolverTest, Async) { TEST_F(HostResolverTest, DnsQueryType) { net::NetLog net_log; std::unique_ptr inner_resolver = - net::HostResolver::CreateDefaultResolver(&net_log); + net::HostResolver::CreateStandaloneResolver(&net_log); HostResolver resolver(inner_resolver.get(), &net_log); @@ -686,7 +686,7 @@ TEST_F(HostResolverTest, Failure_Async) { TEST_F(HostResolverTest, NoOptionalParameters) { net::NetLog net_log; std::unique_ptr inner_resolver = - net::HostResolver::CreateDefaultResolver(&net_log); + net::HostResolver::CreateStandaloneResolver(&net_log); HostResolver resolver(inner_resolver.get(), &net_log); @@ -711,7 +711,7 @@ TEST_F(HostResolverTest, NoOptionalParameters) { TEST_F(HostResolverTest, NoControlHandle) { net::NetLog net_log; std::unique_ptr inner_resolver = - net::HostResolver::CreateDefaultResolver(&net_log); + net::HostResolver::CreateStandaloneResolver(&net_log); HostResolver resolver(inner_resolver.get(), &net_log); @@ -739,7 +739,7 @@ TEST_F(HostResolverTest, NoControlHandle) { TEST_F(HostResolverTest, CloseControlHandle) { net::NetLog net_log; std::unique_ptr inner_resolver = - net::HostResolver::CreateDefaultResolver(&net_log); + net::HostResolver::CreateStandaloneResolver(&net_log); HostResolver resolver(inner_resolver.get(), &net_log); @@ -808,7 +808,7 @@ TEST_F(HostResolverTest, Cancellation) { TEST_F(HostResolverTest, Cancellation_SubsequentRequest) { net::NetLog net_log; std::unique_ptr inner_resolver = - net::HostResolver::CreateDefaultResolver(&net_log); + net::HostResolver::CreateStandaloneResolver(&net_log); HostResolver resolver(inner_resolver.get(), &net_log); @@ -927,7 +927,7 @@ TEST_F(HostResolverTest, CloseClient) { TEST_F(HostResolverTest, CloseClient_SubsequentRequest) { net::NetLog net_log; std::unique_ptr inner_resolver = - net::HostResolver::CreateDefaultResolver(&net_log); + net::HostResolver::CreateStandaloneResolver(&net_log); HostResolver resolver(inner_resolver.get(), &net_log); @@ -972,7 +972,7 @@ TEST_F(HostResolverTest, Binding) { net::NetLog net_log; std::unique_ptr inner_resolver = - net::HostResolver::CreateDefaultResolver(&net_log); + net::HostResolver::CreateStandaloneResolver(&net_log); HostResolver resolver(mojo::MakeRequest(&resolver_ptr), std::move(shutdown_callback), inner_resolver.get(), @@ -1058,7 +1058,7 @@ TEST_F(HostResolverTest, CloseBinding_SubsequentRequest) { net::NetLog net_log; std::unique_ptr inner_resolver = - net::HostResolver::CreateDefaultResolver(&net_log); + net::HostResolver::CreateStandaloneResolver(&net_log); HostResolver resolver(mojo::MakeRequest(&resolver_ptr), std::move(shutdown_callback), inner_resolver.get(), @@ -1101,7 +1101,7 @@ TEST_F(HostResolverTest, CloseBinding_SubsequentRequest) { TEST_F(HostResolverTest, IsSpeculative) { net::NetLog net_log; std::unique_ptr inner_resolver = - net::HostResolver::CreateDefaultResolver(&net_log); + net::HostResolver::CreateStandaloneResolver(&net_log); HostResolver resolver(inner_resolver.get(), &net_log); @@ -1146,7 +1146,7 @@ TEST_F(HostResolverTest, TextResults) { net::NetLog net_log; std::unique_ptr inner_resolver = - net::HostResolver::CreateDefaultResolverImpl(&net_log); + net::HostResolver::CreateStandaloneContextResolver(&net_log); inner_resolver->SetDnsClientForTesting(std::move(dns_client)); inner_resolver->SetBaseDnsConfigForTesting(CreateValidDnsConfig()); @@ -1184,7 +1184,7 @@ TEST_F(HostResolverTest, HostResults) { net::NetLog net_log; std::unique_ptr inner_resolver = - net::HostResolver::CreateDefaultResolverImpl(&net_log); + net::HostResolver::CreateStandaloneContextResolver(&net_log); inner_resolver->SetDnsClientForTesting(std::move(dns_client)); inner_resolver->SetBaseDnsConfigForTesting(CreateValidDnsConfig()); diff --git a/services/network/network_context.cc b/services/network/network_context.cc index 50b61aaf014820..b882aa825923c7 100644 --- a/services/network/network_context.cc +++ b/services/network/network_context.cc @@ -1354,8 +1354,9 @@ void NetworkContext::CreateHostResolver( net::HostResolver::Options options; options.enable_caching = false; - private_internal_resolver = host_resolver_factory_->CreateResolver( - options, url_request_context_->net_log()); + private_internal_resolver = + host_resolver_factory_->CreateStandaloneResolver( + url_request_context_->net_log(), options, ""); internal_resolver = private_internal_resolver.get(); internal_resolver->SetDnsClientEnabled(true); diff --git a/services/network/network_context_unittest.cc b/services/network/network_context_unittest.cc index 3965fb08e31355..b5a9bd81896e8a 100644 --- a/services/network/network_context_unittest.cc +++ b/services/network/network_context_unittest.cc @@ -63,6 +63,7 @@ #include "net/disk_cache/disk_cache.h" #include "net/dns/context_host_resolver.h" #include "net/dns/dns_test_util.h" +#include "net/dns/host_resolver_manager.h" #include "net/dns/host_resolver_source.h" #include "net/dns/mock_host_resolver.h" #include "net/dns/public/dns_query_type.h" @@ -2910,10 +2911,19 @@ class TestResolverFactory : public net::HostResolver::Factory { } std::unique_ptr CreateResolver( + net::HostResolverManager* manager, + base::StringPiece host_mapping_rules) override { + NOTIMPLEMENTED(); + return nullptr; + } + + std::unique_ptr CreateStandaloneResolver( + net::NetLog* net_log, const net::HostResolver::Options& options, - net::NetLog* net_log) override { + base::StringPiece host_mapping_rules) override { + DCHECK(host_mapping_rules.empty()); std::unique_ptr resolver = - net::HostResolver::CreateSystemResolverImpl(options, net_log); + net::HostResolver::CreateStandaloneContextResolver(net_log, options); resolvers_.push_back(resolver.get()); return resolver; } diff --git a/services/network/network_service.cc b/services/network/network_service.cc index ef47b1fa7d5233..800b89d8eba003 100644 --- a/services/network/network_service.cc +++ b/services/network/network_service.cc @@ -114,8 +114,10 @@ std::unique_ptr CreateHostResolver(net::NetLog* net_log) { std::string host_mapping_rules = command_line.GetSwitchValueASCII(switches::kHostResolverRules); - return net::HostResolver::CreateSystemResolver(net::HostResolver::Options(), - net_log, host_mapping_rules); + // TODO(crbug.com/934402): Use a shared HostResolverManager instead of a + // global HostResolver. + return net::HostResolver::CreateStandaloneResolver( + net_log, net::HostResolver::Options(), host_mapping_rules); } // This is duplicated in content/browser/loader/resource_dispatcher_host_impl.cc