diff options
Diffstat (limited to 'chromium/net/dns/mock_host_resolver.cc')
| -rw-r--r-- | chromium/net/dns/mock_host_resolver.cc | 350 |
1 files changed, 196 insertions, 154 deletions
diff --git a/chromium/net/dns/mock_host_resolver.cc b/chromium/net/dns/mock_host_resolver.cc index 03500cf172b..3f662a4c4b3 100644 --- a/chromium/net/dns/mock_host_resolver.cc +++ b/chromium/net/dns/mock_host_resolver.cc @@ -48,6 +48,7 @@ #include "net/dns/host_resolver.h" #include "net/dns/host_resolver_manager.h" #include "net/dns/host_resolver_results.h" +#include "net/dns/https_record_rdata.h" #include "net/dns/public/dns_query_type.h" #include "net/dns/public/host_resolver_source.h" #include "net/dns/public/mdns_listener_update_type.h" @@ -111,13 +112,43 @@ absl::variant<url::SchemeHostPort, std::string> GetCacheHost( return absl::get<HostPortPair>(endpoint).host(); } +absl::optional<HostCache::Entry> CreateCacheEntry( + const std::vector<HostResolverEndpointResult>& endpoint_results, + const std::set<std::string>& aliases) { + absl::optional<std::vector<net::IPEndPoint>> ip_endpoints; + std::multimap<HttpsRecordPriority, ConnectionEndpointMetadata> + endpoint_metadatas; + for (const auto& endpoint_result : endpoint_results) { + if (!ip_endpoints) { + ip_endpoints = endpoint_result.ip_endpoints; + } else { + // TODO(crbug.com/1264933): Support caching different IP endpoints + // resutls. + CHECK(*ip_endpoints == endpoint_result.ip_endpoints) + << "Currently caching MockHostResolver only supports same IP " + "endpoints results."; + } + + if (!endpoint_result.metadata.supported_protocol_alpns.empty()) { + endpoint_metadatas.emplace(/*priority=*/1, endpoint_result.metadata); + } + } + DCHECK(ip_endpoints); + auto endpoint_entry = HostCache::Entry(OK, *ip_endpoints, aliases, + HostCache::Entry::SOURCE_UNKNOWN); + if (endpoint_metadatas.empty()) { + return endpoint_entry; + } + return HostCache::Entry::MergeEntries( + HostCache::Entry(OK, std::move(endpoint_metadatas), + HostCache::Entry::SOURCE_UNKNOWN), + endpoint_entry); +} } // namespace int ParseAddressList(base::StringPiece host_list, - const std::vector<std::string>& dns_aliases, - AddressList* addrlist) { - *addrlist = AddressList(); - addrlist->SetDnsAliases(dns_aliases); + std::vector<net::IPEndPoint>* ip_endpoints) { + ip_endpoints->clear(); for (const base::StringPiece& address : base::SplitStringPiece( host_list, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) { IPAddress ip_address; @@ -125,7 +156,7 @@ int ParseAddressList(base::StringPiece host_list, LOG(WARNING) << "Not a supported IP literal: " << address; return ERR_UNEXPECTED; } - addrlist->push_back(IPEndPoint(ip_address, 0)); + ip_endpoints->push_back(IPEndPoint(ip_address, 0)); } return OK; } @@ -238,58 +269,32 @@ class MockHostResolverBase::RequestImpl resolve_error_info_ = ResolveErrorInfo(error); } - // Sets `address_results_` to `address_results`, after fixing them up. Also - // sets `error` to OK if the fixed up AddressList is non-empty, or - // ERR_NAME_NOT_RESOLVED otherwise. - void SetAddressResults(const AddressList& address_results, - absl::optional<HostCache::EntryStaleness> staleness) { - // Should only be called at most once and before request is marked - // completed. - DCHECK(!complete_); - DCHECK(!address_results_); - DCHECK(!endpoint_results_); - DCHECK(!parameters_.is_speculative); - - address_results_ = FixupAddressList(address_results); - - // If there are no addresses, either as a result of FixupAddressList(), as - // in the originally passed in value, clear results and set an error. - if (address_results_->empty()) { - address_results_.reset(); - SetError(ERR_NAME_NOT_RESOLVED); - return; - } - - SetError(OK); - - fixed_up_dns_alias_results_ = dns_alias_utility::FixUpDnsAliases( - std::set<std::string>(address_results_->dns_aliases().begin(), - address_results_->dns_aliases().end())); - staleness_ = std::move(staleness); - - endpoint_results_ = AddressListToEndpointResults(address_results_.value()); - } - + // Sets `endpoint_results_`, `fixed_up_dns_alias_results_`, + // `address_results_` and `staleness_` after fixing them up. + // Also sets `error` to OK. void SetEndpointResults( - std::vector<HostResolverEndpointResult> endpoint_results) { + std::vector<HostResolverEndpointResult> endpoint_results, + std::set<std::string> aliases, + absl::optional<HostCache::EntryStaleness> staleness) { DCHECK(!complete_); DCHECK(!endpoint_results_); DCHECK(!parameters_.is_speculative); - // TODO(crbug.com/1264933): Perform fixups on `endpoint_results`? endpoint_results_ = std::move(endpoint_results); + for (auto& result : *endpoint_results_) { + result.ip_endpoints = FixupEndPoints(result.ip_endpoints); + } - // For now, we do not support configuring DNS aliases with endpoint results, - // but the value is expected to always be present. - // - // TODO(crbug.com/1264933): Add some way to configure this, to support code - // migrating to `HostResolverEndpointResult`. - fixed_up_dns_alias_results_.emplace(); + fixed_up_dns_alias_results_ = FixupAliases(aliases); // `HostResolver` implementations are expected to provide an `AddressList` // result whenever `HostResolverEndpointResult` is also available. address_results_ = EndpointResultToAddressList( *endpoint_results_, *fixed_up_dns_alias_results_); + + staleness_ = std::move(staleness); + + SetError(OK); } void OnAsyncCompleted(size_t id, int error) { @@ -341,31 +346,29 @@ class MockHostResolverBase::RequestImpl ResolveErrorInfo resolve_error_info() const { return resolve_error_info_; } private: - 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()) { + std::vector<IPEndPoint> FixupEndPoints( + const std::vector<IPEndPoint>& endpoints) { + std::vector<IPEndPoint> corrected; + for (const IPEndPoint& endpoint : endpoints) { DCHECK_NE(endpoint.GetFamily(), ADDRESS_FAMILY_UNSPECIFIED); if (parameters_.dns_query_type == DnsQueryType::UNSPECIFIED || parameters_.dns_query_type == AddressFamilyToDnsQueryType(endpoint.GetFamily())) { if (endpoint.port() == 0) { - corrected.push_back( - IPEndPoint(endpoint.address(), GetPort(request_endpoint_))); + corrected.emplace_back(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; } + std::set<std::string> FixupAliases(const std::set<std::string> aliases) { + if (aliases.empty()) + return std::set<std::string>{std::string(GetHostname(request_endpoint_))}; + return aliases; + } const Host request_endpoint_; const NetworkIsolationKey network_isolation_key_; @@ -490,8 +493,31 @@ MockHostResolverBase::RuleResolver::RuleKey::RuleKey(RuleKey&&) = default; MockHostResolverBase::RuleResolver::RuleKey& MockHostResolverBase::RuleResolver::RuleKey::operator=(RuleKey&&) = default; +MockHostResolverBase::RuleResolver::RuleResult::RuleResult() = default; + +MockHostResolverBase::RuleResolver::RuleResult::RuleResult( + std::vector<HostResolverEndpointResult> endpoints, + std::set<std::string> aliases) + : endpoints(std::move(endpoints)), aliases(std::move(aliases)) {} + +MockHostResolverBase::RuleResolver::RuleResult::~RuleResult() = default; + +MockHostResolverBase::RuleResolver::RuleResult::RuleResult(const RuleResult&) = + default; + +MockHostResolverBase::RuleResolver::RuleResult& +MockHostResolverBase::RuleResolver::RuleResult::operator=(const RuleResult&) = + default; + +MockHostResolverBase::RuleResolver::RuleResult::RuleResult(RuleResult&&) = + default; + +MockHostResolverBase::RuleResolver::RuleResult& +MockHostResolverBase::RuleResolver::RuleResult::operator=(RuleResult&&) = + default; + MockHostResolverBase::RuleResolver::RuleResolver( - absl::optional<RuleResult> default_result) + absl::optional<RuleResultOrError> default_result) : default_result_(std::move(default_result)) {} MockHostResolverBase::RuleResolver::~RuleResolver() = default; @@ -506,14 +532,14 @@ MockHostResolverBase::RuleResolver::RuleResolver(RuleResolver&&) = default; MockHostResolverBase::RuleResolver& MockHostResolverBase::RuleResolver::operator=(RuleResolver&&) = default; -const MockHostResolverBase::RuleResolver::RuleResult& +const MockHostResolverBase::RuleResolver::RuleResultOrError& MockHostResolverBase::RuleResolver::Resolve( const Host& request_endpoint, DnsQueryTypeSet request_types, HostResolverSource request_source) const { for (const auto& rule : rules_) { const RuleKey& key = rule.first; - const RuleResult& result = rule.second; + const RuleResultOrError& result = rule.second; if (absl::holds_alternative<RuleKey::NoScheme>(key.scheme) && absl::holds_alternative<url::SchemeHostPort>(request_endpoint)) { @@ -556,7 +582,7 @@ MockHostResolverBase::RuleResolver::Resolve( NOTREACHED() << "Request " << GetHostname(request_endpoint) << " did not match any MockHostResolver rules."; - static const RuleResult kUnexpected = ERR_UNEXPECTED; + static const RuleResultOrError kUnexpected = ERR_UNEXPECTED; return kUnexpected; } @@ -565,14 +591,15 @@ void MockHostResolverBase::RuleResolver::ClearRules() { } // static -MockHostResolverBase::RuleResolver::RuleResult +MockHostResolverBase::RuleResolver::RuleResultOrError MockHostResolverBase::RuleResolver::GetLocalhostResult() { - return AddressList::CreateFromIPAddress(IPAddress::IPv4Localhost(), - /*port=*/0); + HostResolverEndpointResult endpoint; + endpoint.ip_endpoints = {IPEndPoint(IPAddress::IPv4Localhost(), /*port=*/0)}; + return RuleResult(std::vector{endpoint}); } void MockHostResolverBase::RuleResolver::AddRule(RuleKey key, - RuleResult result) { + RuleResultOrError result) { // Literals are always resolved to themselves by MockHostResolverBase, // consequently we do not support remapping them. IPAddress ip_address; @@ -584,15 +611,15 @@ void MockHostResolverBase::RuleResolver::AddRule(RuleKey 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)); + std::vector<HostResolverEndpointResult> endpoints; + endpoints.emplace_back(); + CHECK_EQ(ParseAddressList(ip_literal, &endpoints[0].ip_endpoints), OK); + AddRule(std::move(key), RuleResult(std::move(endpoints))); } void MockHostResolverBase::RuleResolver::AddRule( base::StringPiece hostname_pattern, - RuleResult result) { + RuleResultOrError result) { RuleKey key; key.hostname_pattern = std::string(hostname_pattern); AddRule(std::move(key), std::move(result)); @@ -601,10 +628,10 @@ void MockHostResolverBase::RuleResolver::AddRule( 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)); + std::vector<HostResolverEndpointResult> endpoints; + endpoints.emplace_back(); + CHECK_EQ(ParseAddressList(ip_literal, &endpoints[0].ip_endpoints), OK); + AddRule(hostname_pattern, RuleResult(std::move(endpoints))); } void MockHostResolverBase::RuleResolver::AddRule( @@ -623,24 +650,26 @@ void MockHostResolverBase::RuleResolver::AddIPLiteralRule( RuleKey key; key.hostname_pattern = std::string(hostname_pattern); - std::vector<std::string> aliases; + std::set<std::string> aliases; if (!canonical_name.empty()) - aliases.emplace_back(canonical_name); + aliases.emplace(canonical_name); - AddressList results; - CHECK_EQ(ParseAddressList(ip_literal, aliases, &results), OK); - - AddRule(std::move(key), std::move(results)); + std::vector<HostResolverEndpointResult> endpoints; + endpoints.emplace_back(); + CHECK_EQ(ParseAddressList(ip_literal, &endpoints[0].ip_endpoints), OK); + AddRule(std::move(key), RuleResult(std::move(endpoints), std::move(aliases))); } 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)); + std::vector<HostResolverEndpointResult> endpoints; + endpoints.emplace_back(); + CHECK_EQ(ParseAddressList(ip_literal, &endpoints[0].ip_endpoints), OK); + AddRule(hostname_pattern, + RuleResult(std::move(endpoints), + std::set(dns_aliases.begin(), dns_aliases.end()))); } void MockHostResolverBase::RuleResolver::AddIPLiteralRuleWithDnsAliases( @@ -669,10 +698,12 @@ void MockHostResolverBase::RuleResolver::AddRuleWithFlags( 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)); + std::vector<HostResolverEndpointResult> endpoints; + endpoints.emplace_back(); + CHECK_EQ(ParseAddressList(ip_literal, &endpoints[0].ip_endpoints), OK); + AddRule(host_pattern, + RuleResult(std::move(endpoints), + std::set(dns_aliases.begin(), dns_aliases.end()))); } MockHostResolverBase::State::State() = default; @@ -747,12 +778,13 @@ int MockHostResolverBase::LoadIntoCache( ResolveHostParameters parameters = optional_parameters.value_or(ResolveHostParameters()); - AddressList addresses; + std::vector<HostResolverEndpointResult> endpoints; + std::set<std::string> aliases; absl::optional<HostCache::EntryStaleness> stale_info; int rv = ResolveFromIPLiteralOrCache( endpoint, network_isolation_key, parameters.dns_query_type, ParametersToHostResolverFlags(parameters), parameters.source, - parameters.cache_usage, &addresses, &stale_info); + parameters.cache_usage, &endpoints, &aliases, &stale_info); if (rv != ERR_DNS_CACHE_MISS) { // Request already in cache (or IP literal). No need to load it. return rv; @@ -894,17 +926,19 @@ int MockHostResolverBase::Resolve(RequestImpl* request) { last_request_network_isolation_key_ = request->network_isolation_key(); last_secure_dns_policy_ = request->parameters().secure_dns_policy; state_->IncrementNumResolve(); - AddressList addresses; + std::vector<HostResolverEndpointResult> endpoints; + std::set<std::string> aliases; absl::optional<HostCache::EntryStaleness> stale_info; // TODO(crbug.com/1264933): Allow caching `ConnectionEndpoint` results. int rv = ResolveFromIPLiteralOrCache( 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); + &endpoints, &aliases, &stale_info); if (rv == OK && !request->parameters().is_speculative) { - request->SetAddressResults(addresses, std::move(stale_info)); + request->SetEndpointResults(std::move(endpoints), std::move(aliases), + std::move(stale_info)); } else { request->SetError(rv); } @@ -945,10 +979,14 @@ int MockHostResolverBase::ResolveFromIPLiteralOrCache( HostResolverFlags flags, HostResolverSource source, HostResolver::ResolveHostParameters::CacheUsage cache_usage, - AddressList* addresses, + std::vector<HostResolverEndpointResult>* out_endpoints, + std::set<std::string>* out_aliases, absl::optional<HostCache::EntryStaleness>* out_stale_info) { - DCHECK(addresses); + DCHECK(out_endpoints); + DCHECK(out_aliases); DCHECK(out_stale_info); + out_endpoints->clear(); + out_aliases->clear(); *out_stale_info = absl::nullopt; IPAddress ip_address; @@ -963,16 +1001,20 @@ int MockHostResolverBase::ResolveFromIPLiteralOrCache( return ERR_NAME_NOT_RESOLVED; } - *addresses = - AddressList::CreateFromIPAddress(ip_address, GetPort(endpoint)); + *out_endpoints = std::vector<HostResolverEndpointResult>(1); + (*out_endpoints)[0].ip_endpoints.emplace_back(ip_address, + GetPort(endpoint)); if (flags & HOST_RESOLVER_CANONNAME) - addresses->SetDefaultCanonicalName(); + *out_aliases = {ip_address.ToString()}; return OK; } + std::vector<IPEndPoint> localhost_endpoints; // Immediately resolve any "localhost" or recognized similar names. if (IsAddressType(dns_query_type) && - ResolveLocalHostname(GetHostname(endpoint), addresses)) { + ResolveLocalHostname(GetHostname(endpoint), &localhost_endpoints)) { + *out_endpoints = std::vector<HostResolverEndpointResult>(1); + (*out_endpoints)[0].ip_endpoints = localhost_endpoints; return OK; } int rv = ERR_DNS_CACHE_MISS; @@ -1000,8 +1042,14 @@ int MockHostResolverBase::ResolveFromIPLiteralOrCache( if (cache_result) { rv = cache_result->second.error(); if (rv == OK) { - *addresses = AddressList::CopyWithPort( - cache_result->second.legacy_addresses().value(), GetPort(endpoint)); + *out_endpoints = std::vector<HostResolverEndpointResult>(1); + (*out_endpoints)[0].ip_endpoints = *cache_result->second.ip_endpoints(); + + if (cache_result->second.aliases()) { + const auto& aliasess = *cache_result->second.aliases(); + *out_aliases = + std::set<std::string>(aliasess.begin(), aliasess.end()); + } *out_stale_info = std::move(stale_info); } @@ -1024,40 +1072,32 @@ int MockHostResolverBase::ResolveFromIPLiteralOrCache( int MockHostResolverBase::DoSynchronousResolution(RequestImpl& request) { state_->IncrementNumNonLocalResolves(); - const RuleResolver::RuleResult& result = rule_resolver_.Resolve( + const RuleResolver::RuleResultOrError& result = rule_resolver_.Resolve( request.request_endpoint(), request.parameters().dns_query_type, request.parameters().source); int error = ERR_UNEXPECTED; absl::optional<HostCache::Entry> cache_entry; - - if (absl::holds_alternative<AddressList>(result)) { - const AddressList& address_results = absl::get<AddressList>(result); - request.SetAddressResults(address_results, - /*staleness=*/absl::nullopt); - error = request.resolve_error_info().error; - cache_entry = - request.address_results() - ? HostCache::Entry(error, *request.address_results(), - HostCache::Entry::SOURCE_UNKNOWN) - : HostCache::Entry(error, HostCache::Entry::SOURCE_UNKNOWN); - } else if (absl::holds_alternative<std::vector<HostResolverEndpointResult>>( - result)) { - const auto& endpoint_results = - absl::get<std::vector<HostResolverEndpointResult>>(result); - request.SetEndpointResults(endpoint_results); + if (absl::holds_alternative<RuleResolver::RuleResult>(result)) { + const auto& rule_result = absl::get<RuleResolver::RuleResult>(result); + const auto& endpoint_results = rule_result.endpoints; + const auto& aliases = rule_result.aliases; + request.SetEndpointResults(endpoint_results, aliases, + /*staleness=*/absl::nullopt); // TODO(crbug.com/1264933): Change `error` on empty results? error = OK; - // TODO(crbug.com/1264933): Save result to cache. + if (cache_.get()) { + cache_entry = CreateCacheEntry(endpoint_results, aliases); + } } else { DCHECK(absl::holds_alternative<RuleResolver::ErrorResult>(result)); error = absl::get<RuleResolver::ErrorResult>(result); request.SetError(error); - cache_entry.emplace(error, HostCache::Entry::SOURCE_UNKNOWN); + if (cache_.get()) { + cache_entry.emplace(error, HostCache::Entry::SOURCE_UNKNOWN); + } } - if (cache_.get() && cache_entry.has_value()) { - DCHECK(cache_entry.has_value()); HostCache::Key key( GetCacheHost(request.request_endpoint()), request.parameters().dns_query_type, request.host_resolver_flags(), @@ -1116,10 +1156,10 @@ std::unique_ptr<HostResolver> MockHostResolverFactory::CreateStandaloneResolver( //----------------------------------------------------------------------------- RuleBasedHostResolverProc::Rule::Rule(ResolverType resolver_type, - const std::string& host_pattern, + base::StringPiece host_pattern, AddressFamily address_family, HostResolverFlags host_resolver_flags, - const std::string& replacement, + base::StringPiece replacement, std::vector<std::string> dns_aliases, int latency_ms) : resolver_type(resolver_type), @@ -1136,20 +1176,21 @@ RuleBasedHostResolverProc::Rule::Rule(const Rule& other) = default; RuleBasedHostResolverProc::Rule::~Rule() = default; -RuleBasedHostResolverProc::RuleBasedHostResolverProc(HostResolverProc* previous, - bool allow_fallback) - : HostResolverProc(previous, allow_fallback) {} +RuleBasedHostResolverProc::RuleBasedHostResolverProc( + scoped_refptr<HostResolverProc> previous, + bool allow_fallback) + : HostResolverProc(std::move(previous), allow_fallback) {} -void RuleBasedHostResolverProc::AddRule(const std::string& host_pattern, - const std::string& replacement) { +void RuleBasedHostResolverProc::AddRule(base::StringPiece host_pattern, + base::StringPiece replacement) { AddRuleForAddressFamily(host_pattern, ADDRESS_FAMILY_UNSPECIFIED, replacement); } void RuleBasedHostResolverProc::AddRuleForAddressFamily( - const std::string& host_pattern, + base::StringPiece host_pattern, AddressFamily address_family, - const std::string& replacement) { + base::StringPiece replacement) { DCHECK(!replacement.empty()); HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY; Rule rule(Rule::kResolverTypeSystem, host_pattern, address_family, flags, @@ -1158,8 +1199,8 @@ void RuleBasedHostResolverProc::AddRuleForAddressFamily( } void RuleBasedHostResolverProc::AddRuleWithFlags( - const std::string& host_pattern, - const std::string& replacement, + base::StringPiece host_pattern, + base::StringPiece replacement, HostResolverFlags flags, std::vector<std::string> dns_aliases) { DCHECK(!replacement.empty()); @@ -1169,9 +1210,9 @@ void RuleBasedHostResolverProc::AddRuleWithFlags( } void RuleBasedHostResolverProc::AddIPLiteralRule( - const std::string& host_pattern, - const std::string& ip_literal, - const std::string& canonical_name) { + base::StringPiece host_pattern, + base::StringPiece ip_literal, + base::StringPiece canonical_name) { // Literals are always resolved to themselves by HostResolverImpl, // consequently we do not support remapping them. IPAddress ip_address; @@ -1190,8 +1231,8 @@ void RuleBasedHostResolverProc::AddIPLiteralRule( } void RuleBasedHostResolverProc::AddIPLiteralRuleWithDnsAliases( - const std::string& host_pattern, - const std::string& ip_literal, + base::StringPiece host_pattern, + base::StringPiece ip_literal, std::vector<std::string> dns_aliases) { // Literals are always resolved to themselves by HostResolverImpl, // consequently we do not support remapping them. @@ -1208,8 +1249,8 @@ void RuleBasedHostResolverProc::AddIPLiteralRuleWithDnsAliases( } void RuleBasedHostResolverProc::AddRuleWithLatency( - const std::string& host_pattern, - const std::string& replacement, + base::StringPiece host_pattern, + base::StringPiece replacement, int latency_ms) { DCHECK(!replacement.empty()); HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY; @@ -1219,7 +1260,7 @@ void RuleBasedHostResolverProc::AddRuleWithLatency( } void RuleBasedHostResolverProc::AllowDirectLookup( - const std::string& host_pattern) { + base::StringPiece host_pattern) { HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY; Rule rule(Rule::kResolverTypeSystem, host_pattern, ADDRESS_FAMILY_UNSPECIFIED, flags, std::string(), /*dns_aliases=*/{}, 0); @@ -1227,7 +1268,7 @@ void RuleBasedHostResolverProc::AllowDirectLookup( } void RuleBasedHostResolverProc::AddSimulatedFailure( - const std::string& host_pattern, + base::StringPiece host_pattern, HostResolverFlags flags) { Rule rule(Rule::kResolverTypeFail, host_pattern, ADDRESS_FAMILY_UNSPECIFIED, flags, std::string(), /*dns_aliases=*/{}, 0); @@ -1235,7 +1276,7 @@ void RuleBasedHostResolverProc::AddSimulatedFailure( } void RuleBasedHostResolverProc::AddSimulatedTimeoutFailure( - const std::string& host_pattern, + base::StringPiece host_pattern, HostResolverFlags flags) { Rule rule(Rule::kResolverTypeFailTimeout, host_pattern, ADDRESS_FAMILY_UNSPECIFIED, flags, std::string(), @@ -1311,17 +1352,17 @@ int RuleBasedHostResolverProc::Resolve(const std::string& host, aliases = (!r->dns_aliases.empty()) ? r->dns_aliases : std::vector<std::string>({host}); - int result = - ParseAddressList(effective_host, aliases, &raw_addr_list); + std::vector<net::IPEndPoint> ip_endpoints; + int result = ParseAddressList(effective_host, &ip_endpoints); // Filter out addresses with the wrong family. *addrlist = AddressList(); - for (const auto& address : raw_addr_list) { + for (const auto& address : ip_endpoints) { if (address_family == ADDRESS_FAMILY_UNSPECIFIED || address_family == address.GetFamily()) { addrlist->push_back(address); } } - addrlist->SetDnsAliases(raw_addr_list.dns_aliases()); + addrlist->SetDnsAliases(aliases); if (result == OK && addrlist->empty()) return ERR_NAME_NOT_RESOLVED; @@ -1364,15 +1405,16 @@ void RuleBasedHostResolverProc::AddRuleInternal(const Rule& rule) { rules_.push_back(fixed_rule); } -RuleBasedHostResolverProc* CreateCatchAllHostResolverProc() { - RuleBasedHostResolverProc* catchall = - new RuleBasedHostResolverProc(/*previous=*/nullptr, - /*allow_fallback=*/false); +scoped_refptr<RuleBasedHostResolverProc> CreateCatchAllHostResolverProc() { + auto catchall = + base::MakeRefCounted<RuleBasedHostResolverProc>(/*previous=*/nullptr, + /*allow_fallback=*/false); // Note that IPv6 lookups fail. catchall->AddIPLiteralRule("*", "127.0.0.1", "localhost"); // Next add a rules-based layer that the test controls. - return new RuleBasedHostResolverProc(catchall, /*allow_fallback=*/false); + return base::MakeRefCounted<RuleBasedHostResolverProc>( + std::move(catchall), /*allow_fallback=*/false); } //----------------------------------------------------------------------------- @@ -1514,7 +1556,7 @@ ScopedDefaultHostResolverProc::~ScopedDefaultHostResolverProc() { void ScopedDefaultHostResolverProc::Init(HostResolverProc* proc) { current_proc_ = proc; previous_proc_ = HostResolverProc::SetDefault(current_proc_.get()); - current_proc_->SetLastProc(previous_proc_.get()); + current_proc_->SetLastProc(previous_proc_); } } // namespace net |