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 <ericorth@chromium.org>
Reviewed-by: Paul Jensen <pauljensen@chromium.org>
Cr-Commit-Position: refs/heads/master@{#643385}diff --git a/chrome/browser/io_thread.cc b/chrome/browser/io_thread.cc
index 38dc13a3..0ec3630 100644
--- a/chrome/browser/io_thread.cc
+++ b/chrome/browser/io_thread.cc
@@ -153,8 +153,10 @@
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 be5491a..bd76b7e 100644
--- a/chromecast/browser/url_request_context_factory.cc
+++ b/chromecast/browser/url_request_context_factory.cc
@@ -233,7 +233,9 @@
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 ea68391..d3a97e4 100644
--- a/components/cronet/ios/cronet_environment.mm
+++ b/components/cronet/ios/cronet_environment.mm
@@ -359,9 +359,11 @@
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<net::MappedHostResolver> 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<CronetPrefsManager>(
diff --git a/components/cronet/stale_host_resolver_unittest.cc b/components/cronet/stale_host_resolver_unittest.cc
index 74db118a..8287e14 100644
--- a/components/cronet/stale_host_resolver_unittest.cc
+++ b/components/cronet/stale_host_resolver_unittest.cc
@@ -176,7 +176,7 @@
CreateMockInnerResolverWithDnsClient(
std::unique_ptr<net::DnsClient> dns_client) {
std::unique_ptr<net::ContextHostResolver> 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 ccbfd7f..aebd97a 100644
--- a/components/cronet/url_request_context_config.cc
+++ b/components/cronet/url_request_context_config.cc
@@ -672,13 +672,15 @@
disable_ipv6_on_wifi) {
CHECK(net_log) << "All DNS-related experiments require NetLog.";
std::unique_ptr<net::HostResolver> 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 d28951a..99794e4 100644
--- a/google_apis/gcm/tools/mcs_probe.cc
+++ b/google_apis/gcm/tools/mcs_probe.cc
@@ -212,7 +212,6 @@
std::unique_ptr<net::URLRequestContext> url_request_context_;
net::NetLog net_log_;
std::unique_ptr<net::FileNetLogObserver> logger_;
- std::unique_ptr<net::HostResolver> host_resolver_;
MCSProbeAuthPreferences http_auth_preferences_;
std::unique_ptr<net::HttpAuthHandlerFactory> http_auth_handler_factory_;
@@ -339,13 +338,13 @@
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<std::string>{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 2e85b7d..6214e2a 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<net::HostResolver> 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 af9fc26..e0ab2d3 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<net::HostResolver> 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 98f3bd3..0e6cfb0c 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<net::HostResolver> 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 7802c13..7bf56d4 100644
--- a/net/dns/context_host_resolver.cc
+++ b/net/dns/context_host_resolver.cc
@@ -6,6 +6,7 @@
#include <utility>
+#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(
- std::unique_ptr<HostResolverManager> impl)
- : impl_(std::move(impl)) {}
+ContextHostResolver::ContextHostResolver(HostResolverManager* manager)
+ : manager_(manager) {
+ DCHECK(manager_);
+}
-ContextHostResolver::~ContextHostResolver() = default;
+ContextHostResolver::ContextHostResolver(
+ std::unique_ptr<HostResolverManager> owned_manager)
+ : manager_(owned_manager.get()), owned_manager_(std::move(owned_manager)) {
+ DCHECK(manager_);
+}
+
+ContextHostResolver::~ContextHostResolver() {
+ if (owned_manager_)
+ DCHECK_EQ(owned_manager_.get(), manager_);
+}
std::unique_ptr<HostResolver::ResolveHostRequest>
ContextHostResolver::CreateRequest(
const HostPortPair& host,
const NetLogWithSource& source_net_log,
const base::Optional<ResolveHostParameters>& optional_parameters) {
- return impl_->CreateRequest(host, source_net_log, optional_parameters);
+ return manager_->CreateRequest(host, source_net_log, optional_parameters);
}
std::unique_ptr<HostResolver::MdnsListener>
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<base::Value> 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<DnsConfig::DnsOverHttpsServerConfig>*
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<DnsClient> 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 fddfaa2..8bc4535 100644
--- a/net/dns/context_host_resolver.h
+++ b/net/dns/context_host_resolver.h
@@ -8,6 +8,7 @@
#include <memory>
#include <vector>
+#include "base/macros.h"
#include "net/base/net_export.h"
#include "net/dns/host_resolver.h"
@@ -33,8 +34,11 @@
class NET_EXPORT ContextHostResolver : public HostResolver {
public:
// Creates a ContextHostResolver that forwards all of its requests through
- // |impl|.
- explicit ContextHostResolver(std::unique_ptr<HostResolverManager> impl);
+ // |manager|.
+ explicit ContextHostResolver(HostResolverManager* manager);
+ // Same except the created resolver will own its own HostResolverManager.
+ explicit ContextHostResolver(
+ std::unique_ptr<HostResolverManager> owned_manager);
~ContextHostResolver() override;
// HostResolver methods:
@@ -72,9 +76,10 @@
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<HostResolverManager> impl_;
+ HostResolverManager* const manager_;
+ std::unique_ptr<HostResolverManager> owned_manager_;
+
+ DISALLOW_COPY_AND_ASSIGN(ContextHostResolver);
};
} // namespace net
diff --git a/net/dns/host_resolver.cc b/net/dns/host_resolver.cc
index 4b9a108..9db6e63 100644
--- a/net/dns/host_resolver.cc
+++ b/net/dns/host_resolver.cc
@@ -97,9 +97,17 @@
enable_caching(true) {}
std::unique_ptr<HostResolver> HostResolver::Factory::CreateResolver(
+ HostResolverManager* manager,
+ base::StringPiece host_mapping_rules) {
+ return HostResolver::CreateResolver(manager, host_mapping_rules);
+}
+
+std::unique_ptr<HostResolver> 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 @@
}
// static
-std::unique_ptr<HostResolver> HostResolver::CreateSystemResolver(
- const Options& options,
- NetLog* net_log,
+std::unique_ptr<HostResolver> HostResolver::CreateResolver(
+ HostResolverManager* manager,
base::StringPiece host_mapping_rules) {
- std::unique_ptr<ContextHostResolver> resolver =
- CreateSystemResolverImpl(options, net_log);
+ DCHECK(manager);
+
+ auto resolver = std::make_unique<ContextHostResolver>(manager);
if (host_mapping_rules.empty())
return resolver;
@@ -159,23 +167,29 @@
}
// static
-std::unique_ptr<ContextHostResolver> HostResolver::CreateSystemResolverImpl(
- const Options& options,
- NetLog* net_log) {
+std::unique_ptr<HostResolver> HostResolver::CreateStandaloneResolver(
+ NetLog* net_log,
+ base::Optional<Options> options,
+ base::StringPiece host_mapping_rules) {
+ auto resolver = std::make_unique<ContextHostResolver>(
+ std::make_unique<HostResolverManager>(
+ std::move(options).value_or(Options()), net_log));
+
+ if (host_mapping_rules.empty())
+ return resolver;
+ auto remapped_resolver =
+ std::make_unique<MappedHostResolver>(std::move(resolver));
+ remapped_resolver->SetRulesFromString(host_mapping_rules);
+ return remapped_resolver;
+}
+
+// static
+std::unique_ptr<ContextHostResolver>
+HostResolver::CreateStandaloneContextResolver(NetLog* net_log,
+ base::Optional<Options> options) {
return std::make_unique<ContextHostResolver>(
- std::make_unique<HostResolverManager>(options, net_log));
-}
-
-// static
-std::unique_ptr<HostResolver> HostResolver::CreateDefaultResolver(
- NetLog* net_log) {
- return CreateSystemResolver(Options(), net_log);
-}
-
-// static
-std::unique_ptr<ContextHostResolver> HostResolver::CreateDefaultResolverImpl(
- NetLog* net_log) {
- return CreateSystemResolverImpl(Options(), net_log);
+ std::make_unique<HostResolverManager>(
+ std::move(options).value_or(Options()), net_log));
}
// static
diff --git a/net/dns/host_resolver.h b/net/dns/host_resolver.h
index f7927fdf..609d815 100644
--- a/net/dns/host_resolver.h
+++ b/net/dns/host_resolver.h
@@ -12,6 +12,7 @@
#include <string>
#include <vector>
+#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 ContextHostResolver;
class DnsClient;
struct DnsConfigOverrides;
+class HostResolverManager;
class NetLog;
class NetLogWithSource;
class URLRequestContext;
@@ -133,9 +135,16 @@
public:
virtual ~Factory() = default;
- // See HostResolver::CreateSystemResolver.
- virtual std::unique_ptr<HostResolver> CreateResolver(const Options& options,
- NetLog* net_log);
+ // See HostResolver::CreateResolver.
+ virtual std::unique_ptr<HostResolver> CreateResolver(
+ HostResolverManager* manager,
+ base::StringPiece host_mapping_rules);
+
+ // See HostResolver::CreateStandaloneResolver.
+ virtual std::unique_ptr<HostResolver> CreateStandaloneResolver(
+ NetLog* net_log,
+ const Options& options,
+ base::StringPiece host_mapping_rules);
};
// Parameter-grouping struct for additional optional parameters for
@@ -293,28 +302,29 @@
virtual const std::vector<DnsConfig::DnsOverHttpsServerConfig>*
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<HostResolver> CreateSystemResolver(
- const Options& options,
+ static std::unique_ptr<HostResolver> CreateResolver(
+ HostResolverManager* manager,
+ base::StringPiece host_mapping_rules = "");
+
+ // 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<HostResolver> CreateStandaloneResolver(
NetLog* net_log,
+ base::Optional<Options> options = base::nullopt,
base::StringPiece host_mapping_rules = "");
// Same, but explicitly returns the implementing ContextHostResolver. Only
- // used by tests.
- static std::unique_ptr<ContextHostResolver> CreateSystemResolverImpl(
- const Options& options,
- NetLog* net_log);
-
- // As above, but uses default parameters.
- static std::unique_ptr<HostResolver> CreateDefaultResolver(NetLog* net_log);
- // Same, but explicitly returns the implementing ContextHostResolver. Only
- // used by tests and by StaleHostResolver in Cronet.
- static std::unique_ptr<ContextHostResolver> 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<ContextHostResolver> CreateStandaloneContextResolver(
+ NetLog* net_log,
+ base::Optional<Options> 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 83aeb01..2e5453e 100644
--- a/net/nqe/network_quality_estimator_util_unittest.cc
+++ b/net/nqe/network_quality_estimator_util_unittest.cc
@@ -122,7 +122,8 @@
// Use actual HostResolver since MockCachingHostResolver does not determine
// the correct answer for localhosts.
std::unique_ptr<ContextHostResolver> resolver =
- HostResolver::CreateDefaultResolverImpl(net_log_ptr->bound().net_log());
+ HostResolver::CreateStandaloneContextResolver(
+ net_log_ptr->bound().net_log());
scoped_refptr<net::RuleBasedHostResolverProc> rules(
new net::RuleBasedHostResolverProc(nullptr));
diff --git a/net/socket/socks_client_socket_unittest.cc b/net/socket/socks_client_socket_unittest.cc
index 13838e8..099e9b6 100644
--- a/net/socket/socks_client_socket_unittest.cc
+++ b/net/socket/socks_client_socket_unittest.cc
@@ -421,7 +421,7 @@
const char kHostName[] = "::1";
std::unique_ptr<HostResolver> host_resolver(
- HostResolver::CreateSystemResolver(HostResolver::Options(), nullptr));
+ HostResolver::CreateStandaloneResolver(nullptr));
user_sock_ = BuildMockSocket(base::span<MockRead>(), base::span<MockWrite>(),
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 1236b8b..4636590 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 @@
DCHECK(address_list);
std::unique_ptr<HostResolver> 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 8bd0b9f..43e5847 100644
--- a/net/tools/quic/synchronous_host_resolver.cc
+++ b/net/tools/quic/synchronous_host_resolver.cc
@@ -64,7 +64,7 @@
options.max_concurrent_resolves = 6;
options.max_retry_attempts = 3u;
std::unique_ptr<net::HostResolver> resolver =
- net::HostResolver::CreateSystemResolver(options, &net_log);
+ net::HostResolver::CreateStandaloneResolver(&net_log, options);
HostPortPair host_port_pair(host_, 80);
std::unique_ptr<net::HostResolver::ResolveHostRequest> 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 e0149eb..6e47d6b 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 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 eff048b..daa34f92 100644
--- a/net/url_request/url_request_context_builder.cc
+++ b/net/url_request/url_request_context_builder.cc
@@ -424,11 +424,15 @@
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 daf2595..3dc5883 100644
--- a/net/url_request/url_request_context_builder.h
+++ b/net/url_request/url_request_context_builder.h
@@ -237,7 +237,8 @@
// 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<HostResolver> 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 4b920d05..4743d5b 100644
--- a/services/network/host_resolver_unittest.cc
+++ b/services/network/host_resolver_unittest.cc
@@ -249,7 +249,7 @@
TEST_F(HostResolverTest, DnsQueryType) {
net::NetLog net_log;
std::unique_ptr<net::HostResolver> 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, NoOptionalParameters) {
net::NetLog net_log;
std::unique_ptr<net::HostResolver> 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, NoControlHandle) {
net::NetLog net_log;
std::unique_ptr<net::HostResolver> 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, CloseControlHandle) {
net::NetLog net_log;
std::unique_ptr<net::HostResolver> 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_SubsequentRequest) {
net::NetLog net_log;
std::unique_ptr<net::HostResolver> 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_SubsequentRequest) {
net::NetLog net_log;
std::unique_ptr<net::HostResolver> inner_resolver =
- net::HostResolver::CreateDefaultResolver(&net_log);
+ net::HostResolver::CreateStandaloneResolver(&net_log);
HostResolver resolver(inner_resolver.get(), &net_log);
@@ -972,7 +972,7 @@
net::NetLog net_log;
std::unique_ptr<net::HostResolver> 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 @@
net::NetLog net_log;
std::unique_ptr<net::HostResolver> 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, IsSpeculative) {
net::NetLog net_log;
std::unique_ptr<net::HostResolver> inner_resolver =
- net::HostResolver::CreateDefaultResolver(&net_log);
+ net::HostResolver::CreateStandaloneResolver(&net_log);
HostResolver resolver(inner_resolver.get(), &net_log);
@@ -1146,7 +1146,7 @@
net::NetLog net_log;
std::unique_ptr<net::ContextHostResolver> 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 @@
net::NetLog net_log;
std::unique_ptr<net::ContextHostResolver> 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 50b61aa..b882aa8 100644
--- a/services/network/network_context.cc
+++ b/services/network/network_context.cc
@@ -1354,8 +1354,9 @@
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 3965fb0..b5a9bd81 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 @@
}
std::unique_ptr<net::HostResolver> CreateResolver(
+ net::HostResolverManager* manager,
+ base::StringPiece host_mapping_rules) override {
+ NOTIMPLEMENTED();
+ return nullptr;
+ }
+
+ std::unique_ptr<net::HostResolver> 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<net::ContextHostResolver> 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 ef47b1fa..800b89d 100644
--- a/services/network/network_service.cc
+++ b/services/network/network_service.cc
@@ -114,8 +114,10 @@
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
