chromium/src
0
Fork 0
Code Activity

Rework MockHostResolver to better fit the new HTTPS record world

Browse Source 
Changes:
* Rewrote the core of MockHostResolverBase with a new RuleResolver to
  handle rule matching. MockHostResolver is now completely divorced
  from RuleBasedHostResolverProc that still exists for rule matching by
  TestHostResolver (for browser tests) and is not compatible with
  scheme matching because it is based around mocking the system
  resolver that does not even see schemes. Ideally, we'd also rework
  RuleBasedHostResolverProc to itself be based on the new RuleResolver
  to avoid unnecessary logic duplication, but I'm leaving it alone for
  now since we haven't yet figured out all the plans for browser tests
  in the HTTPS record world.
* Pipe the scheme through to the RuleResolver to allow it to match on
  those schemes.  Also, similarly pipe the scheme through to the
  underlying HostCache, so it can do scheme-specific caching, like in
  the real HostResolver.
* Create new rule setting for RuleResolver to a simple
  `AddRule(key, result);` with string overloads for the simple
  key-is-hostname and result-is-single-ip cases. The key allows more
  matching specifying than before, especially allowing requiring
  specific schemes, but in the default case, is even more allowing,
  matching on only hostname, to simplify the 99% case where the test
  doesn't care that other specific parameters match. Also added some
  legacy Add*() methods with same name as old RuleBasedHostResolverProc
  methods to reduce the already-crazy code churn from this CL.
* Make the default to DCHECK on queries without any matching rules, as
  I believe that is more commonly the sane behavior for a unittest mock
  like this.  But also add a `default_result` parameter to the
  constructor to allow different behavior.  Set that new parameter in
  test utilities where MockHostResolvers get widely used by tests that
  likely don't even know what a HostResolver is, as that seems
  reasonable for those cases.  Also set it in a few cases of mocks used
  in large test files where I didn't want to take the churn of setting
  expectations for all the tests, even if those were generally cases
  where, in an ideal world, we would have explicit expectations.  But
  going forward, the new expectation for new tests is that if you are
  directly messing with a MockHostResolver, you should be setting the
  expectations rather than relying on default behavior.
* Add automatic synchronous resolution of "localhost" and similar, more
  closely matching the real HostResolver behavior for such names.
  Related to the default result change, as some tests were relying on
  the previous default behavior in order to allow resolving these
  names.  (And them some tests were just randomly using "localhost" for
  no apparent reason and became slightly broken if the expected it to
  be mappable through rules or made asynchronous, etc, even though the
  real HostResolver absolutely would never behave that way.)
* A subtle change that MockHostResolver will now only overwrite the
  port in results with the request port when the rule-matched response
  port is zero. This matches the actual behavior of HostResolver when
  request port is only used when lower layers return a port of zero.
  Allows matching to rules with a specific overriding port to match the
  HostResolver behavior that will soon be more common with HTTPS record
  support.

Change-Id: I6e57c4b6cdd2dac2a1aca6bfaf15fbde6671d4cb
Bug: 1206799
Fixed: 1182263
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3166033
Commit-Queue: Eric Orth <ericorth@chromium.org>
Reviewed-by: David Benjamin <davidben@chromium.org>
Reviewed-by: Dan McArdle <dmcardle@chromium.org>
Cr-Commit-Position: refs/heads/main@{#936136}
This commit is contained in:
Eric Orth
2021-10-28 22:31:11 +00:00
committed by Chromium LUCI CQ
parent 442c4e5a3b
commit be86fee19e
31 changed files with 902 additions and 514 deletions

3
net/cert_net/cert_net_fetcher_url_request_unittest.cc

@ -54,7 +54,8 @@ class RequestContext : public URLRequestContext {
public:
RequestContext() : storage_(this) {
ProxyConfig no_proxy;
storage_.set_host_resolver(std::make_unique<MockHostResolver>());
storage_.set_host_resolver(std::make_unique<MockHostResolver>(
MockHostResolverBase::RuleResolver::GetLocalhostResult()));
storage_.set_cert_verifier(std::make_unique<MockCertVerifier>());
storage_.set_transport_security_state(
std::make_unique<TransportSecurityState>());

424
net/dns/mock_host_resolver.cc

@ -4,6 +4,8 @@
#include "net/dns/mock_host_resolver.h"
#include <stdint.h>
#include <memory>
#include <string>
#include <utility>
@ -11,11 +13,13 @@
#include "base/bind.h"
#include "base/callback_helpers.h"
#include "base/check_op.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/memory/ref_counted.h"
#include "base/no_destructor.h"
#include "base/notreached.h"
#include "base/strings/pattern.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_split.h"
@ -27,6 +31,7 @@
#include "base/time/tick_clock.h"
#include "build/build_config.h"
#include "net/base/address_family.h"
#include "net/base/address_list.h"
#include "net/base/host_port_pair.h"
#include "net/base/ip_address.h"
#include "net/base/ip_endpoint.h"
@ -35,6 +40,8 @@
#include "net/base/test_completion_callback.h"
#include "net/dns/dns_alias_utility.h"
#include "net/dns/host_cache.h"
#include "net/dns/host_resolver.h"
#include "net/dns/host_resolver_manager.h"
#include "net/dns/public/host_resolver_source.h"
#include "net/dns/public/mdns_listener_update_type.h"
#include "net/dns/public/resolve_error_info.h"
@ -42,6 +49,7 @@
#include "net/log/net_log_with_source.h"
#include "net/url_request/url_request_context.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
#include "third_party/abseil-cpp/absl/types/variant.h"
#include "url/scheme_host_port.h"
#if defined(OS_WIN)
@ -57,18 +65,51 @@ const unsigned kMaxCacheEntries = 100;
// TTL for the successful resolutions. Failures are not cached.
const unsigned kCacheEntryTTLSeconds = 60;
RuleBasedHostResolverProc* CreateMockHostResolverProc(bool add_catchall) {
if (add_catchall) {
return CreateCatchAllHostResolverProc();
base::StringPiece GetScheme(
const absl::variant<url::SchemeHostPort, HostPortPair>& endpoint) {
DCHECK(absl::holds_alternative<url::SchemeHostPort>(endpoint));
return absl::get<url::SchemeHostPort>(endpoint).scheme();
}
// In HostPortPair format (no brackets around IPv6 literals) purely for
// compatibility with IPAddress::AssignFromIPLiteral().
base::StringPiece GetHostname(
const absl::variant<url::SchemeHostPort, HostPortPair>& endpoint) {
if (absl::holds_alternative<url::SchemeHostPort>(endpoint)) {
base::StringPiece hostname =
absl::get<url::SchemeHostPort>(endpoint).host();
if (hostname.size() >= 2 && hostname.front() == '[' &&
hostname.back() == ']') {
return hostname.substr(1, hostname.size() - 2);
}
return hostname;
}
return new RuleBasedHostResolverProc(/*previous=*/nullptr,
/*allow_fallback=*/false);
DCHECK(absl::holds_alternative<HostPortPair>(endpoint));
return absl::get<HostPortPair>(endpoint).host();
}
uint16_t GetPort(
const absl::variant<url::SchemeHostPort, HostPortPair>& endpoint) {
if (absl::holds_alternative<url::SchemeHostPort>(endpoint))
return absl::get<url::SchemeHostPort>(endpoint).port();
DCHECK(absl::holds_alternative<HostPortPair>(endpoint));
return absl::get<HostPortPair>(endpoint).port();
}
absl::variant<url::SchemeHostPort, std::string> GetCacheHost(
const absl::variant<url::SchemeHostPort, HostPortPair>& endpoint) {
if (absl::holds_alternative<url::SchemeHostPort>(endpoint))
return absl::get<url::SchemeHostPort>(endpoint);
DCHECK(absl::holds_alternative<HostPortPair>(endpoint));
return absl::get<HostPortPair>(endpoint).host();
}
} // namespace
int ParseAddressList(const std::string& host_list,
int ParseAddressList(base::StringPiece host_list,
const std::vector<std::string>& dns_aliases,
AddressList* addrlist) {
*addrlist = AddressList();
@ -88,11 +129,11 @@ int ParseAddressList(const std::string& host_list,
class MockHostResolverBase::RequestImpl
: public HostResolver::ResolveHostRequest {
public:
RequestImpl(const HostPortPair& request_host,
RequestImpl(absl::variant<url::SchemeHostPort, HostPortPair> request_endpoint,
const NetworkIsolationKey& network_isolation_key,
const absl::optional<ResolveHostParameters>& optional_parameters,
base::WeakPtr<MockHostResolverBase> resolver)
: request_host_(request_host),
: request_endpoint_(std::move(request_endpoint)),
network_isolation_key_(network_isolation_key),
parameters_(optional_parameters ? optional_parameters.value()
: ResolveHostParameters()),
@ -198,7 +239,7 @@ class MockHostResolverBase::RequestImpl
DCHECK(!address_results_);
DCHECK(!parameters_.is_speculative);
address_results_ = address_results;
address_results_ = FixupAddressList(address_results);
sanitized_dns_alias_results_ =
dns_alias_utility::SanitizeDnsAliases(address_results_->dns_aliases());
staleness_ = std::move(staleness);
@ -221,7 +262,10 @@ class MockHostResolverBase::RequestImpl
std::move(callback_).Run(error);
}
const HostPortPair& request_host() const { return request_host_; }
const absl::variant<url::SchemeHostPort, HostPortPair>& request_endpoint()
const {
return request_endpoint_;
}
const NetworkIsolationKey& network_isolation_key() const {
return network_isolation_key_;
@ -245,7 +289,33 @@ class MockHostResolverBase::RequestImpl
bool complete() { return complete_; }
private:
const HostPortPair request_host_;
AddressList FixupAddressList(const AddressList& list) {
// Filter address family by query type and set request port if response port
// is default.
AddressList corrected;
for (const IPEndPoint& endpoint : list.endpoints()) {
if (IsAddressType(parameters_.dns_query_type) &&
(parameters_.dns_query_type == DnsQueryType::UNSPECIFIED ||
HostResolver::DnsQueryTypeToAddressFamily(
parameters_.dns_query_type) == endpoint.GetFamily())) {
if (endpoint.port() == 0) {
corrected.push_back(
IPEndPoint(endpoint.address(), GetPort(request_endpoint_)));
} else {
corrected.push_back(endpoint);
}
}
}
// Copy over aliases and set to request hostname if empty.
corrected.SetDnsAliases(list.dns_aliases());
if (corrected.dns_aliases().empty())
corrected.SetDnsAliases({std::string(GetHostname(request_endpoint_))});
return corrected;
}
const absl::variant<url::SchemeHostPort, HostPortPair> request_endpoint_;
const NetworkIsolationKey network_isolation_key_;
const ResolveHostParameters parameters_;
RequestPriority priority_;
@ -356,6 +426,192 @@ class MockHostResolverBase::MdnsListenerImpl
base::WeakPtr<MockHostResolverBase> resolver_;
};
MockHostResolverBase::RuleResolver::RuleKey::RuleKey() = default;
MockHostResolverBase::RuleResolver::RuleKey::~RuleKey() = default;
MockHostResolverBase::RuleResolver::RuleKey::RuleKey(const RuleKey&) = default;
MockHostResolverBase::RuleResolver::RuleKey&
MockHostResolverBase::RuleResolver::RuleKey::operator=(const RuleKey&) =
default;
MockHostResolverBase::RuleResolver::RuleKey::RuleKey(RuleKey&&) = default;
MockHostResolverBase::RuleResolver::RuleKey&
MockHostResolverBase::RuleResolver::RuleKey::operator=(RuleKey&&) = default;
MockHostResolverBase::RuleResolver::RuleResolver(
absl::optional<RuleResult> default_result)
: default_result_(std::move(default_result)) {}
MockHostResolverBase::RuleResolver::~RuleResolver() = default;
MockHostResolverBase::RuleResolver::RuleResolver(const RuleResolver&) = default;
MockHostResolverBase::RuleResolver&
MockHostResolverBase::RuleResolver::operator=(const RuleResolver&) = default;
MockHostResolverBase::RuleResolver::RuleResolver(RuleResolver&&) = default;
MockHostResolverBase::RuleResolver&
MockHostResolverBase::RuleResolver::operator=(RuleResolver&&) = default;
const MockHostResolverBase::RuleResolver::RuleResult&
MockHostResolverBase::RuleResolver::Resolve(
const absl::variant<url::SchemeHostPort, HostPortPair>& request_endpoint,
DnsQueryType request_type,
HostResolverSource request_source) const {
for (const auto& rule : rules_) {
const RuleKey& key = rule.first;
const RuleResult& result = rule.second;
if (absl::holds_alternative<RuleKey::NoScheme>(key.scheme) &&
absl::holds_alternative<url::SchemeHostPort>(request_endpoint)) {
continue;
}
if (key.port.has_value() && key.port.value() != GetPort(request_endpoint)) {
continue;
}
if (key.query_type.has_value() && request_type != key.query_type.value()) {
continue;
}
if (key.query_source.has_value() &&
request_source != key.query_source.value()) {
continue;
}
if (absl::holds_alternative<RuleKey::Scheme>(key.scheme) &&
(!absl::holds_alternative<url::SchemeHostPort>(request_endpoint) ||
GetScheme(request_endpoint) !=
absl::get<RuleKey::Scheme>(key.scheme))) {
continue;
}
if (!base::MatchPattern(GetHostname(request_endpoint),
key.hostname_pattern)) {
continue;
}
return result;
}
if (default_result_)
return default_result_.value();
NOTREACHED() << "Request " << GetHostname(request_endpoint)
<< " did not match any MockHostResolver rules.";
static const RuleResult kUnexpected = ERR_UNEXPECTED;
return kUnexpected;
}
void MockHostResolverBase::RuleResolver::ClearRules() {
rules_.clear();
}
// static
MockHostResolverBase::RuleResolver::RuleResult
MockHostResolverBase::RuleResolver::GetLocalhostResult() {
return AddressList::CreateFromIPAddress(IPAddress::IPv4Localhost(),
/*port=*/0);
}
void MockHostResolverBase::RuleResolver::AddRule(RuleKey key,
RuleResult result) {
// Literals are always resolved to themselves by MockHostResolverBase,
// consequently we do not support remapping them.
IPAddress ip_address;
DCHECK(!ip_address.AssignFromIPLiteral(key.hostname_pattern));
CHECK(rules_.emplace(std::move(key), std::move(result)).second)
<< "Duplicate rule key";
}
void MockHostResolverBase::RuleResolver::AddRule(RuleKey key,
base::StringPiece ip_literal) {
AddressList results;
CHECK_EQ(ParseAddressList(ip_literal, /*dns_aliases=*/{}, &results), OK);
AddRule(std::move(key), std::move(results));
}
void MockHostResolverBase::RuleResolver::AddRule(
base::StringPiece hostname_pattern,
RuleResult result) {
RuleKey key;
key.hostname_pattern = std::string(hostname_pattern);
AddRule(std::move(key), std::move(result));
}
void MockHostResolverBase::RuleResolver::AddRule(
base::StringPiece hostname_pattern,
base::StringPiece ip_literal) {
AddressList results;
CHECK_EQ(ParseAddressList(ip_literal, /*dns_aliases=*/{}, &results), OK);
AddRule(hostname_pattern, std::move(results));
}
void MockHostResolverBase::RuleResolver::AddRule(
base::StringPiece hostname_pattern,
Error error) {
RuleKey key;
key.hostname_pattern = std::string(hostname_pattern);
AddRule(std::move(key), error);
}
void MockHostResolverBase::RuleResolver::AddIPLiteralRule(
base::StringPiece hostname_pattern,
base::StringPiece ip_literal,
base::StringPiece canonical_name) {
RuleKey key;
key.hostname_pattern = std::string(hostname_pattern);
std::vector<std::string> aliases;
if (!canonical_name.empty())
aliases.emplace_back(canonical_name);
AddressList results;
CHECK_EQ(ParseAddressList(ip_literal, aliases, &results), OK);
AddRule(std::move(key), std::move(results));
}
void MockHostResolverBase::RuleResolver::AddIPLiteralRuleWithDnsAliases(
base::StringPiece hostname_pattern,
base::StringPiece ip_literal,
std::vector<std::string> dns_aliases) {
AddressList results;
CHECK_EQ(ParseAddressList(ip_literal, dns_aliases, &results), OK);
AddRule(hostname_pattern, std::move(results));
}
void MockHostResolverBase::RuleResolver::AddSimulatedFailure(
base::StringPiece hostname_pattern) {
AddRule(hostname_pattern, ERR_NAME_NOT_RESOLVED);
}
void MockHostResolverBase::RuleResolver::AddSimulatedTimeoutFailure(
base::StringPiece hostname_pattern) {
AddRule(hostname_pattern, ERR_DNS_TIMED_OUT);
}
void MockHostResolverBase::RuleResolver::AddRuleWithFlags(
base::StringPiece host_pattern,
base::StringPiece ip_literal,
HostResolverFlags /*flags*/,
std::vector<std::string> dns_aliases) {
AddressList results;
CHECK_EQ(ParseAddressList(ip_literal, dns_aliases, &results), OK);
AddRule(host_pattern, std::move(results));
}
MockHostResolverBase::~MockHostResolverBase() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
@ -374,7 +630,7 @@ void MockHostResolverBase::OnShutdown() {
requests_.clear();
// Prevent future requests by clearing resolution rules and the cache.
rules_map_.clear();
rule_resolver_.ClearRules();
cache_ = nullptr;
doh_probe_request_ = nullptr;
@ -386,9 +642,8 @@ MockHostResolverBase::CreateRequest(
NetworkIsolationKey network_isolation_key,
NetLogWithSource net_log,
absl::optional<ResolveHostParameters> optional_parameters) {
// TODO(crbug.com/1206799): Propagate scheme and make affect behavior.
return CreateRequest(HostPortPair::FromSchemeHostPort(host),
network_isolation_key, net_log, optional_parameters);
return std::make_unique<RequestImpl>(std::move(host), network_isolation_key,
optional_parameters, AsWeakPtr());
}
std::unique_ptr<HostResolver::ResolveHostRequest>
@ -417,7 +672,7 @@ HostCache* MockHostResolverBase::GetHostCache() {
}
int MockHostResolverBase::LoadIntoCache(
const HostPortPair& host,
const absl::variant<url::SchemeHostPort, HostPortPair>& endpoint,
const NetworkIsolationKey& network_isolation_key,
const absl::optional<ResolveHostParameters>& optional_parameters) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
@ -429,7 +684,7 @@ int MockHostResolverBase::LoadIntoCache(
AddressList addresses;
absl::optional<HostCache::EntryStaleness> stale_info;
int rv = ResolveFromIPLiteralOrCache(
host, network_isolation_key, parameters.dns_query_type,
endpoint, network_isolation_key, parameters.dns_query_type,
ParametersToHostResolverFlags(parameters), parameters.source,
parameters.cache_usage, &addresses, &stale_info);
if (rv != ERR_DNS_CACHE_MISS) {
@ -439,13 +694,12 @@ int MockHostResolverBase::LoadIntoCache(
// Just like the real resolver, refuse to do anything with invalid
// hostnames.
if (!IsValidDNSDomain(host.host()))
if (!IsValidDNSDomain(GetHostname(endpoint)))
return ERR_NAME_NOT_RESOLVED;
return ResolveProc(host, network_isolation_key,
DnsQueryTypeToAddressFamily(parameters.dns_query_type),
ParametersToHostResolverFlags(parameters),
parameters.source, &addresses);
RequestImpl request(endpoint, network_isolation_key, optional_parameters,
AsWeakPtr());
return DoSynchronousResolution(request);
}
void MockHostResolverBase::ResolveAllPending() {
@ -472,15 +726,8 @@ void MockHostResolverBase::ResolveNow(size_t id) {
RequestImpl* req = it->second;
requests_.erase(it);
AddressList addresses;
int error = ResolveProc(
req->request_host(), req->network_isolation_key(),
DnsQueryTypeToAddressFamily(req->parameters().dns_query_type),
req->host_resolver_flags(), req->parameters().source, &addresses);
req->SetError(error);
if (error == OK && !req->parameters().is_speculative)
req->SetAddressResults(addresses, absl::nullopt);
req->OnAsyncCompleted(id, SquashErrorCode(error));
int error = DoSynchronousResolution(*req);
req->OnAsyncCompleted(id, error);
}
void MockHostResolverBase::DetachRequest(size_t id) {
@ -489,9 +736,9 @@ void MockHostResolverBase::DetachRequest(size_t id) {
requests_.erase(it);
}
const std::string& MockHostResolverBase::request_host(size_t id) {
base::StringPiece MockHostResolverBase::request_host(size_t id) {
DCHECK(request(id));
return request(id)->request_host().host();
return GetHostname(request(id)->request_endpoint());
}
RequestPriority MockHostResolverBase::request_priority(size_t id) {
@ -555,33 +802,26 @@ void MockHostResolverBase::TriggerMdnsListeners(
MockHostResolverBase::RequestImpl* MockHostResolverBase::request(size_t id) {
RequestMap::iterator request = requests_.find(id);
DCHECK(request != requests_.end());
CHECK(request != requests_.end());
CHECK_EQ(request->second->id(), id);
return (*request).second;
}
// start id from 1 to distinguish from NULL RequestHandle
MockHostResolverBase::MockHostResolverBase(bool use_caching,
int cache_invalidation_num,
bool require_matching_rule)
RuleResolver rule_resolver)
: last_request_priority_(DEFAULT_PRIORITY),
last_secure_dns_policy_(SecureDnsPolicy::kAllow),
synchronous_mode_(false),
ondemand_mode_(false),
rule_resolver_(std::move(rule_resolver)),
initial_cache_invalidation_num_(cache_invalidation_num),
next_request_id_(1),
num_resolve_(0),
num_resolve_from_cache_(0),
num_non_local_resolves_(0),
tick_clock_(base::DefaultTickClock::GetInstance()) {
rules_map_[HostResolverSource::ANY] =
CreateMockHostResolverProc(/*add_catchall=*/!require_matching_rule);
rules_map_[HostResolverSource::SYSTEM] =
CreateMockHostResolverProc(/*add_catchall=*/!require_matching_rule);
rules_map_[HostResolverSource::DNS] =
CreateMockHostResolverProc(/*add_catchall=*/!require_matching_rule);
rules_map_[HostResolverSource::MULTICAST_DNS] =
CreateMockHostResolverProc(/*add_catchall=*/!require_matching_rule);
if (use_caching)
cache_ = std::make_unique<HostCache>(kMaxCacheEntries);
else
@ -598,7 +838,7 @@ int MockHostResolverBase::Resolve(RequestImpl* request) {
AddressList addresses;
absl::optional<HostCache::EntryStaleness> stale_info;
int rv = ResolveFromIPLiteralOrCache(
request->request_host(), request->network_isolation_key(),
request->request_endpoint(), request->network_isolation_key(),
request->parameters().dns_query_type, request->host_resolver_flags(),
request->parameters().source, request->parameters().cache_usage,
&addresses, &stale_info);
@ -613,23 +853,13 @@ int MockHostResolverBase::Resolve(RequestImpl* request) {
// Just like the real resolver, refuse to do anything with invalid
// hostnames.
if (!IsValidDNSDomain(request->request_host().host())) {
if (!IsValidDNSDomain(GetHostname(request->request_endpoint()))) {
request->SetError(ERR_NAME_NOT_RESOLVED);
return ERR_NAME_NOT_RESOLVED;
}
if (synchronous_mode_) {
rv = ResolveProc(
request->request_host(), request->network_isolation_key(),
DnsQueryTypeToAddressFamily(request->parameters().dns_query_type),
request->host_resolver_flags(), request->parameters().source,
&addresses);
request->SetError(rv);
if (rv == OK && !request->parameters().is_speculative)
request->SetAddressResults(addresses, absl::nullopt);
return SquashErrorCode(rv);
}
if (synchronous_mode_)
return DoSynchronousResolution(*request);
// Store the request for asynchronous resolution
size_t id = next_request_id_++;
@ -646,7 +876,7 @@ int MockHostResolverBase::Resolve(RequestImpl* request) {
}
int MockHostResolverBase::ResolveFromIPLiteralOrCache(
const HostPortPair& host,
const absl::variant<url::SchemeHostPort, HostPortPair>& endpoint,
const NetworkIsolationKey& network_isolation_key,
DnsQueryType dns_query_type,
HostResolverFlags flags,
@ -659,7 +889,7 @@ int MockHostResolverBase::ResolveFromIPLiteralOrCache(
*out_stale_info = absl::nullopt;
IPAddress ip_address;
if (ip_address.AssignFromIPLiteral(host.host())) {
if (ip_address.AssignFromIPLiteral(GetHostname(endpoint))) {
// This matches the behavior HostResolverImpl.
if (dns_query_type != DnsQueryType::UNSPECIFIED &&
dns_query_type !=
@ -667,11 +897,18 @@ int MockHostResolverBase::ResolveFromIPLiteralOrCache(
return ERR_NAME_NOT_RESOLVED;
}
*addresses = AddressList::CreateFromIPAddress(ip_address, host.port());
*addresses =
AddressList::CreateFromIPAddress(ip_address, GetPort(endpoint));
if (flags & HOST_RESOLVER_CANONNAME)
addresses->SetDefaultCanonicalName();
return OK;
}
// Immediately resolve any "localhost" or recognized similar names.
if (IsAddressType(dns_query_type) &&
ResolveLocalHostname(GetHostname(endpoint), addresses)) {
return OK;
}
int rv = ERR_DNS_CACHE_MISS;
bool cache_allowed =
cache_usage == HostResolver::ResolveHostParameters::CacheUsage::ALLOWED ||
@ -682,8 +919,8 @@ int MockHostResolverBase::ResolveFromIPLiteralOrCache(
HostResolverSource effective_source =
source == HostResolverSource::LOCAL_ONLY ? HostResolverSource::ANY
: source;
HostCache::Key key(host.host(), dns_query_type, flags, effective_source,
network_isolation_key);
HostCache::Key key(GetCacheHost(endpoint), dns_query_type, flags,
effective_source, network_isolation_key);
const std::pair<const HostCache::Key, HostCache::Entry>* cache_result;
HostCache::EntryStaleness stale_info = HostCache::kNotStale;
if (cache_usage ==
@ -698,7 +935,7 @@ int MockHostResolverBase::ResolveFromIPLiteralOrCache(
rv = cache_result->second.error();
if (rv == OK) {
*addresses = AddressList::CopyWithPort(
cache_result->second.addresses().value(), host.port());
cache_result->second.addresses().value(), GetPort(endpoint));
*out_stale_info = std::move(stale_info);
}
@ -718,37 +955,47 @@ int MockHostResolverBase::ResolveFromIPLiteralOrCache(
return rv;
}
int MockHostResolverBase::ResolveProc(
const HostPortPair& host,
const NetworkIsolationKey& network_isolation_key,
AddressFamily requested_address_family,
HostResolverFlags flags,
HostResolverSource source,
AddressList* addresses) {
DCHECK(rules_map_.find(source) != rules_map_.end());
int MockHostResolverBase::DoSynchronousResolution(RequestImpl& request) {
++num_non_local_resolves_;
AddressList addr;
int rv = rules_map_[source]->Resolve(host.host(), requested_address_family,
flags, &addr, nullptr);
const RuleResolver::RuleResult& result = rule_resolver_.Resolve(
request.request_endpoint(), request.parameters().dns_query_type,
request.parameters().source);
Error error = ERR_UNEXPECTED;
absl::optional<HostCache::Entry> cache_entry;
const AddressList* address_results = absl::get_if<AddressList>(&result);
if (address_results) {
error = address_results->empty() ? ERR_NAME_NOT_RESOLVED : OK;
request.SetAddressResults(*address_results,
/*staleness=*/absl::nullopt);
cache_entry.emplace(error, *address_results,
HostCache::Entry::SOURCE_UNKNOWN);
} else {
DCHECK(absl::holds_alternative<RuleResolver::ErrorResult>(result));
error = absl::get<RuleResolver::ErrorResult>(result);
cache_entry.emplace(error, HostCache::Entry::SOURCE_UNKNOWN);
}
request.SetError(error);
if (cache_.get()) {
HostCache::Key key(host.host(),
AddressFamilyToDnsQueryType(requested_address_family),
flags, source, network_isolation_key);
DCHECK(cache_entry.has_value());
HostCache::Key key(
GetCacheHost(request.request_endpoint()),
request.parameters().dns_query_type, request.host_resolver_flags(),
request.parameters().source, request.network_isolation_key());
// Storing a failure with TTL 0 so that it overwrites previous value.
base::TimeDelta ttl;
if (rv == OK) {
if (error == OK) {
ttl = base::Seconds(kCacheEntryTTLSeconds);
if (initial_cache_invalidation_num_ > 0)
cache_invalidation_nums_[key] = initial_cache_invalidation_num_;
}
cache_->Set(key,
HostCache::Entry(rv, addr, HostCache::Entry::SOURCE_UNKNOWN),
tick_clock_->NowTicks(), ttl);
cache_->Set(key, cache_entry.value(), tick_clock_->NowTicks(), ttl);
}
if (rv == OK)
*addresses = AddressList::CopyWithPort(addr, host.port());
return rv;
return SquashErrorCode(error);
}
void MockHostResolverBase::AddListener(MdnsListenerImpl* listener) {
@ -760,7 +1007,7 @@ void MockHostResolverBase::RemoveCancelledListener(MdnsListenerImpl* listener) {
}
MockHostResolverFactory::MockHostResolverFactory(
scoped_refptr<RuleBasedHostResolverProc> rules,
MockHostResolverBase::RuleResolver rules,
bool use_caching,
int cache_invalidation_num)
: rules_(std::move(rules)),
@ -777,10 +1024,7 @@ std::unique_ptr<HostResolver> MockHostResolverFactory::CreateResolver(
// Explicit new to access private constructor.
auto resolver = base::WrapUnique(new MockHostResolverBase(
enable_caching && use_caching_, cache_invalidation_num_,
/*require_matching_rule=*/true));
if (rules_)
resolver->set_rules(rules_.get());
enable_caching && use_caching_, cache_invalidation_num_, rules_));
return resolver;
}

188
net/dns/mock_host_resolver.h

@ -6,6 +6,7 @@
#define NET_DNS_MOCK_HOST_RESOLVER_H_
#include <stddef.h>
#include <stdint.h>
#include <list>
#include <map>
@ -16,11 +17,14 @@
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "base/strings/string_piece.h"
#include "base/synchronization/lock.h"
#include "base/synchronization/waitable_event.h"
#include "base/threading/thread_checker.h"
#include "net/base/address_family.h"
#include "net/base/completion_once_callback.h"
#include "net/base/host_port_pair.h"
#include "net/base/net_errors.h"
#include "net/base/network_isolation_key.h"
#include "net/dns/host_resolver.h"
#include "net/dns/host_resolver_proc.h"
@ -30,6 +34,7 @@
#include "net/dns/public/secure_dns_policy.h"
#include "net/log/net_log_with_source.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
#include "third_party/abseil-cpp/absl/types/variant.h"
#include "url/scheme_host_port.h"
namespace base {
@ -39,9 +44,7 @@ class TickClock;
namespace net {
class HostCache;
class HostPortPair;
class IPEndPoint;
class RuleBasedHostResolverProc;
class URLRequestContext;
// Fills `*addrlist` with a socket address for `host_list` which should be a
@ -50,7 +53,7 @@ class URLRequestContext;
// canonical name (i.e. address record name) for the host, and the alias
// chain is listed in reverse order through to the last entry, the query name.
// Returns OK on success, ERR_UNEXPECTED otherwise.
int ParseAddressList(const std::string& host_list,
int ParseAddressList(base::StringPiece host_list,
const std::vector<std::string>& dns_aliases,
AddressList* addrlist);
@ -59,33 +62,31 @@ int ParseAddressList(const std::string& host_list,
// is unreliable for some reason. To simplify writing tests that avoid making
// actual DNS queries, pass a MockHostResolver as the HostResolver dependency.
// The socket addresses returned can be configured using the
// RuleBasedHostResolverProc:
// MockHostResolverBase::RuleResolver:
//
// host_resolver->rules()->AddRule("foo.com", "1.2.3.4");
// host_resolver->rules()->AddRule("bar.com", "2.3.4.5");
//
// The above rules define a static mapping from hostnames to IP address
// literals. The first parameter to AddRule specifies a host pattern to match
// against, and the second parameter indicates what value should be used to
// against, and the second parameter indicates what IP address should be used to
// replace the given hostname. So, the following is also supported:
//
// host_mapper->AddRule("*.com", "127.0.0.1");
//
// Replacement doesn't have to be string representing an IP address. It can
// re-map one hostname to another as well.
// For more advanced matching, the first parameter may be replaced with a
// MockHostResolverBase::RuleResolver::RuleKey. For more advanced responses, the
// second parameter may be replaced with a
// MockHostResolverBase::RuleResolver::RuleResult.
//
// By default, MockHostResolvers include a single rule that maps all hosts to
// 127.0.0.1. Disable by setting `require_matching_rule` to true.
// TODO(crbug.com/1182263): Fixup any tests relying on the current default and
// switch to make `require_matching_rule` be the default.
// MockHostResolvers may optionally be created with a default result:
//
// Separate rules are used for separate HostResolverSource (eg
// HostResolverSource::SYSTEM for requests that should only be resolved using
// the system resolver). Use rules_map() to access the separate rules if tests
// involve requests specifying sources:
// MockHostResolver(ERR_NAME_NOT_RESOLVED);
// MockHostResolver(AddressList(ip_endpoint));
// MockHostResolver(MockHostResolverBase::RuleResolver::GetLocalhostResult());
//
// host_resolver->rules_map()[HostResolverSource::DNS]->AddRule("foo.com",
// "1.2.3.4");
// If no default result is given, every resolve request must match a configured
// rule, otherwise DCHECKs will fire.
// Base class shared by MockHostResolver and MockCachingHostResolver.
class MockHostResolverBase
@ -97,21 +98,103 @@ class MockHostResolverBase
class MdnsListenerImpl;
public:
class RuleResolver {
public:
struct RuleKey {
struct WildcardScheme : absl::monostate {};
struct NoScheme : absl::monostate {};
using Scheme = std::string;
RuleKey();
~RuleKey();
RuleKey(const RuleKey&);
RuleKey& operator=(const RuleKey&);
RuleKey(RuleKey&&);
RuleKey& operator=(RuleKey&&);
auto GetTuple() const {
return std::tie(scheme, hostname_pattern, port, query_type,
query_source);
}
bool operator<(const RuleKey& other) const {
return GetTuple() < other.GetTuple();
}
// If `WildcardScheme`, scheme is wildcard and any query will match,
// whether made with url::SchemeHostPort or HostPortPair. If `NoScheme`,
// queries will only match if made using HostPortPair. Else, queries will
// only match if made using url::SchemeHostPort with matching scheme
// value.
absl::variant<WildcardScheme, NoScheme, Scheme> scheme = WildcardScheme();
// Pattern matched via `base::MatchPattern()`.
std::string hostname_pattern = "*";
// `nullopt` represents wildcard and all queries will match.
absl::optional<uint16_t> port;
absl::optional<DnsQueryType> query_type;
absl::optional<HostResolverSource> query_source;
};
using ErrorResult = Error;
using RuleResult = absl::variant<AddressList, ErrorResult>;
// If `default_result` is nullopt, every resolve must match an added rule.
explicit RuleResolver(
absl::optional<RuleResult> default_result = absl::nullopt);
~RuleResolver();
RuleResolver(const RuleResolver&);
RuleResolver& operator=(const RuleResolver&);
RuleResolver(RuleResolver&&);
RuleResolver& operator=(RuleResolver&&);
const RuleResult& Resolve(
const absl::variant<url::SchemeHostPort, HostPortPair>&
request_endpoint,
DnsQueryType request_type,
HostResolverSource request_source) const;
void ClearRules();
static RuleResult GetLocalhostResult();
void AddRule(RuleKey key, RuleResult result);
void AddRule(RuleKey key, base::StringPiece ip_literal);
void AddRule(base::StringPiece hostname_pattern, RuleResult result);
void AddRule(base::StringPiece hostname_pattern,
base::StringPiece ip_literal);
void AddRule(base::StringPiece hostname_pattern, Error error);
// Legacy rule creation. Only for compatibility with tests written for use
// with RuleBasedHostResolverProc. New code should use the AddRule() calls
// above.
void AddIPLiteralRule(base::StringPiece hostname_pattern,
base::StringPiece ip_literal,
base::StringPiece canonical_name);
void AddIPLiteralRuleWithDnsAliases(base::StringPiece hostname_pattern,
base::StringPiece ip_literal,
std::vector<std::string> dns_aliases);
void AddSimulatedFailure(base::StringPiece hostname_pattern);
void AddSimulatedTimeoutFailure(base::StringPiece hostname_pattern);
void AddRuleWithFlags(base::StringPiece host_pattern,
base::StringPiece ip_literal,
HostResolverFlags flags,
std::vector<std::string> dns_aliases = {});
private:
std::map<RuleKey, RuleResult> rules_;
absl::optional<RuleResult> default_result_;
};
MockHostResolverBase(const MockHostResolverBase&) = delete;
MockHostResolverBase& operator=(const MockHostResolverBase&) = delete;
~MockHostResolverBase() override;
RuleBasedHostResolverProc* rules() {
return rules_map_[HostResolverSource::ANY].get();
}
void set_rules(RuleBasedHostResolverProc* rules) {
rules_map_[HostResolverSource::ANY] = rules;
}
std::map<HostResolverSource, scoped_refptr<RuleBasedHostResolverProc>>
rules_map() {
return rules_map_;
}
RuleResolver* rules() { return &rule_resolver_; }
// Controls whether resolutions complete synchronously or asynchronously.
void set_synchronous_mode(bool is_synchronous) {
@ -149,7 +232,7 @@ class MockHostResolverBase
// Preloads the cache with what would currently be the result of a request
// with the given parameters. Returns the net error of the cached result.
int LoadIntoCache(
const HostPortPair& host,
const absl::variant<url::SchemeHostPort, HostPortPair>& endpoint,
const NetworkIsolationKey& network_isolation_key,
const absl::optional<ResolveHostParameters>& optional_parameters);
@ -177,7 +260,7 @@ class MockHostResolverBase
void DetachRequest(size_t id);
// Returns the hostname of the request with the given id.
const std::string& request_host(size_t id);
base::StringPiece request_host(size_t id);
// Returns the priority of the request with the given id.
RequestPriority request_priority(size_t id);
@ -256,9 +339,9 @@ class MockHostResolverBase
// If > 0, |cache_invalidation_num| is the number of times a cached entry can
// be read before it invalidates itself. Useful to force cache expiration
// scenarios.
explicit MockHostResolverBase(bool use_caching,
int cache_invalidation_num,
bool require_matching_rule);
MockHostResolverBase(bool use_caching,
int cache_invalidation_num,
RuleResolver rule_resolver);
// Handle resolution for |request|. Expected to be called only the RequestImpl
// object itself.
@ -267,7 +350,7 @@ class MockHostResolverBase
// Resolve as IP or from |cache_| return cached error or
// DNS_CACHE_MISS if failed.
int ResolveFromIPLiteralOrCache(
const HostPortPair& host,
const absl::variant<url::SchemeHostPort, HostPortPair>& endpoint,
const NetworkIsolationKey& network_isolation_key,
DnsQueryType dns_query_type,
HostResolverFlags flags,
@ -275,13 +358,7 @@ class MockHostResolverBase
HostResolver::ResolveHostParameters::CacheUsage cache_usage,
AddressList* addresses,
absl::optional<HostCache::EntryStaleness>* stale_info);
// Resolve via |proc_|.
int ResolveProc(const HostPortPair& host,
const NetworkIsolationKey& network_isolation_key,
AddressFamily requested_address_family,
HostResolverFlags flags,
HostResolverSource source,
AddressList* addresses);
int DoSynchronousResolution(RequestImpl& request);
void AddListener(MdnsListenerImpl* listener);
void RemoveCancelledListener(MdnsListenerImpl* listener);
@ -291,8 +368,7 @@ class MockHostResolverBase
SecureDnsPolicy last_secure_dns_policy_;
bool synchronous_mode_;
bool ondemand_mode_;
std::map<HostResolverSource, scoped_refptr<RuleBasedHostResolverProc>>
rules_map_;
RuleResolver rule_resolver_;
std::unique_ptr<HostCache> cache_;
const int initial_cache_invalidation_num_;
@ -318,10 +394,11 @@ class MockHostResolverBase
class MockHostResolver : public MockHostResolverBase {
public:
explicit MockHostResolver(bool require_matching_rule = false)
: MockHostResolverBase(false /*use_caching*/,
0 /* cache_invalidation_num */,
require_matching_rule) {}
explicit MockHostResolver(
absl::optional<RuleResolver::RuleResult> default_result = absl::nullopt)
: MockHostResolverBase(/*use_caching=*/false,
/*cache_invalidation_num=*/0,
RuleResolver(std::move(default_result))) {}
~MockHostResolver() override = default;
};
@ -335,11 +412,12 @@ class MockCachingHostResolver : public MockHostResolverBase {
// If > 0, |cache_invalidation_num| is the number of times a cached entry can
// be read before it invalidates itself. Useful to force cache expiration
// scenarios.
explicit MockCachingHostResolver(int cache_invalidation_num = 0,
bool require_matching_rule = false)
: MockHostResolverBase(true /*use_caching*/,
explicit MockCachingHostResolver(
int cache_invalidation_num = 0,
absl::optional<RuleResolver::RuleResult> default_result = absl::nullopt)
: MockHostResolverBase(/*use_caching=*/true,
cache_invalidation_num,
require_matching_rule) {}
RuleResolver(std::move(default_result))) {}
~MockCachingHostResolver() override = default;
};
@ -351,10 +429,10 @@ class MockCachingHostResolver : public MockHostResolverBase {
// factory construction and |enable_caching| is set in the creation method.
class MockHostResolverFactory : public HostResolver::Factory {
public:
MockHostResolverFactory(
scoped_refptr<RuleBasedHostResolverProc> rules = nullptr,
bool use_caching = false,
int cache_invalidation_num = 0);
explicit MockHostResolverFactory(MockHostResolverBase::RuleResolver rules =
MockHostResolverBase::RuleResolver(),
bool use_caching = false,
int cache_invalidation_num = 0);
MockHostResolverFactory(const MockHostResolverFactory&) = delete;
MockHostResolverFactory& operator=(const MockHostResolverFactory&) = delete;
@ -372,7 +450,7 @@ class MockHostResolverFactory : public HostResolver::Factory {
bool enable_caching) override;
private:
const scoped_refptr<RuleBasedHostResolverProc> rules_;
const MockHostResolverBase::RuleResolver rules_;
const bool use_caching_;
const int cache_invalidation_num_;
};

9
net/http/http_auth_handler_negotiate_unittest.cc

@ -64,9 +64,12 @@ class HttpAuthHandlerNegotiateTest : public PlatformTest,
#else
auth_library_ = new MockAuthLibrary();
#endif
resolver_ = std::make_unique<MockCachingHostResolver>();
resolver_->rules_map()[HostResolverSource::ANY]->AddIPLiteralRule(
"alias", "10.0.0.2", "canonical.example.com");
resolver_ = std::make_unique<MockCachingHostResolver>(
/*cache_invalidation_num=*/0,
/*default_result=*/MockHostResolverBase::RuleResolver::
GetLocalhostResult());
resolver_->rules()->AddIPLiteralRule("alias", "10.0.0.2",
"canonical.example.com");
http_auth_preferences_ = std::make_unique<MockAllowHttpAuthPreferences>();
factory_ = std::make_unique<HttpAuthHandlerNegotiate::Factory>(

4
net/http/http_network_layer_unittest.cc

@ -265,7 +265,9 @@ class HttpNetworkLayerTest : public PlatformTest, public WithTaskEnvironment {
}
MockClientSocketFactory mock_socket_factory_;
MockHostResolver host_resolver_;
MockHostResolver host_resolver_{
/*default_result=*/
MockHostResolverBase::RuleResolver::GetLocalhostResult()};
std::unique_ptr<CertVerifier> cert_verifier_;
std::unique_ptr<TransportSecurityState> transport_security_state_;
DefaultCTPolicyEnforcer ct_policy_enforcer_;

27
net/http/http_network_transaction_unittest.cc

@ -17152,6 +17152,8 @@ TEST_F(HttpNetworkTransactionTest, CertificateRequestInRenego) {
TEST_F(HttpNetworkTransactionTest, UseIPConnectionPooling) {
// Set up a special HttpNetworkSession with a MockCachingHostResolver.
session_deps_.host_resolver = std::make_unique<MockCachingHostResolver>();
session_deps_.host_resolver->rules()->AddRule("www.example.org", "1.2.3.4");
session_deps_.host_resolver->rules()->AddRule("mail.example.com", "1.2.3.4");
std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
AddSSLSocketData();
@ -17236,6 +17238,8 @@ TEST_F(HttpNetworkTransactionTest, UseIPConnectionPooling) {
TEST_F(HttpNetworkTransactionTest, UseIPConnectionPoolingAfterResolution) {
// Set up a special HttpNetworkSession with a MockCachingHostResolver.
session_deps_.host_resolver = std::make_unique<MockCachingHostResolver>();
session_deps_.host_resolver->rules()->AddRule("www.example.org", "1.2.3.4");
session_deps_.host_resolver->rules()->AddRule("mail.example.com", "1.2.3.4");
std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
AddSSLSocketData();
@ -17380,7 +17384,7 @@ TEST_F(HttpNetworkTransactionTest, RetryWithoutConnectionPooling) {
// Preload mail.example.org into HostCache.
int rv = session_deps_.host_resolver->LoadIntoCache(
HostPortPair("mail.example.com", 443), NetworkIsolationKey(),
HostPortPair("mail.example.org", 443), NetworkIsolationKey(),
absl::nullopt);
EXPECT_THAT(rv, IsOk());
@ -17507,7 +17511,7 @@ TEST_F(HttpNetworkTransactionTest, ReturnHTTP421OnRetry) {
// Preload mail.example.org into HostCache.
int rv = session_deps_.host_resolver->LoadIntoCache(
HostPortPair("mail.example.com", 443), NetworkIsolationKey(),
HostPortPair("mail.example.org", 443), NetworkIsolationKey(),
absl::nullopt);
EXPECT_THAT(rv, IsOk());
@ -17567,6 +17571,8 @@ TEST_F(HttpNetworkTransactionTest,
// Set up HostResolver to invalidate cached entries after 1 cached resolve.
session_deps_.host_resolver =
std::make_unique<MockCachingHostResolver>(1 /* cache_invalidation_num */);
session_deps_.host_resolver->rules()->AddRule("www.example.org", "1.2.3.4");
session_deps_.host_resolver->rules()->AddRule("mail.example.com", "1.2.3.4");
std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
AddSSLSocketData();
@ -20837,7 +20843,7 @@ TEST_F(HttpNetworkTransactionNetworkErrorLoggingTest,
// Preload mail.example.org into HostCache.
int rv = session_deps_.host_resolver->LoadIntoCache(
HostPortPair("mail.example.com", 443), NetworkIsolationKey(),
HostPortPair("mail.example.org", 443), NetworkIsolationKey(),
absl::nullopt);
EXPECT_THAT(rv, IsOk());
@ -23540,10 +23546,8 @@ TEST_F(HttpNetworkTransactionTest, RequestWithDnsAliases) {
// Add a rule with DNS aliases to the host resolver.
std::vector<std::string> aliases({"alias1", "alias2", "www.example.org"});
auto* rules = session_deps_.host_resolver->rules();
rules->AddIPLiteralRuleWithDnsAliases("www.example.org", "127.0.0.1",
std::move(aliases));
session_deps_.host_resolver->set_rules(rules);
session_deps_.host_resolver->rules()->AddIPLiteralRuleWithDnsAliases(
"www.example.org", "127.0.0.1", std::move(aliases));
// Create a HttpNetworkSession.
std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
@ -23596,13 +23600,8 @@ TEST_F(HttpNetworkTransactionTest, RequestWithNoAdditionalDnsAliases) {
request.traffic_annotation =
net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
// Add a rule without DNS aliases to the host resolver. The parameter is an
// empty vector.
std::vector<std::string> aliases;
auto* rules = session_deps_.host_resolver->rules();
rules->AddIPLiteralRuleWithDnsAliases("www.example.org", "127.0.0.1",
std::move(aliases));
session_deps_.host_resolver->set_rules(rules);
// Add a rule without DNS aliases to the host resolver.
session_deps_.host_resolver->rules()->AddRule("www.example.org", "127.0.0.1");
// Create a HttpNetworkSession.
std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));

4
net/http/http_proxy_connect_job_unittest.cc

@ -61,7 +61,9 @@ class HttpProxyConnectJobTest : public ::testing::TestWithParam<HttpProxyType>,
: WithTaskEnvironment(
base::test::TaskEnvironment::TimeSource::MOCK_TIME) {
// Used a mock HostResolver that does not have a cache.
session_deps_.host_resolver = std::make_unique<MockHostResolver>();
session_deps_.host_resolver = std::make_unique<MockHostResolver>(
/*default_result=*/MockHostResolverBase::RuleResolver::
GetLocalhostResult());
network_quality_estimator_ =
std::make_unique<TestNetworkQualityEstimator>();

1
net/http/http_stream_factory_job_controller_unittest.cc

@ -1760,6 +1760,7 @@ TEST_F(HttpStreamFactoryJobControllerTest, InvalidPortForQuic) {
TEST_F(HttpStreamFactoryJobControllerTest, HostResolutionHang) {
auto hanging_resolver = std::make_unique<MockHostResolver>();
hanging_resolver->set_ondemand_mode(true);
hanging_resolver->rules()->AddRule("www.google.com", "1.2.3.4");
session_deps_.host_resolver = std::move(hanging_resolver);
HttpRequestInfo request_info;

7
net/http/http_stream_factory_unittest.cc

@ -869,6 +869,9 @@ TEST_F(HttpStreamFactoryTest, QuicProxyMarkedAsBad) {
session_context.http_server_properties = &http_server_properties;
session_context.quic_context = &quic_context;
host_resolver.rules()->AddRule("www.google.com", "2.3.4.5");
host_resolver.rules()->AddRule("bad", "1.2.3.4");
auto session =
std::make_unique<HttpNetworkSession>(session_params, session_context);
session->quic_stream_factory()
@ -2096,7 +2099,9 @@ class HttpStreamFactoryBidirectionalQuicTest
HttpServerProperties http_server_properties_;
TransportSecurityState transport_security_state_;
DefaultCTPolicyEnforcer ct_policy_enforcer_;
MockHostResolver host_resolver_;
MockHostResolver host_resolver_{
/*default_result=*/
MockHostResolverBase::RuleResolver::GetLocalhostResult()};
std::unique_ptr<ProxyResolutionService> proxy_resolution_service_;
std::unique_ptr<SSLConfigServiceDefaults> ssl_config_service_;
HttpNetworkSessionParams params_;

18
net/nqe/network_quality_estimator_util_unittest.cc

@ -44,16 +44,11 @@ TEST(NetworkQualityEstimatorUtilTest, MAYBE_ReservedHost) {
MockCachingHostResolver mock_host_resolver;
scoped_refptr<net::RuleBasedHostResolverProc> rules(
new net::RuleBasedHostResolverProc(nullptr));
// example1.com resolves to a private IP address.
rules->AddRule("example1.com", "127.0.0.3");
mock_host_resolver.rules()->AddRule("example1.com", "127.0.0.3");
// example2.com resolves to a public IP address.
rules->AddRule("example2.com", "27.0.0.3");
mock_host_resolver.set_rules(rules.get());
mock_host_resolver.rules()->AddRule("example2.com", "27.0.0.3");
EXPECT_EQ(0u, mock_host_resolver.num_resolve());
@ -109,8 +104,7 @@ TEST(NetworkQualityEstimatorUtilTest, MAYBE_ReservedHostUncached) {
new net::RuleBasedHostResolverProc(nullptr));
// Add example3.com resolution to the DNS cache.
rules->AddRule("example3.com", "127.0.0.3");
mock_host_resolver.set_rules(rules.get());
mock_host_resolver.rules()->AddRule("example3.com", "127.0.0.3");
// Not in DNS host cache, so should not be marked as private.
EXPECT_FALSE(IsPrivateHostForTesting(&mock_host_resolver,
@ -155,12 +149,8 @@ TEST(NetworkQualityEstimatorUtilTest,
MockCachingHostResolver mock_host_resolver;
scoped_refptr<net::RuleBasedHostResolverProc> rules(
new net::RuleBasedHostResolverProc(nullptr));
// Add example3.com resolution to the DNS cache.
rules->AddRule("example3.com", "127.0.0.3");
mock_host_resolver.set_rules(rules.get());
mock_host_resolver.rules()->AddRule("example3.com", "127.0.0.3");
// Not in DNS host cache, so should not be marked as private.
EXPECT_FALSE(IsPrivateHostForTesting(&mock_host_resolver,

18
net/nqe/throughput_analyzer_unittest.cc

@ -88,13 +88,11 @@ class TestThroughputAnalyzer : public internal::ThroughputAnalyzer {
// Uses a mock resolver to force example.com to resolve to a public IP
// address.
void AddIPAddressResolution(TestURLRequestContext* context) {
scoped_refptr<net::RuleBasedHostResolverProc> rules =
base::MakeRefCounted<RuleBasedHostResolverProc>(nullptr);
mock_host_resolver_.rules()->ClearRules();
// example.com resolves to a public IP address.
rules->AddRule("example.com", "27.0.0.3");
mock_host_resolver_.rules()->AddRule("example.com", "27.0.0.3");
// local.com resolves to a private IP address.
rules->AddRule("local.com", "127.0.0.1");
mock_host_resolver_.set_rules(rules.get());
mock_host_resolver_.rules()->AddRule("local.com", "127.0.0.1");
mock_host_resolver_.LoadIntoCache(HostPortPair("example.com", 80),
NetworkIsolationKey(), absl::nullopt);
mock_host_resolver_.LoadIntoCache(HostPortPair("local.com", 80),
@ -205,18 +203,14 @@ TEST_F(ThroughputAnalyzerTest, MAYBE_MaximumRequestsWithNetworkIsolationKey) {
// Add an entry to the host cache mapping kUrl to non-local IP when using an
// empty NetworkIsolationKey.
scoped_refptr<net::RuleBasedHostResolverProc> rules =
base::MakeRefCounted<RuleBasedHostResolverProc>(nullptr);
rules->AddRule(kUrl.host(), "1.2.3.4");
mock_host_resolver.set_rules(rules.get());
mock_host_resolver.rules()->AddRule(kUrl.host(), "1.2.3.4");
mock_host_resolver.LoadIntoCache(HostPortPair::FromURL(kUrl),
NetworkIsolationKey(), absl::nullopt);
// Add an entry to the host cache mapping kUrl to local IP when using
// kNetworkIsolationKey.
rules = base::MakeRefCounted<RuleBasedHostResolverProc>(nullptr);
rules->AddRule(kUrl.host(), "127.0.0.1");
mock_host_resolver.set_rules(rules.get());
mock_host_resolver.rules()->ClearRules();
mock_host_resolver.rules()->AddRule(kUrl.host(), "127.0.0.1");
mock_host_resolver.LoadIntoCache(HostPortPair::FromURL(kUrl),
kNetworkIsolationKey, absl::nullopt);

17
net/proxy_resolution/pac_file_decider_unittest.cc

@ -352,7 +352,7 @@ class PacFileDeciderQuickCheckTest : public ::testing::Test,
}
protected:
MockHostResolver resolver_{/*require_matching_rule=*/true};
MockHostResolver resolver_;
Rules rules_;
Rules::Rule rule_;
TestCompletionCallback callback_;
@ -368,8 +368,7 @@ class PacFileDeciderQuickCheckTest : public ::testing::Test,
// Fails if a synchronous DNS lookup success for wpad causes QuickCheck to fail.
TEST_F(PacFileDeciderQuickCheckTest, SyncSuccess) {
resolver_.set_synchronous_mode(true);
resolver_.rules_map()[HostResolverSource::SYSTEM]->AddRuleWithFlags(
"wpad", "1.2.3.4", HOST_RESOLVER_AVOID_MULTICAST);
resolver_.rules()->AddRule("wpad", "1.2.3.4");
EXPECT_THAT(StartDecider(), IsOk());
EXPECT_EQ(rule_.text(), decider_->script_data().data->utf16());
@ -383,8 +382,7 @@ TEST_F(PacFileDeciderQuickCheckTest, SyncSuccess) {
// fail.
TEST_F(PacFileDeciderQuickCheckTest, AsyncSuccess) {
resolver_.set_ondemand_mode(true);
resolver_.rules_map()[HostResolverSource::SYSTEM]->AddRuleWithFlags(
"wpad", "1.2.3.4", HOST_RESOLVER_AVOID_MULTICAST);
resolver_.rules()->AddRule("wpad", "1.2.3.4");
EXPECT_THAT(StartDecider(), IsError(ERR_IO_PENDING));
ASSERT_TRUE(resolver_.has_pending_requests());
@ -409,8 +407,7 @@ TEST_F(PacFileDeciderQuickCheckTest, AsyncSuccess) {
// PacFileDecider to yield a PAC URL.
TEST_F(PacFileDeciderQuickCheckTest, AsyncFail) {
resolver_.set_ondemand_mode(true);
resolver_.rules_map()[HostResolverSource::SYSTEM]->AddSimulatedFailure(
"wpad", HOST_RESOLVER_AVOID_MULTICAST);
resolver_.rules()->AddRule("wpad", ERR_NAME_NOT_RESOLVED);
EXPECT_THAT(StartDecider(), IsError(ERR_IO_PENDING));
ASSERT_TRUE(resolver_.has_pending_requests());
@ -472,10 +469,8 @@ TEST_F(PacFileDeciderQuickCheckTest, ExplicitPacUrl) {
const char* kCustomUrl = "http://custom/proxy.pac";
config_.set_pac_url(GURL(kCustomUrl));
Rules::Rule rule = rules_.AddSuccessRule(kCustomUrl);
resolver_.rules_map()[HostResolverSource::SYSTEM]->AddSimulatedFailure(
"wpad", HOST_RESOLVER_AVOID_MULTICAST);
resolver_.rules_map()[HostResolverSource::SYSTEM]->AddRuleWithFlags(
"custom", "1.2.3.4", HOST_RESOLVER_AVOID_MULTICAST);
resolver_.rules()->AddRule("wpad", ERR_NAME_NOT_RESOLVED);
resolver_.rules()->AddRule("custom", "1.2.3.4");
EXPECT_THAT(StartDecider(), IsError(ERR_IO_PENDING));
callback_.WaitForResult();
EXPECT_TRUE(decider_->effective_config().value().has_pac_url());

12
net/proxy_resolution/pac_file_fetcher_impl_unittest.cc

@ -79,7 +79,9 @@ class RequestContext : public URLRequestContext {
public:
RequestContext() : storage_(this) {
ProxyConfig no_proxy;
storage_.set_host_resolver(std::make_unique<MockCachingHostResolver>());
storage_.set_host_resolver(std::make_unique<MockCachingHostResolver>(
/*cache_invalidation_num=*/0, /*default_result=*/
MockHostResolverBase::RuleResolver::GetLocalhostResult()));
storage_.set_cert_verifier(std::make_unique<MockCertVerifier>());
storage_.set_transport_security_state(
std::make_unique<TransportSecurityState>());
@ -303,13 +305,12 @@ TEST_F(PacFileFetcherImplTest, IsolationInfo) {
// Check that the URL in kDestination is in the HostCache, with
// the fetcher's IsolationInfo / NetworkIsolationKey, and no others.
const net::HostPortPair kHostPortPair =
net::HostPortPair(kHost, 0 /* port */);
net::HostResolver::ResolveHostParameters params;
params.source = net::HostResolverSource::LOCAL_ONLY;
std::unique_ptr<net::HostResolver::ResolveHostRequest> host_request =
context_.host_resolver()->CreateRequest(
kHostPortPair, pac_fetcher->isolation_info().network_isolation_key(),
url::SchemeHostPort(url),
pac_fetcher->isolation_info().network_isolation_key(),
net::NetLogWithSource(), params);
net::TestCompletionCallback callback2;
result = host_request->Start(callback2.callback());
@ -322,7 +323,8 @@ TEST_F(PacFileFetcherImplTest, IsolationInfo) {
// Make sure the cache is actually returning different results based on
// NetworkIsolationKey.
host_request = context_.host_resolver()->CreateRequest(
kHostPortPair, NetworkIsolationKey(), net::NetLogWithSource(), params);
url::SchemeHostPort(url), NetworkIsolationKey(), net::NetLogWithSource(),
params);
net::TestCompletionCallback callback3;
result = host_request->Start(callback3.callback());
EXPECT_EQ(net::ERR_NAME_NOT_RESOLVED, callback3.GetResult(result));

10
net/quic/quic_network_transaction_unittest.cc

@ -1014,7 +1014,8 @@ class QuicNetworkTransactionTest
MockClientSocketFactory socket_factory_;
ProofVerifyDetailsChromium verify_details_;
MockCryptoClientStreamFactory crypto_client_stream_factory_;
MockHostResolver host_resolver_;
MockHostResolver host_resolver_{/*default_result=*/MockHostResolverBase::
RuleResolver::GetLocalhostResult()};
MockCertVerifier cert_verifier_;
TransportSecurityState transport_security_state_;
DefaultCTPolicyEnforcer ct_policy_enforcer_;
@ -6833,7 +6834,9 @@ class QuicURLRequestContext : public URLRequestContext {
MockClientSocketFactory* socket_factory)
: storage_(this) {
socket_factory_ = socket_factory;
storage_.set_host_resolver(std::make_unique<MockHostResolver>());
storage_.set_host_resolver(std::make_unique<MockHostResolver>(
/*default_result=*/MockHostResolverBase::RuleResolver::
GetLocalhostResult()));
storage_.set_cert_verifier(std::make_unique<MockCertVerifier>());
storage_.set_transport_security_state(
std::make_unique<TransportSecurityState>());
@ -7150,7 +7153,8 @@ class QuicNetworkTransactionWithDestinationTest
MockQuicContext context_;
std::unique_ptr<HttpNetworkSession> session_;
MockClientSocketFactory socket_factory_;
MockHostResolver host_resolver_;
MockHostResolver host_resolver_{/*default_result=*/MockHostResolverBase::
RuleResolver::GetLocalhostResult()};
MockCertVerifier cert_verifier_;
TransportSecurityState transport_security_state_;
DefaultCTPolicyEnforcer ct_policy_enforcer_;

392
net/quic/quic_stream_factory_test.cc

@ -204,7 +204,9 @@ class QuicStreamFactoryTestBase : public WithTaskEnvironment {
protected:
QuicStreamFactoryTestBase(quic::ParsedQuicVersion version,
bool client_headers_include_h2_stream_dependency)
: host_resolver_(new MockHostResolver),
: host_resolver_(
new MockHostResolver(/*default_result=*/MockHostResolverBase::
RuleResolver::GetLocalhostResult())),
ssl_config_service_(new SSLConfigServiceDefaults),
socket_factory_(new MockClientSocketFactory),
runner_(new TestTaskRunner(context_.mock_clock())),
@ -802,6 +804,7 @@ class QuicStreamFactoryTestBase : public WithTaskEnvironment {
socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
socket_data2.AddSocketDataToFactory(socket_factory_.get());
host_resolver_->rules()->ClearRules();
host_resolver_->rules()->AddIPLiteralRule(scheme_host_port_.host(),
"192.168.0.2", "");
@ -13827,22 +13830,21 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceAndHostResolutionSync) {
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
// Set an address in resolver for synchronous return.
// Set up an address in stale resolver cache.
host_resolver_->set_synchronous_mode(true);
host_resolver_->rules()->AddIPLiteralRule(scheme_host_port_.host(),
kNonCachedIPAddress, "");
host_resolver_->rules()->AddRule(
scheme_host_port_.host(),
AddressList::CreateFromIPAddress(kCachedIPAddress, 0));
host_resolver_->LoadIntoCache(scheme_host_port_, NetworkIsolationKey(),
/*optional_parameters=*/absl::nullopt);
// Set up a different address in stale resolver cache.
HostCache::Key key(scheme_host_port_.host(), DnsQueryType::UNSPECIFIED, 0,
HostResolverSource::ANY, NetworkIsolationKey());
HostCache::Entry entry(OK,
AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
HostCache::Entry::SOURCE_DNS);
base::TimeDelta zero;
HostCache* cache = host_resolver_->GetHostCache();
cache->Set(key, entry, base::TimeTicks::Now(), zero);
// Expire the cache
cache->Invalidate();
host_resolver_->GetHostCache()->Invalidate();
// Change to different address for fresh host resolutions.
host_resolver_->rules()->ClearRules();
host_resolver_->rules()->AddRule(scheme_host_port_.host(),
kNonCachedIPAddress);
MockQuicData quic_data(version_);
quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
@ -13925,22 +13927,16 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceHostResolveAsyncStaleMatch) {
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
// Set an address in resolver for asynchronous return.
// Set up an address in stale resolver cache.
host_resolver_->set_ondemand_mode(true);
host_resolver_->rules()->AddIPLiteralRule(scheme_host_port_.host(),
kCachedIPAddress.ToString(), "");
host_resolver_->rules()->AddRule(
scheme_host_port_.host(),
AddressList::CreateFromIPAddress(kCachedIPAddress, 0));
host_resolver_->LoadIntoCache(scheme_host_port_, NetworkIsolationKey(),
/*optional_parameters=*/absl::nullopt);
// Set up the same address in the stale resolver cache.
HostCache::Key key(scheme_host_port_.host(), DnsQueryType::UNSPECIFIED, 0,
HostResolverSource::ANY, NetworkIsolationKey());
HostCache::Entry entry(OK,
AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
HostCache::Entry::SOURCE_DNS);
base::TimeDelta zero;
HostCache* cache = host_resolver_->GetHostCache();
cache->Set(key, entry, base::TimeTicks::Now(), zero);
// Expire the cache
cache->Invalidate();
host_resolver_->GetHostCache()->Invalidate();
MockQuicData quic_data(version_);
quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
@ -13986,25 +13982,20 @@ TEST_P(QuicStreamFactoryTest,
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
// Set an address in resolver for asynchronous return.
// Set up an address in stale resolver cache.
host_resolver_->set_ondemand_mode(true);
host_resolver_->rules()->AddRule(
scheme_host_port_.host(),
AddressList::CreateFromIPAddress(kCachedIPAddress, 0));
host_resolver_->LoadIntoCache(scheme_host_port_, NetworkIsolationKey(),
/*optional_parameters=*/absl::nullopt);
// Expire the cache
host_resolver_->GetHostCache()->Invalidate();
factory_->set_is_quic_known_to_work_on_current_network(false);
crypto_client_stream_factory_.set_handshake_mode(
MockCryptoClientStream::ZERO_RTT);
host_resolver_->rules()->AddIPLiteralRule(scheme_host_port_.host(),
kCachedIPAddress.ToString(), "");
// Set up the same address in the stale resolver cache.
HostCache::Key key(scheme_host_port_.host(), DnsQueryType::UNSPECIFIED, 0,
HostResolverSource::ANY, NetworkIsolationKey());
HostCache::Entry entry(OK,
AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
HostCache::Entry::SOURCE_DNS);
base::TimeDelta zero;
HostCache* cache = host_resolver_->GetHostCache();
cache->Set(key, entry, base::TimeTicks::Now(), zero);
// Expire the cache
cache->Invalidate();
MockQuicData quic_data(version_);
quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
@ -14057,25 +14048,20 @@ TEST_P(QuicStreamFactoryTest,
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
// Set an address in resolver for asynchronous return.
// Set up an address in stale resolver cache.
host_resolver_->set_ondemand_mode(true);
host_resolver_->rules()->AddRule(
scheme_host_port_.host(),
AddressList::CreateFromIPAddress(kCachedIPAddress, 0));
host_resolver_->LoadIntoCache(scheme_host_port_, NetworkIsolationKey(),
/*optional_parameters=*/absl::nullopt);
// Expire the cache
host_resolver_->GetHostCache()->Invalidate();
factory_->set_is_quic_known_to_work_on_current_network(false);
crypto_client_stream_factory_.set_handshake_mode(
MockCryptoClientStream::ZERO_RTT);
host_resolver_->rules()->AddIPLiteralRule(scheme_host_port_.host(),
kCachedIPAddress.ToString(), "");
// Set up the same address in the stale resolver cache.
HostCache::Key key(scheme_host_port_.host(), DnsQueryType::UNSPECIFIED, 0,
HostResolverSource::ANY, NetworkIsolationKey());
HostCache::Entry entry(OK,
AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
HostCache::Entry::SOURCE_DNS);
base::TimeDelta zero;
HostCache* cache = host_resolver_->GetHostCache();
cache->Set(key, entry, base::TimeTicks::Now(), zero);
// Expire the cache
cache->Invalidate();
MockQuicData quic_data(version_);
quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
@ -14124,22 +14110,21 @@ TEST_P(QuicStreamFactoryTest,
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
// Set an address in resolver for asynchronous return.
// Set up an address in stale resolver cache.
host_resolver_->set_ondemand_mode(true);
host_resolver_->rules()->AddIPLiteralRule(scheme_host_port_.host(),
kNonCachedIPAddress, "");
host_resolver_->rules()->AddRule(
scheme_host_port_.host(),
AddressList::CreateFromIPAddress(kCachedIPAddress, 0));
host_resolver_->LoadIntoCache(scheme_host_port_, NetworkIsolationKey(),
/*optional_parameters=*/absl::nullopt);
// Set up a different address in the stale resolver cache.
HostCache::Key key(scheme_host_port_.host(), DnsQueryType::UNSPECIFIED, 0,
HostResolverSource::ANY, NetworkIsolationKey());
HostCache::Entry entry(OK,
AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
HostCache::Entry::SOURCE_DNS);
base::TimeDelta zero;
HostCache* cache = host_resolver_->GetHostCache();
cache->Set(key, entry, base::TimeTicks::Now(), zero);
// Expire the cache
cache->Invalidate();
host_resolver_->GetHostCache()->Invalidate();
// Change to different address for fresh host resolutions.
host_resolver_->rules()->ClearRules();
host_resolver_->rules()->AddRule(scheme_host_port_.host(),
kNonCachedIPAddress);
// Socket for the stale connection which will invoke connection closure.
MockQuicData quic_data(version_);
@ -14202,25 +14187,25 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleAsyncResolveAsyncNoMatch) {
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
// Set an address in resolver for asynchronous return.
// Set up an address in stale resolver cache.
host_resolver_->set_ondemand_mode(true);
host_resolver_->rules()->AddRule(
scheme_host_port_.host(),
AddressList::CreateFromIPAddress(kCachedIPAddress, 0));
host_resolver_->LoadIntoCache(scheme_host_port_, NetworkIsolationKey(),
/*optional_parameters=*/absl::nullopt);
// Expire the cache
host_resolver_->GetHostCache()->Invalidate();
// Change to different address for fresh host resolutions.
host_resolver_->rules()->ClearRules();
host_resolver_->rules()->AddRule(scheme_host_port_.host(),
kNonCachedIPAddress);
factory_->set_is_quic_known_to_work_on_current_network(false);
crypto_client_stream_factory_.set_handshake_mode(
MockCryptoClientStream::ZERO_RTT);
host_resolver_->rules()->AddIPLiteralRule(scheme_host_port_.host(),
kNonCachedIPAddress, "");
// Set up a different address in the stale resolver cache.
HostCache::Key key(scheme_host_port_.host(), DnsQueryType::UNSPECIFIED, 0,
HostResolverSource::ANY, NetworkIsolationKey());
HostCache::Entry entry(OK,
AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
HostCache::Entry::SOURCE_DNS);
base::TimeDelta zero;
HostCache* cache = host_resolver_->GetHostCache();
cache->Set(key, entry, base::TimeTicks::Now(), zero);
// Expire the cache
cache->Invalidate();
MockQuicData quic_data(version_);
quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
@ -14287,25 +14272,25 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceResolveAsyncStaleAsyncNoMatch) {
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
// Set an address in resolver for asynchronous return.
// Set up an address in stale resolver cache.
host_resolver_->set_ondemand_mode(true);
host_resolver_->rules()->AddRule(
scheme_host_port_.host(),
AddressList::CreateFromIPAddress(kCachedIPAddress, 0));
host_resolver_->LoadIntoCache(scheme_host_port_, NetworkIsolationKey(),
/*optional_parameters=*/absl::nullopt);
// Expire the cache
host_resolver_->GetHostCache()->Invalidate();
// Change to different address for fresh host resolutions.
host_resolver_->rules()->ClearRules();
host_resolver_->rules()->AddRule(scheme_host_port_.host(),
kNonCachedIPAddress);
factory_->set_is_quic_known_to_work_on_current_network(false);
crypto_client_stream_factory_.set_handshake_mode(
MockCryptoClientStream::ZERO_RTT);
host_resolver_->rules()->AddIPLiteralRule(scheme_host_port_.host(),
kNonCachedIPAddress, "");
// Set up a different address in the stale resolver cache.
HostCache::Key key(scheme_host_port_.host(), DnsQueryType::UNSPECIFIED, 0,
HostResolverSource::ANY, NetworkIsolationKey());
HostCache::Entry entry(OK,
AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
HostCache::Entry::SOURCE_DNS);
base::TimeDelta zero;
HostCache* cache = host_resolver_->GetHostCache();
cache->Set(key, entry, base::TimeTicks::Now(), zero);
// Expire the cache
cache->Invalidate();
MockQuicData quic_data(version_);
quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
@ -14419,21 +14404,21 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleSyncHostResolveError) {
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
// Set asynchronous failure in resolver.
// Set up an address in stale resolver cache.
host_resolver_->set_ondemand_mode(true);
host_resolver_->rules()->AddSimulatedFailure(scheme_host_port_.host());
host_resolver_->rules()->AddRule(
scheme_host_port_.host(),
AddressList::CreateFromIPAddress(kCachedIPAddress, 0));
host_resolver_->LoadIntoCache(scheme_host_port_, NetworkIsolationKey(),
/*optional_parameters=*/absl::nullopt);
// Set up an address in the stale cache.
HostCache::Key key(scheme_host_port_.host(), DnsQueryType::UNSPECIFIED, 0,
HostResolverSource::ANY, NetworkIsolationKey());
HostCache::Entry entry(OK,
AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
HostCache::Entry::SOURCE_DNS);
base::TimeDelta zero;
HostCache* cache = host_resolver_->GetHostCache();
cache->Set(key, entry, base::TimeTicks::Now(), zero);
// Expire the cache
cache->Invalidate();
host_resolver_->GetHostCache()->Invalidate();
// Change to failure for fresh host resolutions.
host_resolver_->rules()->ClearRules();
host_resolver_->rules()->AddRule(scheme_host_port_.host(),
ERR_NAME_NOT_RESOLVED);
// Socket for the stale connection which is supposed to disconnect.
MockQuicData quic_data(version_);
@ -14480,22 +14465,16 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleErrorDNSMatches) {
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
// Set an address in host resolver for asynchronous return.
// Set up an address in stale resolver cache.
host_resolver_->set_ondemand_mode(true);
host_resolver_->rules()->AddIPLiteralRule(scheme_host_port_.host(),
kCachedIPAddress.ToString(), "");
host_resolver_->rules()->AddRule(
scheme_host_port_.host(),
AddressList::CreateFromIPAddress(kCachedIPAddress, 0));
host_resolver_->LoadIntoCache(scheme_host_port_, NetworkIsolationKey(),
/*optional_parameters=*/absl::nullopt);
// Set up the same address in the stale resolver cache.
HostCache::Key key(scheme_host_port_.host(), DnsQueryType::UNSPECIFIED, 0,
HostResolverSource::ANY, NetworkIsolationKey());
HostCache::Entry entry(OK,
AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
HostCache::Entry::SOURCE_DNS);
base::TimeDelta zero;
HostCache* cache = host_resolver_->GetHostCache();
cache->Set(key, entry, base::TimeTicks::Now(), zero);
// Expire the cache
cache->Invalidate();
host_resolver_->GetHostCache()->Invalidate();
// Simulate synchronous connect failure.
MockQuicData quic_data(version_);
@ -14530,22 +14509,21 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleErrorDNSNoMatch) {
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
// Set an address in host resolver.
// Set up an address in stale resolver cache.
host_resolver_->set_ondemand_mode(true);
host_resolver_->rules()->AddIPLiteralRule(scheme_host_port_.host(),
kNonCachedIPAddress, "");
host_resolver_->rules()->AddRule(
scheme_host_port_.host(),
AddressList::CreateFromIPAddress(kCachedIPAddress, 0));
host_resolver_->LoadIntoCache(scheme_host_port_, NetworkIsolationKey(),
/*optional_parameters=*/absl::nullopt);
// Set up a different address in stale resolver cache.
HostCache::Key key(scheme_host_port_.host(), DnsQueryType::UNSPECIFIED, 0,
HostResolverSource::ANY, NetworkIsolationKey());
HostCache::Entry entry(OK,
AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
HostCache::Entry::SOURCE_DNS);
base::TimeDelta zero;
HostCache* cache = host_resolver_->GetHostCache();
cache->Set(key, entry, base::TimeTicks::Now(), zero);
// Expire the cache
cache->Invalidate();
host_resolver_->GetHostCache()->Invalidate();
// Change to different address for fresh host resolutions.
host_resolver_->rules()->ClearRules();
host_resolver_->rules()->AddRule(scheme_host_port_.host(),
kNonCachedIPAddress);
// Add failure for the stale connection.
MockQuicData quic_data(version_);
@ -14596,22 +14574,21 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleErrorDNSNoMatchError) {
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
// Set an address in host resolver asynchronously.
// Set up an address in stale resolver cache.
host_resolver_->set_ondemand_mode(true);
host_resolver_->rules()->AddIPLiteralRule(scheme_host_port_.host(),
kNonCachedIPAddress, "");
host_resolver_->rules()->AddRule(
scheme_host_port_.host(),
AddressList::CreateFromIPAddress(kCachedIPAddress, 0));
host_resolver_->LoadIntoCache(scheme_host_port_, NetworkIsolationKey(),
/*optional_parameters=*/absl::nullopt);
// Set up a different address in the stale cache.
HostCache::Key key(scheme_host_port_.host(), DnsQueryType::UNSPECIFIED, 0,
HostResolverSource::ANY, NetworkIsolationKey());
HostCache::Entry entry(OK,
AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
HostCache::Entry::SOURCE_DNS);
base::TimeDelta zero;
HostCache* cache = host_resolver_->GetHostCache();
cache->Set(key, entry, base::TimeTicks::Now(), zero);
// Expire the cache
cache->Invalidate();
host_resolver_->GetHostCache()->Invalidate();
// Change to different address for fresh host resolutions.
host_resolver_->rules()->ClearRules();
host_resolver_->rules()->AddRule(scheme_host_port_.host(),
kNonCachedIPAddress);
// Add failure for stale connection.
MockQuicData quic_data(version_);
@ -14650,22 +14627,23 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceResolveAsyncErrorStaleAsync) {
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
// Add asynchronous failure in host resolver.
host_resolver_->set_ondemand_mode(true);
host_resolver_->rules()->AddSimulatedFailure(scheme_host_port_.host());
factory_->set_is_quic_known_to_work_on_current_network(false);
// Set up an address in stale resolver cache.
HostCache::Key key(scheme_host_port_.host(), DnsQueryType::UNSPECIFIED, 0,
HostResolverSource::ANY, NetworkIsolationKey());
HostCache::Entry entry(OK,
AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
HostCache::Entry::SOURCE_DNS);
base::TimeDelta zero;
HostCache* cache = host_resolver_->GetHostCache();
cache->Set(key, entry, base::TimeTicks::Now(), zero);
host_resolver_->set_ondemand_mode(true);
host_resolver_->rules()->AddRule(
scheme_host_port_.host(),
AddressList::CreateFromIPAddress(kCachedIPAddress, 0));
host_resolver_->LoadIntoCache(scheme_host_port_, NetworkIsolationKey(),
/*optional_parameters=*/absl::nullopt);
// Expire the cache
cache->Invalidate();
host_resolver_->GetHostCache()->Invalidate();
// Change to error for fresh host resolutions.
host_resolver_->rules()->ClearRules();
host_resolver_->rules()->AddRule(scheme_host_port_.host(),
ERR_NAME_NOT_RESOLVED);
factory_->set_is_quic_known_to_work_on_current_network(false);
// Socket data for stale connection which is supposed to disconnect.
MockQuicData quic_data(version_);
@ -14708,22 +14686,23 @@ TEST_P(QuicStreamFactoryTest,
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
// Add asynchronous failure to host resolver.
host_resolver_->set_ondemand_mode(true);
factory_->set_is_quic_known_to_work_on_current_network(false);
host_resolver_->rules()->AddSimulatedFailure(scheme_host_port_.host());
// Set up an address in stale resolver cache.
HostCache::Key key(scheme_host_port_.host(), DnsQueryType::UNSPECIFIED, 0,
HostResolverSource::ANY, NetworkIsolationKey());
HostCache::Entry entry(OK,
AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
HostCache::Entry::SOURCE_DNS);
base::TimeDelta zero;
HostCache* cache = host_resolver_->GetHostCache();
cache->Set(key, entry, base::TimeTicks::Now(), zero);
host_resolver_->set_ondemand_mode(true);
host_resolver_->rules()->AddRule(
scheme_host_port_.host(),
AddressList::CreateFromIPAddress(kCachedIPAddress, 0));
host_resolver_->LoadIntoCache(scheme_host_port_, NetworkIsolationKey(),
/*optional_parameters=*/absl::nullopt);
// Expire the cache
cache->Invalidate();
host_resolver_->GetHostCache()->Invalidate();
// Change to different address for fresh host resolutions.
host_resolver_->rules()->ClearRules();
host_resolver_->rules()->AddRule(scheme_host_port_.host(),
ERR_NAME_NOT_RESOLVED);
factory_->set_is_quic_known_to_work_on_current_network(false);
MockQuicData quic_data(version_);
quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
@ -14813,22 +14792,21 @@ TEST_P(QuicStreamFactoryTest, StaleNetworkFailedAfterHandshake) {
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
// Set an address in resolver for asynchronous return.
// Set up an address in stale resolver cache.
host_resolver_->set_ondemand_mode(true);
host_resolver_->rules()->AddIPLiteralRule(scheme_host_port_.host(),
kNonCachedIPAddress, "");
host_resolver_->rules()->AddRule(
scheme_host_port_.host(),
AddressList::CreateFromIPAddress(kCachedIPAddress, 0));
host_resolver_->LoadIntoCache(scheme_host_port_, NetworkIsolationKey(),
/*optional_parameters=*/absl::nullopt);
// Set up the same address in the stale resolver cache.
HostCache::Key key(scheme_host_port_.host(), DnsQueryType::UNSPECIFIED, 0,
HostResolverSource::ANY, NetworkIsolationKey());
HostCache::Entry entry(OK,
AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
HostCache::Entry::SOURCE_DNS);
base::TimeDelta zero;
HostCache* cache = host_resolver_->GetHostCache();
cache->Set(key, entry, base::TimeTicks::Now(), zero);
// Expire the cache
cache->Invalidate();
host_resolver_->GetHostCache()->Invalidate();
// Change to different address for fresh host resolutions.
host_resolver_->rules()->ClearRules();
host_resolver_->rules()->AddRule(scheme_host_port_.host(),
kNonCachedIPAddress);
MockQuicData quic_data(version_);
quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
@ -14887,25 +14865,25 @@ TEST_P(QuicStreamFactoryTest, StaleNetworkFailedBeforeHandshake) {
ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
// Set an address in resolver for asynchronous return.
// Set up an address in stale resolver cache.
host_resolver_->set_ondemand_mode(true);
host_resolver_->rules()->AddRule(
scheme_host_port_.host(),
AddressList::CreateFromIPAddress(kCachedIPAddress, 0));
host_resolver_->LoadIntoCache(scheme_host_port_, NetworkIsolationKey(),
/*optional_parameters=*/absl::nullopt);
// Expire the cache
host_resolver_->GetHostCache()->Invalidate();
// Change to different address for fresh host resolutions.
host_resolver_->rules()->ClearRules();
host_resolver_->rules()->AddRule(scheme_host_port_.host(),
kNonCachedIPAddress);
factory_->set_is_quic_known_to_work_on_current_network(false);
crypto_client_stream_factory_.set_handshake_mode(
MockCryptoClientStream::ZERO_RTT);
host_resolver_->rules()->AddIPLiteralRule(scheme_host_port_.host(),
kNonCachedIPAddress, "");
// Set up a different address in the stale resolvercache.
HostCache::Key key(scheme_host_port_.host(), DnsQueryType::UNSPECIFIED, 0,
HostResolverSource::ANY, NetworkIsolationKey());
HostCache::Entry entry(OK,
AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
HostCache::Entry::SOURCE_DNS);
base::TimeDelta zero;
HostCache* cache = host_resolver_->GetHostCache();
cache->Set(key, entry, base::TimeTicks::Now(), zero);
// Expire the cache
cache->Invalidate();
MockQuicData quic_data(version_);
quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);

9
net/socket/socks_client_socket_fuzzer.cc

@ -37,21 +37,18 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
// Determine if the DNS lookup returns synchronously or asynchronously,
// succeeds or fails, and returns an IPv4 or IPv6 address.
net::MockHostResolver mock_host_resolver;
scoped_refptr<net::RuleBasedHostResolverProc> rules(
new net::RuleBasedHostResolverProc(nullptr));
mock_host_resolver.set_synchronous_mode(data_provider.ConsumeBool());
switch (data_provider.ConsumeIntegralInRange(0, 2)) {
case 0:
rules->AddRule("*", "127.0.0.1");
mock_host_resolver.rules()->AddRule("*", "127.0.0.1");
break;
case 1:
rules->AddRule("*", "::1");
mock_host_resolver.rules()->AddRule("*", "::1");
break;
case 2:
rules->AddSimulatedFailure("*");
mock_host_resolver.rules()->AddRule("*", net::ERR_NAME_NOT_RESOLVED);
break;
}
mock_host_resolver.set_rules(rules.get());
net::TestCompletionCallback callback;
std::unique_ptr<net::FuzzedSocket> fuzzed_socket(

7
net/socket/socks_client_socket_unittest.cc

@ -226,7 +226,7 @@ TEST_F(SOCKSClientSocketTest, HandshakeFailures) {
};
//---------------------------------------
host_resolver_->rules()->AddRule("socks.test", "127.0.0.1");
for (const auto& test : tests) {
MockWrite data_writes[] = {
MockWrite(SYNCHRONOUS, kSOCKS4OkRequestLocalHostPort80,
@ -236,7 +236,7 @@ TEST_F(SOCKSClientSocketTest, HandshakeFailures) {
RecordingNetLogObserver log_observer;
user_sock_ = BuildMockSocket(data_reads, data_writes, host_resolver_.get(),
"localhost", 80, NetLog::Get());
"socks.test", 80, NetLog::Get());
int rv = user_sock_->Connect(callback_.callback());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
@ -455,10 +455,11 @@ TEST_F(SOCKSClientSocketTest, SetSecureDnsPolicy) {
{SecureDnsPolicy::kAllow, SecureDnsPolicy::kDisable}) {
StaticSocketDataProvider data;
MockHostResolver host_resolver;
host_resolver.rules()->AddRule("doh.test", "127.0.0.1");
SOCKSClientSocket socket(
std::make_unique<MockTCPClientSocket>(address_list_, NetLog::Get(),
&data),
HostPortPair("localhost", 80), NetworkIsolationKey(), DEFAULT_PRIORITY,
HostPortPair("doh.test", 80), NetworkIsolationKey(), DEFAULT_PRIORITY,
&host_resolver, secure_dns_policy, TRAFFIC_ANNOTATION_FOR_TESTS);
EXPECT_EQ(ERR_IO_PENDING, socket.Connect(callback_.callback()));

3
net/socket/socks_connect_job_unittest.cc

@ -82,7 +82,8 @@ class SOCKSConnectJobTest : public testing::Test, public WithTaskEnvironment {
}
protected:
MockHostResolver host_resolver_;
MockHostResolver host_resolver_{/*default_result=*/MockHostResolverBase::
RuleResolver::GetLocalhostResult()};
MockTaggingClientSocketFactory client_socket_factory_;
const CommonConnectJobParams common_connect_job_params_;
};

3
net/socket/ssl_connect_job_unittest.cc

@ -167,7 +167,8 @@ class SSLConnectJobTest : public WithTaskEnvironment, public testing::Test {
protected:
MockClientSocketFactory socket_factory_;
MockHostResolver host_resolver_;
MockHostResolver host_resolver_{/*default_result=*/MockHostResolverBase::
RuleResolver::GetLocalhostResult()};
MockCertVerifier cert_verifier_;
TransportSecurityState transport_security_state_;
DefaultCTPolicyEnforcer ct_policy_enforcer_;

3
net/socket/transport_connect_job_unittest.cc

@ -68,7 +68,8 @@ class TransportConnectJobTest : public WithTaskEnvironment,
}
protected:
MockHostResolver host_resolver_;
MockHostResolver host_resolver_{/*default_result=*/MockHostResolverBase::
RuleResolver::GetLocalhostResult()};
MockTransportClientSocketFactory client_socket_factory_;
const CommonConnectJobParams common_connect_job_params_;
};

6
net/socket/websocket_transport_client_socket_pool_unittest.cc

@ -4,6 +4,7 @@
#include "net/socket/websocket_transport_client_socket_pool.h"
#include <memory>
#include <utility>
#include <vector>
@ -78,7 +79,10 @@ class WebSocketTransportClientSocketPoolTest : public TestWithTaskEnvironment {
NetworkIsolationKey(),
SecureDnsPolicy::kAllow),
params_(ClientSocketPool::SocketParams::CreateForHttpForTesting()),
host_resolver_(new MockHostResolver),
host_resolver_(std::make_unique<
MockHostResolver>(/*default_result=*/
MockHostResolverBase::RuleResolver::
GetLocalhostResult())),
client_socket_factory_(NetLog::Get()),
common_connect_job_params_(
&client_socket_factory_,

8
net/spdy/spdy_test_util_common.cc

@ -290,7 +290,9 @@ SpdySessionDependencies::SpdySessionDependencies()
SpdySessionDependencies::SpdySessionDependencies(
std::unique_ptr<ProxyResolutionService> proxy_resolution_service)
: host_resolver(std::make_unique<MockCachingHostResolver>()),
: host_resolver(std::make_unique<MockCachingHostResolver>(
/*cache_invalidation_num=*/0,
MockHostResolverBase::RuleResolver::GetLocalhostResult())),
cert_verifier(std::make_unique<MockCertVerifier>()),
transport_security_state(std::make_unique<TransportSecurityState>()),
ct_policy_enforcer(std::make_unique<DefaultCTPolicyEnforcer>()),
@ -411,7 +413,9 @@ HttpNetworkSessionContext SpdySessionDependencies::CreateSessionContext(
}
SpdyURLRequestContext::SpdyURLRequestContext() : storage_(this) {
storage_.set_host_resolver(std::make_unique<MockHostResolver>());
storage_.set_host_resolver(std::make_unique<MockHostResolver>(
/*default_result=*/MockHostResolverBase::RuleResolver::
GetLocalhostResult()));
storage_.set_cert_verifier(std::make_unique<MockCertVerifier>());
storage_.set_transport_security_state(
std::make_unique<TransportSecurityState>());

1
net/url_request/url_request_context_builder_unittest.cc

@ -242,7 +242,6 @@ TEST_F(URLRequestContextBuilderTest, ShutdownHostResolverWithPendingRequest) {
mock_host_resolver->ResolveAllPending();
EXPECT_FALSE(mock_host_resolver->has_pending_requests());
EXPECT_TRUE(mock_host_resolver->rules_map().empty());
// Request should never complete.
base::RunLoop().RunUntilIdle();

5
net/url_request/url_request_test_util.cc

@ -87,7 +87,10 @@ void TestURLRequestContext::Init() {
if (!host_resolver())
context_storage_.set_host_resolver(
std::unique_ptr<HostResolver>(new MockCachingHostResolver()));
std::unique_ptr<HostResolver>(new MockCachingHostResolver(
/*cache_invalidation_num=*/0,
/*default_result=*/net::MockHostResolverBase::RuleResolver::
GetLocalhostResult())));
if (!proxy_resolution_service())
context_storage_.set_proxy_resolution_service(
ConfiguredProxyResolutionService::CreateDirect());

82
net/url_request/url_request_unittest.cc

@ -151,6 +151,7 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/platform_test.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
#include "url/url_constants.h"
#include "url/url_util.h"
#if defined(OS_WIN)
@ -1338,9 +1339,9 @@ TEST_F(URLRequestTest, NetworkDelegateProxyError) {
EXPECT_EQ(1, network_delegate.completed_requests());
}
// Test that requests with "http" scheme are upgraded to "https" when DNS
// indicates that the name is HTTPS-only.
TEST_F(URLRequestTest, DnsHttpsRecordPresentCausesSchemeUpgrade) {
// Test that when host resolution fails with `ERR_DNS_NAME_HTTPS_ONLY` for
// "http://" requests, scheme is upgraded to "https://".
TEST_F(URLRequestTest, DnsNameHttpsOnlyErrorCausesSchemeUpgrade) {
base::test::ScopedFeatureList features;
features.InitAndEnableFeatureWithParameters(
features::kUseDnsHttpsSvcb, {{"UseDnsHttpsSvcbHttpUpgrade", "true"}});
@ -1357,11 +1358,20 @@ TEST_F(URLRequestTest, DnsHttpsRecordPresentCausesSchemeUpgrade) {
replacements.SetSchemeStr(url::kHttpScheme);
const GURL http_url = https_url.ReplaceComponents(replacements);
// Build a mocked resolver that returns ERR_DNS_NAME_HTTPS_ONLY for the
// first lookup, regardless of the request scheme. Real resolvers should
// only return this error when the scheme is "http" or "ws".
// Return `ERR_DNS_NAME_HTTPS_ONLY` for "http://" requests and an address for
// "https://" requests. This simulates the HostResolver behavior for a domain
// with an HTTPS DNS record.
MockHostResolver host_resolver;
host_resolver.rules()->AddSimulatedHTTPSServiceFormRecord("*");
MockHostResolverBase::RuleResolver::RuleKey unencrypted_resolve_key;
unencrypted_resolve_key.scheme = url::kHttpScheme;
unencrypted_resolve_key.hostname_pattern = kHost;
host_resolver.rules()->AddRule(std::move(unencrypted_resolve_key),
ERR_DNS_NAME_HTTPS_ONLY);
MockHostResolverBase::RuleResolver::RuleKey encrypted_resolve_key;
encrypted_resolve_key.scheme = url::kHttpsScheme;
encrypted_resolve_key.hostname_pattern = kHost;
host_resolver.rules()->AddRule(std::move(encrypted_resolve_key),
https_server.GetIPLiteralString());
TestNetworkDelegate network_delegate; // Must outlive URLRequest.
TestURLRequestContext context(true);
@ -1392,7 +1402,7 @@ TEST_F(URLRequestTest, DnsHttpsRecordPresentCausesSchemeUpgrade) {
}
// Test that DNS-based scheme upgrade supports deferred redirect.
TEST_F(URLRequestTest, DnsHttpsRecordPresentCausesSchemeUpgradeDeferred) {
TEST_F(URLRequestTest, DnsNameHttpsOnlyErrorCausesSchemeUpgradeDeferred) {
base::test::ScopedFeatureList features;
features.InitAndEnableFeatureWithParameters(
features::kUseDnsHttpsSvcb, {{"UseDnsHttpsSvcbHttpUpgrade", "true"}});
@ -1409,11 +1419,20 @@ TEST_F(URLRequestTest, DnsHttpsRecordPresentCausesSchemeUpgradeDeferred) {
replacements.SetSchemeStr(url::kHttpScheme);
const GURL http_url = https_url.ReplaceComponents(replacements);
// Build a mocked resolver that returns ERR_DNS_NAME_HTTPS_ONLY for the
// first lookup, regardless of the request scheme. Real resolvers should
// only return this error when the scheme is "http" or "ws".
// Return `ERR_DNS_NAME_HTTPS_ONLY` for "http://" requests and an address for
// "https://" requests. This simulates the HostResolver behavior for a domain
// with an HTTPS DNS record.
MockHostResolver host_resolver;
host_resolver.rules()->AddSimulatedHTTPSServiceFormRecord("*");
MockHostResolverBase::RuleResolver::RuleKey unencrypted_resolve_key;
unencrypted_resolve_key.scheme = url::kHttpScheme;
unencrypted_resolve_key.hostname_pattern = kHost;
host_resolver.rules()->AddRule(std::move(unencrypted_resolve_key),
ERR_DNS_NAME_HTTPS_ONLY);
MockHostResolverBase::RuleResolver::RuleKey encrypted_resolve_key;
encrypted_resolve_key.scheme = url::kHttpsScheme;
encrypted_resolve_key.hostname_pattern = kHost;
host_resolver.rules()->AddRule(std::move(encrypted_resolve_key),
https_server.GetIPLiteralString());
TestNetworkDelegate network_delegate; // Must outlive URLRequest.
TestURLRequestContext context(true);
@ -1467,11 +1486,17 @@ TEST_F(URLRequestTest, DnsHttpsRecordPresentCausesWsSchemeUpgrade) {
replacements.SetSchemeStr(url::kWsScheme);
const GURL ws_url = https_url.ReplaceComponents(replacements);
// Build a mocked resolver that returns ERR_DNS_NAME_HTTPS_ONLY for the
// first lookup, regardless of the request scheme. Real resolvers should
// only return this error when the scheme is "http" or "ws".
MockHostResolver host_resolver;
host_resolver.rules()->AddSimulatedHTTPSServiceFormRecord("*");
MockHostResolverBase::RuleResolver::RuleKey unencrypted_resolve_key;
unencrypted_resolve_key.scheme = url::kHttpScheme;
unencrypted_resolve_key.hostname_pattern = kHost;
host_resolver.rules()->AddRule(std::move(unencrypted_resolve_key),
ERR_DNS_NAME_HTTPS_ONLY);
MockHostResolverBase::RuleResolver::RuleKey encrypted_resolve_key;
encrypted_resolve_key.scheme = url::kHttpsScheme;
encrypted_resolve_key.hostname_pattern = kHost;
host_resolver.rules()->AddRule(std::move(encrypted_resolve_key),
https_server.GetIPLiteralString());
TestNetworkDelegate network_delegate; // Must outlive URLRequest.
TestURLRequestContext context(true);
@ -1525,6 +1550,7 @@ TEST_F(URLRequestTest, DnsHttpsRecordAbsentNoSchemeUpgrade) {
const GURL http_url = http_server.GetURL(kHost, "/defaultresponse");
MockHostResolver host_resolver;
host_resolver.rules()->AddRule(kHost, http_server.GetIPLiteralString());
TestNetworkDelegate network_delegate; // Must outlive URLRequest.
TestURLRequestContext context(true);
context.set_network_delegate(&network_delegate);
@ -1554,6 +1580,7 @@ TEST_F(URLRequestTest, DnsHttpsRecordAbsentNoSchemeUpgrade) {
TEST_F(URLRequestTest, SkipSecureDnsDisabledByDefault) {
MockHostResolver host_resolver;
host_resolver.rules()->AddRule("example.com", "127.0.0.1");
TestNetworkDelegate network_delegate; // Must outlive URLRequest.
TestURLRequestContext context(true);
context.set_network_delegate(&network_delegate);
@ -1572,6 +1599,7 @@ TEST_F(URLRequestTest, SkipSecureDnsDisabledByDefault) {
TEST_F(URLRequestTest, SkipSecureDnsEnabled) {
MockHostResolver host_resolver;
host_resolver.rules()->AddRule("example.com", "127.0.0.1");
TestNetworkDelegate network_delegate; // Must outlive URLRequest.
TestURLRequestContext context(true);
context.set_network_delegate(&network_delegate);
@ -6346,10 +6374,11 @@ TEST_F(URLRequestTestHTTP, PreloadExpectCTHeader) {
ct::CTPolicyCompliance::CT_POLICY_NOT_ENOUGH_SCTS);
TestNetworkDelegate network_delegate;
// Use a MockHostResolver (which by default maps all hosts to
// 127.0.0.1) so that the request can be sent to a site on the Expect
// CT preload list.
// Use a MockHostResolver, so that the request can be sent to a site on the
// Expect CT preload list.
MockHostResolver host_resolver;
host_resolver.rules()->AddRule(kExpectCTStaticHostname,
https_test_server.GetIPLiteralString());
TestURLRequestContext context(true);
context.set_host_resolver(&host_resolver);
context.set_transport_security_state(&transport_security_state);
@ -9653,10 +9682,11 @@ TEST_F(HTTPSRequestTest, HTTPSPreloadedHSTSTest) {
// We require that the URL be hsts-hpkp-preloaded.test. This is a test domain
// that has a preloaded HSTS+HPKP entry in the TransportSecurityState. This
// means that we have to use a MockHostResolver in order to direct
// hsts-hpkp-preloaded.test to the testserver. By default, MockHostResolver
// maps all hosts to 127.0.0.1.
// hsts-hpkp-preloaded.test to the testserver.
MockHostResolver host_resolver;
host_resolver.rules()->AddRule("hsts-hpkp-preloaded.test",
test_server.GetIPLiteralString());
TestNetworkDelegate network_delegate; // Must outlive URLRequest.
TestURLRequestContext context(true);
context.set_network_delegate(&network_delegate);
@ -9697,10 +9727,11 @@ TEST_F(HTTPSRequestTest, HTTPSErrorsNoClobberTSSTest) {
// We require that the URL be hsts-hpkp-preloaded.test. This is a test domain
// that has a preloaded HSTS+HPKP entry in the TransportSecurityState. This
// means that we have to use a MockHostResolver in order to direct
// hsts-hpkp-preloaded.test to the testserver. By default, MockHostResolver
// maps all hosts to 127.0.0.1.
// hsts-hpkp-preloaded.test to the testserver.
MockHostResolver host_resolver;
host_resolver.rules()->AddRule("hsts-hpkp-preloaded.test",
test_server.GetIPLiteralString());
TestNetworkDelegate network_delegate; // Must outlive URLRequest.
TestURLRequestContext context(true);
context.set_network_delegate(&network_delegate);
@ -9770,9 +9801,10 @@ TEST_F(HTTPSRequestTest, HSTSPreservesPosts) {
// Per spec, TransportSecurityState expects a domain name, rather than an IP
// address, so a MockHostResolver is needed to redirect www.somewhere.com to
// the EmbeddedTestServer. By default, MockHostResolver maps all hosts
// to 127.0.0.1.
// the EmbeddedTestServer.
MockHostResolver host_resolver;
host_resolver.rules()->AddRule("www.somewhere.com",
test_server.GetIPLiteralString());
// Force https for www.somewhere.com.
TransportSecurityState transport_security_state;

15
net/websockets/websocket_end_to_end_test.cc

@ -65,6 +65,7 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "url/gurl.h"
#include "url/origin.h"
#include "url/url_constants.h"
namespace net {
@ -648,12 +649,16 @@ TEST_F(WebSocketEndToEndTest, DnsSchemeUpgradeSupported) {
replacements.SetSchemeStr(url::kWsScheme);
GURL ws_url = wss_url.ReplaceComponents(replacements);
// Build a mocked resolver that returns ERR_DNS_NAME_HTTPS_ONLY for the
// first lookup, regardless of the request scheme. Real resolvers should
// only return this error when the scheme is "http" or "ws".
// Note that due to socket pool behavior, HostResolver will see the ws/wss
// requests as http/https.
MockHostResolver host_resolver;
host_resolver.rules()->AddSimulatedHTTPSServiceFormRecord("a.test");
host_resolver.rules()->AddRule("*", "127.0.0.1");
MockHostResolverBase::RuleResolver::RuleKey unencrypted_resolve_key;
unencrypted_resolve_key.scheme = url::kHttpScheme;
host_resolver.rules()->AddRule(std::move(unencrypted_resolve_key),
ERR_DNS_NAME_HTTPS_ONLY);
MockHostResolverBase::RuleResolver::RuleKey encrypted_resolve_key;
encrypted_resolve_key.scheme = url::kHttpsScheme;
host_resolver.rules()->AddRule(std::move(encrypted_resolve_key), "127.0.0.1");
context_.set_host_resolver(&host_resolver);
EXPECT_TRUE(ConnectAndWait(ws_url));

77
services/network/host_resolver_unittest.cc

@ -30,6 +30,7 @@
#include "net/dns/host_resolver_manager.h"
#include "net/dns/mock_host_resolver.h"
#include "net/dns/public/dns_protocol.h"
#include "net/dns/public/host_resolver_source.h"
#include "net/dns/public/mdns_listener_update_type.h"
#include "net/dns/public/secure_dns_policy.h"
#include "net/log/net_log.h"
@ -212,6 +213,7 @@ class TestMdnsListenClient : public mojom::MdnsListenClient {
TEST_F(HostResolverTest, Sync) {
auto inner_resolver = std::make_unique<net::MockHostResolver>();
inner_resolver->set_synchronous_mode(true);
inner_resolver->rules()->AddRule("example.test", "1.2.3.4");
HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
@ -225,14 +227,14 @@ TEST_F(HostResolverTest, Sync) {
TestResolveHostClient response_client(&pending_response_client, &run_loop);
resolver.ResolveHost(
net::HostPortPair("localhost", 160), net::NetworkIsolationKey(),
net::HostPortPair("example.test", 160), net::NetworkIsolationKey(),
std::move(optional_parameters), std::move(pending_response_client));
run_loop.Run();
EXPECT_EQ(net::OK, response_client.top_level_result_error());
EXPECT_EQ(net::OK, response_client.result_error());
EXPECT_THAT(response_client.result_addresses().value().endpoints(),
testing::ElementsAre(CreateExpectedEndPoint("127.0.0.1", 160)));
testing::ElementsAre(CreateExpectedEndPoint("1.2.3.4", 160)));
EXPECT_FALSE(response_client.result_text());
EXPECT_FALSE(response_client.result_hosts());
EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
@ -242,6 +244,7 @@ TEST_F(HostResolverTest, Sync) {
TEST_F(HostResolverTest, Async) {
auto inner_resolver = std::make_unique<net::MockHostResolver>();
inner_resolver->set_synchronous_mode(false);
inner_resolver->rules()->AddRule("example.test", "1.2.3.4");
HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
@ -255,7 +258,7 @@ TEST_F(HostResolverTest, Async) {
TestResolveHostClient response_client(&pending_response_client, &run_loop);
resolver.ResolveHost(
net::HostPortPair("localhost", 160), net::NetworkIsolationKey(),
net::HostPortPair("example.test", 160), net::NetworkIsolationKey(),
std::move(optional_parameters), std::move(pending_response_client));
bool control_handle_closed = false;
@ -266,7 +269,7 @@ TEST_F(HostResolverTest, Async) {
EXPECT_EQ(net::OK, response_client.result_error());
EXPECT_THAT(response_client.result_addresses().value().endpoints(),
testing::ElementsAre(CreateExpectedEndPoint("127.0.0.1", 160)));
testing::ElementsAre(CreateExpectedEndPoint("1.2.3.4", 160)));
EXPECT_FALSE(response_client.result_text());
EXPECT_FALSE(response_client.result_hosts());
EXPECT_TRUE(control_handle_closed);
@ -300,6 +303,7 @@ TEST_F(HostResolverTest, DnsQueryType) {
TEST_F(HostResolverTest, InitialPriority) {
auto inner_resolver = std::make_unique<net::MockHostResolver>();
inner_resolver->rules()->AddRule("priority.test", "1.2.3.4");
HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
@ -312,13 +316,13 @@ TEST_F(HostResolverTest, InitialPriority) {
TestResolveHostClient response_client(&pending_response_client, &run_loop);
resolver.ResolveHost(
net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
net::HostPortPair("priority.test", 80), net::NetworkIsolationKey(),
std::move(optional_parameters), std::move(pending_response_client));
run_loop.Run();
EXPECT_EQ(net::OK, response_client.result_error());
EXPECT_THAT(response_client.result_addresses().value().endpoints(),
testing::ElementsAre(CreateExpectedEndPoint("127.0.0.1", 80)));
testing::ElementsAre(CreateExpectedEndPoint("1.2.3.4", 80)));
EXPECT_EQ(net::HIGHEST, inner_resolver->last_request_priority());
}
@ -331,14 +335,26 @@ TEST_F(HostResolverTest, Source) {
constexpr char kDnsResult[] = "168.100.12.23";
constexpr char kMdnsResult[] = "200.1.2.3";
auto inner_resolver = std::make_unique<net::MockHostResolver>();
inner_resolver->rules_map()[net::HostResolverSource::ANY]->AddRule(
kDomain, kAnyResult);
inner_resolver->rules_map()[net::HostResolverSource::SYSTEM]->AddRule(
kDomain, kSystemResult);
inner_resolver->rules_map()[net::HostResolverSource::DNS]->AddRule(
kDomain, kDnsResult);
inner_resolver->rules_map()[net::HostResolverSource::MULTICAST_DNS]->AddRule(
kDomain, kMdnsResult);
net::MockHostResolverBase::RuleResolver::RuleKey any_key;
any_key.hostname_pattern = kDomain;
any_key.query_source = net::HostResolverSource::ANY;
inner_resolver->rules()->AddRule(std::move(any_key), kAnyResult);
net::MockHostResolverBase::RuleResolver::RuleKey system_key;
system_key.hostname_pattern = kDomain;
system_key.query_source = net::HostResolverSource::SYSTEM;
inner_resolver->rules()->AddRule(std::move(system_key), kSystemResult);
net::MockHostResolverBase::RuleResolver::RuleKey dns_key;
dns_key.hostname_pattern = kDomain;
dns_key.query_source = net::HostResolverSource::DNS;
inner_resolver->rules()->AddRule(std::move(dns_key), kDnsResult);
net::MockHostResolverBase::RuleResolver::RuleKey mdns_key;
mdns_key.hostname_pattern = kDomain;
mdns_key.query_source = net::HostResolverSource::MULTICAST_DNS;
inner_resolver->rules()->AddRule(std::move(mdns_key), kMdnsResult);
HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
@ -411,10 +427,14 @@ TEST_F(HostResolverTest, SeparateCacheBySource) {
constexpr char kAnyResultOriginal[] = "1.2.3.4";
constexpr char kSystemResultOriginal[] = "127.0.0.1";
auto inner_resolver = std::make_unique<net::MockCachingHostResolver>();
inner_resolver->rules_map()[net::HostResolverSource::ANY]->AddRule(
kDomain, kAnyResultOriginal);
inner_resolver->rules_map()[net::HostResolverSource::SYSTEM]->AddRule(
kDomain, kSystemResultOriginal);
net::MockHostResolverBase::RuleResolver::RuleKey any_key;
any_key.hostname_pattern = kDomain;
any_key.query_source = net::HostResolverSource::ANY;
inner_resolver->rules()->AddRule(any_key, kAnyResultOriginal);
net::MockHostResolverBase::RuleResolver::RuleKey system_key;
system_key.hostname_pattern = kDomain;
system_key.query_source = net::HostResolverSource::SYSTEM;
inner_resolver->rules()->AddRule(system_key, kSystemResultOriginal);
HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
@ -439,12 +459,9 @@ TEST_F(HostResolverTest, SeparateCacheBySource) {
// not based on whether they resolve to the old or new value.
constexpr char kAnyResultFresh[] = "111.222.1.1";
constexpr char kSystemResultFresh[] = "111.222.1.2";
inner_resolver->rules_map()[net::HostResolverSource::ANY]->ClearRules();
inner_resolver->rules_map()[net::HostResolverSource::ANY]->AddRule(
kDomain, kAnyResultFresh);
inner_resolver->rules_map()[net::HostResolverSource::SYSTEM]->ClearRules();
inner_resolver->rules_map()[net::HostResolverSource::SYSTEM]->AddRule(
kDomain, kSystemResultFresh);
inner_resolver->rules()->ClearRules();
inner_resolver->rules()->AddRule(any_key, kAnyResultFresh);
inner_resolver->rules()->AddRule(system_key, kSystemResultFresh);
base::RunLoop cached_run_loop;
mojo::PendingRemote<mojom::ResolveHostClient> pending_cached_client;
@ -721,6 +738,7 @@ TEST_F(HostResolverTest, LoopbackOnly) {
TEST_F(HostResolverTest, HandlesSecureDnsPolicyParameter) {
auto inner_resolver = std::make_unique<net::MockHostResolver>();
inner_resolver->rules()->AddRule("secure.test", "1.2.3.4");
HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
@ -734,13 +752,13 @@ TEST_F(HostResolverTest, HandlesSecureDnsPolicyParameter) {
TestResolveHostClient response_client(&pending_response_client, &run_loop);
resolver.ResolveHost(
net::HostPortPair("localhost", 80), net::NetworkIsolationKey(),
net::HostPortPair("secure.test", 80), net::NetworkIsolationKey(),
std::move(optional_parameters), std::move(pending_response_client));
run_loop.Run();
EXPECT_EQ(net::OK, response_client.result_error());
EXPECT_THAT(response_client.result_addresses().value().endpoints(),
testing::ElementsAre(CreateExpectedEndPoint("127.0.0.1", 80)));
testing::ElementsAre(CreateExpectedEndPoint("1.2.3.4", 80)));
EXPECT_EQ(net::SecureDnsPolicy::kDisable,
inner_resolver->last_secure_dns_policy());
}
@ -810,6 +828,7 @@ TEST_F(HostResolverTest, NetworkIsolationKey) {
const net::NetworkIsolationKey kNetworkIsolationKey(kOrigin, kOrigin);
auto inner_resolver = std::make_unique<net::MockHostResolver>();
inner_resolver->rules()->AddRule("nik.test", "1.2.3.4");
HostResolver resolver(inner_resolver.get(), net::NetLog::Get());
@ -822,14 +841,14 @@ TEST_F(HostResolverTest, NetworkIsolationKey) {
mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client;
TestResolveHostClient response_client(&pending_response_client, &run_loop);
resolver.ResolveHost(net::HostPortPair("localhost", 160),
kNetworkIsolationKey, std::move(optional_parameters),
resolver.ResolveHost(net::HostPortPair("nik.test", 160), kNetworkIsolationKey,
std::move(optional_parameters),
std::move(pending_response_client));
run_loop.Run();
EXPECT_EQ(net::OK, response_client.result_error());
EXPECT_THAT(response_client.result_addresses().value().endpoints(),
testing::ElementsAre(CreateExpectedEndPoint("127.0.0.1", 160)));
testing::ElementsAre(CreateExpectedEndPoint("1.2.3.4", 160)));
EXPECT_EQ(0u, resolver.GetNumOutstandingRequestsForTesting());
EXPECT_EQ(kNetworkIsolationKey,
inner_resolver->last_request_network_isolation_key());

16
services/network/mojo_host_resolver_impl_unittest.cc

@ -16,7 +16,9 @@
#include "base/time/time.h"
#include "mojo/public/cpp/bindings/receiver.h"
#include "net/base/address_family.h"
#include "net/base/address_list.h"
#include "net/base/ip_address.h"
#include "net/base/ip_endpoint.h"
#include "net/base/net_errors.h"
#include "net/base/network_isolation_key.h"
#include "net/dns/mock_host_resolver.h"
@ -108,13 +110,16 @@ class MojoHostResolverImplTest : public testing::Test {
const net::IPAddress kChromiumOrgAddress{8, 8, 8, 8};
void SetUp() override {
mock_host_resolver_.rules()->AddRuleForAddressFamily(
"example.com", net::ADDRESS_FAMILY_IPV4, kExampleComAddress.ToString());
net::AddressList example_com_addresses;
example_com_addresses.push_back(net::IPEndPoint(kExampleComAddress, 0));
example_com_addresses.push_back(net::IPEndPoint(kExampleComAddressIpv6, 0));
mock_host_resolver_.rules()->AddRule("example.com",
kExampleComAddressIpv6.ToString());
std::move(example_com_addresses));
mock_host_resolver_.rules()->AddRule("chromium.org",
kChromiumOrgAddress.ToString());
mock_host_resolver_.rules()->AddSimulatedFailure("failure.fail");
mock_host_resolver_.rules()->AddRule("failure.fail",
net::ERR_NAME_NOT_RESOLVED);
resolver_service_ = std::make_unique<MojoHostResolverImpl>(
&mock_host_resolver_, net::NetLogWithSource());
@ -237,7 +242,8 @@ TEST_F(MojoHostResolverImplTest, ResolveEx) {
client.WaitForResult();
EXPECT_THAT(client.error_, IsOk());
EXPECT_THAT(client.results_, testing::ElementsAre(kExampleComAddressIpv6));
EXPECT_THAT(client.results_, testing::UnorderedElementsAre(
kExampleComAddress, kExampleComAddressIpv6));
}
// Makes sure that the passed in NetworkIsolationKey is passed to the

36
services/network/network_context_unittest.cc

@ -3306,6 +3306,7 @@ class TestResolveHostClient : public ResolveHostClientBase {
TEST_F(NetworkContextTest, ResolveHost_Sync) {
auto resolver = std::make_unique<net::MockHostResolver>();
resolver->rules()->AddRule("sync.test", "1.2.3.4");
std::unique_ptr<NetworkContext> network_context =
CreateContextWithParams(CreateNetworkContextParamsForTesting());
@ -3322,7 +3323,7 @@ TEST_F(NetworkContextTest, ResolveHost_Sync) {
TestResolveHostClient response_client(&pending_response_client, &run_loop);
network_context->ResolveHost(
net::HostPortPair("localhost", 160), net::NetworkIsolationKey(),
net::HostPortPair("sync.test", 160), net::NetworkIsolationKey(),
std::move(optional_parameters), std::move(pending_response_client));
run_loop.Run();
@ -3330,13 +3331,14 @@ TEST_F(NetworkContextTest, ResolveHost_Sync) {
EXPECT_EQ(net::OK, response_client.result_error());
EXPECT_THAT(
response_client.result_addresses().value().endpoints(),
testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 160)));
testing::UnorderedElementsAre(CreateExpectedEndPoint("1.2.3.4", 160)));
EXPECT_EQ(0u,
network_context->GetNumOutstandingResolveHostRequestsForTesting());
}
TEST_F(NetworkContextTest, ResolveHost_Async) {
auto resolver = std::make_unique<net::MockHostResolver>();
resolver->rules()->AddRule("async.test", "1.2.3.4");
std::unique_ptr<NetworkContext> network_context =
CreateContextWithParams(CreateNetworkContextParamsForTesting());
@ -3353,7 +3355,7 @@ TEST_F(NetworkContextTest, ResolveHost_Async) {
TestResolveHostClient response_client(&pending_response_client, &run_loop);
network_context->ResolveHost(
net::HostPortPair("localhost", 160), net::NetworkIsolationKey(),
net::HostPortPair("async.test", 160), net::NetworkIsolationKey(),
std::move(optional_parameters), std::move(pending_response_client));
bool control_handle_closed = false;
@ -3366,7 +3368,7 @@ TEST_F(NetworkContextTest, ResolveHost_Async) {
EXPECT_EQ(net::OK, response_client.result_error());
EXPECT_THAT(
response_client.result_addresses().value().endpoints(),
testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 160)));
testing::UnorderedElementsAre(CreateExpectedEndPoint("1.2.3.4", 160)));
EXPECT_TRUE(control_handle_closed);
EXPECT_EQ(0u,
network_context->GetNumOutstandingResolveHostRequestsForTesting());
@ -3445,6 +3447,7 @@ TEST_F(NetworkContextTest, ResolveHost_NetworkIsolationKey) {
const net::NetworkIsolationKey kNetworkIsolationKey(kOrigin, kOrigin);
net::MockHostResolver resolver;
resolver.rules()->AddRule("nik.test", "1.2.3.4");
std::unique_ptr<NetworkContext> network_context =
CreateContextWithParams(CreateNetworkContextParamsForTesting());
@ -3460,14 +3463,14 @@ TEST_F(NetworkContextTest, ResolveHost_NetworkIsolationKey) {
TestResolveHostClient response_client(&pending_response_client, &run_loop);
network_context->ResolveHost(
net::HostPortPair("localhost", 160), kNetworkIsolationKey,
net::HostPortPair("nik.test", 160), kNetworkIsolationKey,
std::move(optional_parameters), std::move(pending_response_client));
run_loop.Run();
EXPECT_EQ(net::OK, response_client.result_error());
EXPECT_THAT(
response_client.result_addresses().value().endpoints(),
testing::UnorderedElementsAre(CreateExpectedEndPoint("127.0.0.1", 160)));
testing::UnorderedElementsAre(CreateExpectedEndPoint("1.2.3.4", 160)));
EXPECT_EQ(0u,
network_context->GetNumOutstandingResolveHostRequestsForTesting());
EXPECT_EQ(kNetworkIsolationKey,
@ -4612,8 +4615,14 @@ TEST_F(NetworkContextTest, TrustedParams) {
// Test that the disable_secure_dns trusted param is passed through to the
// host resolver.
TEST_F(NetworkContextTest, TrustedParams_DisableSecureDns) {
net::EmbeddedTestServer test_server;
test_server.AddDefaultHandlers(
base::FilePath(FILE_PATH_LITERAL("services/test/data")));
ASSERT_TRUE(test_server.Start());
std::unique_ptr<net::MockHostResolver> resolver =
std::make_unique<net::MockHostResolver>();
resolver->rules()->AddRule("example.test", test_server.GetIPLiteralString());
std::unique_ptr<net::TestURLRequestContext> url_request_context =
std::make_unique<net::TestURLRequestContext>(
true /* delay_initialization */);
@ -4639,7 +4648,7 @@ TEST_F(NetworkContextTest, TrustedParams_DisableSecureDns) {
for (bool disable_secure_dns : {false, true}) {
ResourceRequest request;
request.url = GURL("http://example.test");
request.url = GURL("http://example.test/echo");
request.load_flags = net::LOAD_BYPASS_CACHE;
request.trusted_params = ResourceRequest::TrustedParams();
request.trusted_params->disable_secure_dns = disable_secure_dns;
@ -4664,7 +4673,13 @@ TEST_F(NetworkContextTest, TrustedParams_DisableSecureDns) {
// Test that the disable_secure_dns factory param is passed through to the
// host resolver.
TEST_F(NetworkContextTest, FactoryParams_DisableSecureDns) {
net::EmbeddedTestServer test_server;
test_server.AddDefaultHandlers(
base::FilePath(FILE_PATH_LITERAL("services/test/data")));
ASSERT_TRUE(test_server.Start());
net::MockHostResolver resolver;
resolver.rules()->AddRule("example.test", test_server.GetIPLiteralString());
net::TestURLRequestContext url_request_context(
true /* delay_initialization */);
url_request_context.set_host_resolver(&resolver);
@ -4688,7 +4703,7 @@ TEST_F(NetworkContextTest, FactoryParams_DisableSecureDns) {
loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
ResourceRequest request;
request.url = GURL("http://example.test");
request.url = GURL("http://example.test/echo");
request.load_flags = net::LOAD_BYPASS_CACHE;
auto client = std::make_unique<TestURLLoaderClient>();
mojo::Remote<mojom::URLLoader> loader;
@ -5816,9 +5831,8 @@ TEST_F(NetworkContextTest, HangingHeaderClientAbortDuringOnHeadersReceived) {
class NetworkContextMockHostTest : public NetworkContextTest {
public:
NetworkContextMockHostTest() {
scoped_refptr<net::RuleBasedHostResolverProc> rules =
net::CreateCatchAllHostResolverProc();
rules->AddRule(kMockHost, "127.0.0.1");
net::MockHostResolverBase::RuleResolver rules;
rules.AddRule(kMockHost, "127.0.0.1");
network_service_->set_host_resolver_factory_for_testing(
std::make_unique<net::MockHostResolverFactory>(std::move(rules)));

6
services/network/proxy_resolving_client_socket_unittest.cc

@ -48,8 +48,10 @@ class TestURLRequestContextWithProxy : public net::TestURLRequestContext {
context_storage_.set_proxy_resolution_service(
net::ConfiguredProxyResolutionService::CreateFixedFromPacResult(
pac_result, TRAFFIC_ANNOTATION_FOR_TESTS));
// net::MockHostResolver maps all hosts to localhost.
auto host_resolver = std::make_unique<net::MockCachingHostResolver>();
auto host_resolver = std::make_unique<net::MockCachingHostResolver>(
/*cache_invalidation_num=*/0,
/*default_result=*/net::MockHostResolverBase::RuleResolver::
GetLocalhostResult());
context_storage_.set_host_resolver(std::move(host_resolver));
set_client_socket_factory(client_socket_factory);
Init();

5
services/network/proxy_resolving_socket_mojo_unittest.cc

@ -45,8 +45,9 @@ class TestURLRequestContextWithProxy : public net::TestURLRequestContext {
context_storage_.set_proxy_resolution_service(
net::ConfiguredProxyResolutionService::CreateFixedFromPacResult(
pac_result, TRAFFIC_ANNOTATION_FOR_TESTS));
// net::MockHostResolver maps all hosts to localhost.
auto host_resolver = std::make_unique<net::MockHostResolver>();
auto host_resolver = std::make_unique<net::MockHostResolver>(
/*default_result=*/net::MockHostResolverBase::RuleResolver::
GetLocalhostResult());
context_storage_.set_host_resolver(std::move(host_resolver));
}