diff --git a/net/dns/host_resolver.cc b/net/dns/host_resolver.cc index fc3112f3782b2..05286aef8168d 100644 --- a/net/dns/host_resolver.cc +++ b/net/dns/host_resolver.cc @@ -270,15 +270,8 @@ int HostResolver::SquashErrorCode(int error) { std::vector<HostResolverEndpointResult> HostResolver::AddressListToEndpointResults(const AddressList& address_list) { HostResolverEndpointResult connection_endpoint; - connection_endpoint.ip_endpoints = address_list.endpoints(); - // AddressList always assumes a single alias name. Not completely accurate to - // assume it is valid for both address families, but only as inaccurate as - // AddressList has always been. - connection_endpoint.ipv4_alias_name = address_list.GetCanonicalName(); - connection_endpoint.ipv6_alias_name = address_list.GetCanonicalName(); - std::vector<HostResolverEndpointResult> list; list.push_back(std::move(connection_endpoint)); return list; diff --git a/net/dns/host_resolver.h b/net/dns/host_resolver.h index 9c8cb9d5fd084..c41f5c7793047 100644 --- a/net/dns/host_resolver.h +++ b/net/dns/host_resolver.h @@ -116,9 +116,15 @@ class NET_EXPORT HostResolver { // canonical name (i.e. address record name) through to query name. Should // only be called after Start() signals completion, either by invoking the // callback or by returning a result other than `ERR_IO_PENDING`. Returns a - // list of aliases that has been sanitized and canonicalized (as URL + // list of aliases that has been fixed up and canonicalized (as URL // hostnames), and thus may differ from the results stored directly in the // AddressList. + // + // If `ResolveHostParameters::include_canonical_name` was true, alias + // results will always be the single "canonical name" received from the + // system resolver without URL hostname canonicalization (or an empty vector + // or `nullopt` in the unusual case that the system resolver did not give a + // canonical name). virtual const absl::optional<std::vector<std::string>>& GetDnsAliasResults() const = 0; @@ -257,10 +263,18 @@ class NET_EXPORT HostResolver { }; CacheUsage cache_usage = CacheUsage::ALLOWED; - // If |true|, requests that the resolver include AddressList::canonical_name - // in the results. If the resolver can do so without significant - // performance impact, canonical_name may still be included even if - // parameter is set to |false|. + // If |true|, requests special behavior that the "canonical name" be + // requested from the system and be returned as the only entry in + // `ResolveHostRequest::GetDnsAliasResults()` results. Setting this + // parameter is disallowed for any requests that cannot be resolved using + // the system resolver, e.g. non-address requests or requests specifying a + // non-`SYSTEM` `source`. + // + // TODO(crbug.com/1282281): Consider allowing the built-in resolver to still + // be used with this parameter. Would then function as a request to just + // keep the single final name from the alias chain instead of all aliases, + // and also skip the canonicalization unless that canonicalization is found + // to be fine for usage. bool include_canonical_name = false; // Hint to the resolver that resolution is only being requested for loopback diff --git a/net/dns/host_resolver_manager.cc b/net/dns/host_resolver_manager.cc index f1efb4b3b483a..3247173ac1d8d 100644 --- a/net/dns/host_resolver_manager.cc +++ b/net/dns/host_resolver_manager.cc @@ -761,7 +761,24 @@ class HostResolverManager::RequestImpl const absl::optional<std::vector<std::string>>& GetDnsAliasResults() const override { DCHECK(complete_); - return sanitized_dns_alias_results_; + + // If `include_canonical_name` param was true, should only ever have at most + // a single alias, representing the expected "canonical name". +#if DCHECK_IS_ON() + if (parameters().include_canonical_name && fixed_up_dns_alias_results_) { + DCHECK_LE(fixed_up_dns_alias_results_->size(), 1u); + if (GetAddressResults()) { + DCHECK(GetAddressResults()->dns_aliases() == + fixed_up_dns_alias_results_.value()); + DCHECK_EQ(GetAddressResults()->GetCanonicalName(), + fixed_up_dns_alias_results_->empty() + ? "" + : fixed_up_dns_alias_results_->front()); + } + } +#endif // DCHECK_IS_ON() + + return fixed_up_dns_alias_results_; } const absl::optional<std::vector<bool>>& GetExperimentalResultsForTesting() @@ -874,16 +891,24 @@ class HostResolverManager::RequestImpl bool complete() const { return complete_; } - void SanitizeDnsAliasResults() { + void FixupDnsAliasResults() { // If there are no address results, if there are no aliases, or if there - // are already sanitized alias results, there is nothing to do. + // are already fixed up alias results, there is nothing to do. if (!results_ || !results_.value().addresses() || results_.value().addresses()->dns_aliases().empty() || - sanitized_dns_alias_results_) { + fixed_up_dns_alias_results_) { return; } - sanitized_dns_alias_results_ = dns_alias_utility::SanitizeDnsAliases( + // Skip fixups for `include_canonical_name` requests. Just use the + // canonical name exactly as it was received from the system resolver. + if (parameters().include_canonical_name) { + DCHECK_LE(results_.value().addresses()->dns_aliases().size(), 1u); + fixed_up_dns_alias_results_ = results_.value().addresses()->dns_aliases(); + return; + } + + fixed_up_dns_alias_results_ = dns_alias_utility::SanitizeDnsAliases( results_.value().addresses()->dns_aliases()); } @@ -954,7 +979,7 @@ class HostResolverManager::RequestImpl bool complete_; absl::optional<HostCache::Entry> results_; absl::optional<HostCache::EntryStaleness> stale_info_; - absl::optional<std::vector<std::string>> sanitized_dns_alias_results_; + absl::optional<std::vector<std::string>> fixed_up_dns_alias_results_; ResolveErrorInfo error_info_; const raw_ptr<const base::TickClock> tick_clock_; @@ -2791,9 +2816,9 @@ class HostResolverManager::Job : public PrioritizedDispatcher::Job, results.CopyWithDefaultPort(GetPort(req->request_host()))); // TODO(cammie): Move the sanitization deeper, possibly in - // HttpCache::Entry::SetResult(AddressList addresses), so that it + // HostCache::Entry::SetResult(AddressList addresses), so that it // doesn't happen on a per-request basis. - req->SanitizeDnsAliasResults(); + req->FixupDnsAliasResults(); } req->OnJobCompleted( this, results.error(), @@ -3223,7 +3248,7 @@ int HostResolverManager::Resolve(RequestImpl* request) { results.CopyWithDefaultPort(GetPort(request->request_host()))); // TODO(cammie): Sanitize before adding to the cache instead. - request->SanitizeDnsAliasResults(); + request->FixupDnsAliasResults(); } if (stale_info && !request->parameters().is_speculative) request->set_stale_info(std::move(stale_info).value()); @@ -3768,6 +3793,12 @@ void HostResolverManager::CreateTaskSequence( // If no external source allowed, a job should not be created or started break; } + + // `HOST_RESOLVER_CANONNAME` is only supported through system resolution. + if (job_key.flags & HOST_RESOLVER_CANONNAME) { + DCHECK(base::ranges::find(*out_tasks, TaskType::DNS) == out_tasks->end()); + DCHECK(base::ranges::find(*out_tasks, TaskType::MDNS) == out_tasks->end()); + } } void HostResolverManager::GetEffectiveParametersForRequest( diff --git a/net/dns/host_resolver_manager_fuzzer.cc b/net/dns/host_resolver_manager_fuzzer.cc index cc17b8cb9b696..72bc32f6addd5 100644 --- a/net/dns/host_resolver_manager_fuzzer.cc +++ b/net/dns/host_resolver_manager_fuzzer.cc @@ -163,7 +163,14 @@ class DnsRequest { data_provider_->ConsumeBool() ? net::HostResolver::ResolveHostParameters::CacheUsage::ALLOWED : net::HostResolver::ResolveHostParameters::CacheUsage::DISALLOWED; - parameters.include_canonical_name = data_provider_->ConsumeBool(); + + // `include_canonical_name` only allowed for address queries and only when + // the system resolver can be used. + if (net::IsAddressType(parameters.dns_query_type) && + parameters.source != net::HostResolverSource::DNS && + parameters.source != net::HostResolverSource::MULTICAST_DNS) { + parameters.include_canonical_name = data_provider_->ConsumeBool(); + } if (!IsParameterCombinationAllowed(parameters)) { return net::ERR_FAILED; diff --git a/net/dns/host_resolver_manager_unittest.cc b/net/dns/host_resolver_manager_unittest.cc index 1c5d51822b37f..bdf6521332cea 100644 --- a/net/dns/host_resolver_manager_unittest.cc +++ b/net/dns/host_resolver_manager_unittest.cc @@ -2642,8 +2642,73 @@ TEST_F(HostResolverManagerTest, IncludeCanonicalName) { EXPECT_THAT( response.request()->GetEndpointResults(), testing::Optional(testing::UnorderedElementsAre(ExpectEndpointResult( - testing::ElementsAre(CreateExpected("192.168.1.42", 80)), - "canon.name")))); + testing::ElementsAre(CreateExpected("192.168.1.42", 80)))))); + EXPECT_THAT(response.request()->GetDnsAliasResults(), + testing::Optional(testing::ElementsAre("canon.name"))); + + EXPECT_THAT(response_no_flag.result_error(), IsError(ERR_NAME_NOT_RESOLVED)); +} + +TEST_F(HostResolverManagerTest, IncludeCanonicalNameButNotReceived) { + proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42", + HOST_RESOLVER_CANONNAME); + proc_->SignalMultiple(2u); + + HostResolver::ResolveHostParameters parameters; + parameters.include_canonical_name = true; + ResolveHostResponseHelper response(resolver_->CreateRequest( + HostPortPair("just.testing", 80), NetworkIsolationKey(), + NetLogWithSource(), parameters, resolve_context_.get(), + resolve_context_->host_cache())); + ResolveHostResponseHelper response_no_flag(resolver_->CreateRequest( + HostPortPair("just.testing", 80), NetworkIsolationKey(), + NetLogWithSource(), absl::nullopt, resolve_context_.get(), + resolve_context_->host_cache())); + + EXPECT_THAT(response.result_error(), IsOk()); + EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(), + testing::ElementsAre(CreateExpected("192.168.1.42", 80))); + EXPECT_EQ("", + response.request()->GetAddressResults().value().GetCanonicalName()); + EXPECT_THAT( + response.request()->GetEndpointResults(), + testing::Optional(testing::UnorderedElementsAre(ExpectEndpointResult( + testing::ElementsAre(CreateExpected("192.168.1.42", 80)))))); + EXPECT_EQ(response.request()->GetDnsAliasResults(), absl::nullopt); + + EXPECT_THAT(response_no_flag.result_error(), IsError(ERR_NAME_NOT_RESOLVED)); +} + +// If `ResolveHostParameters::include_canonical_name` is set, canonical name +// should be returned exactly as received from the system resolver, without any +// attempt to do URL hostname canonicalization on it. +TEST_F(HostResolverManagerTest, IncludeCanonicalNameSkipsUrlCanonicalization) { + proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42", + HOST_RESOLVER_CANONNAME, "CANON.name"); + proc_->SignalMultiple(2u); + + HostResolver::ResolveHostParameters parameters; + parameters.include_canonical_name = true; + ResolveHostResponseHelper response(resolver_->CreateRequest( + HostPortPair("just.testing", 80), NetworkIsolationKey(), + NetLogWithSource(), parameters, resolve_context_.get(), + resolve_context_->host_cache())); + ResolveHostResponseHelper response_no_flag(resolver_->CreateRequest( + HostPortPair("just.testing", 80), NetworkIsolationKey(), + NetLogWithSource(), absl::nullopt, resolve_context_.get(), + resolve_context_->host_cache())); + + EXPECT_THAT(response.result_error(), IsOk()); + EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(), + testing::ElementsAre(CreateExpected("192.168.1.42", 80))); + EXPECT_EQ("CANON.name", + response.request()->GetAddressResults().value().GetCanonicalName()); + EXPECT_THAT( + response.request()->GetEndpointResults(), + testing::Optional(testing::UnorderedElementsAre(ExpectEndpointResult( + testing::ElementsAre(CreateExpected("192.168.1.42", 80)))))); + EXPECT_THAT(response.request()->GetDnsAliasResults(), + testing::Optional(testing::ElementsAre("CANON.name"))); EXPECT_THAT(response_no_flag.result_error(), IsError(ERR_NAME_NOT_RESOLVED)); } @@ -7406,32 +7471,6 @@ TEST_F(HostResolverManagerDnsTest, TtlNotSharedBetweenQtypes) { EXPECT_EQ(resolve_context_->host_cache()->size(), 0u); } -TEST_F(HostResolverManagerDnsTest, NoCanonicalName) { - MockDnsClientRuleList rules; - AddDnsRule(&rules, "alias", dns_protocol::kTypeA, IPAddress::IPv4Localhost(), - "canonical", false /* delay */); - AddDnsRule(&rules, "alias", dns_protocol::kTypeAAAA, - IPAddress::IPv6Localhost(), "canonical", false /* delay */); - - CreateResolver(); - UseMockDnsClient(CreateValidDnsConfig(), std::move(rules)); - set_allow_fallback_to_proctask(false); - - ResolveHostResponseHelper response(resolver_->CreateRequest( - HostPortPair("alias", 80), NetworkIsolationKey(), NetLogWithSource(), - absl::nullopt, resolve_context_.get(), resolve_context_->host_cache())); - ASSERT_THAT(response.result_error(), IsOk()); - - // HostResolver may still give name, but if so, it must be correct. - std::string result_name = - response.request()->GetAddressResults().value().GetCanonicalName(); - EXPECT_TRUE(result_name.empty() || result_name == "canonical"); - EXPECT_THAT(response.request()->GetEndpointResults(), - testing::Optional(testing::ElementsAre(ExpectEndpointResult( - _, testing::AnyOf(IsEmpty(), "canonical"), - testing::AnyOf(IsEmpty(), "canonical"))))); -} - TEST_F(HostResolverManagerDnsTest, CanonicalName) { MockDnsClientRuleList rules; AddDnsRule(&rules, "alias", dns_protocol::kTypeA, IPAddress::IPv4Localhost(), @@ -7444,7 +7483,6 @@ TEST_F(HostResolverManagerDnsTest, CanonicalName) { set_allow_fallback_to_proctask(false); HostResolver::ResolveHostParameters params; - params.include_canonical_name = true; params.source = HostResolverSource::DNS; ResolveHostResponseHelper response(resolver_->CreateRequest( HostPortPair("alias", 80), NetworkIsolationKey(), NetLogWithSource(), @@ -7453,9 +7491,8 @@ TEST_F(HostResolverManagerDnsTest, CanonicalName) { EXPECT_EQ(response.request()->GetAddressResults().value().GetCanonicalName(), "canonical"); - EXPECT_THAT(response.request()->GetEndpointResults(), - testing::Optional(testing::ElementsAre( - ExpectEndpointResult(_, "canonical", "canonical")))); + EXPECT_THAT(response.request()->GetDnsAliasResults(), + testing::Optional(testing::ElementsAre("canonical", "alias"))); } TEST_F(HostResolverManagerDnsTest, CanonicalName_PreferV6) { @@ -7470,7 +7507,6 @@ TEST_F(HostResolverManagerDnsTest, CanonicalName_PreferV6) { set_allow_fallback_to_proctask(false); HostResolver::ResolveHostParameters params; - params.include_canonical_name = true; params.source = HostResolverSource::DNS; ResolveHostResponseHelper response(resolver_->CreateRequest( HostPortPair("alias", 80), NetworkIsolationKey(), NetLogWithSource(), @@ -7481,11 +7517,11 @@ TEST_F(HostResolverManagerDnsTest, CanonicalName_PreferV6) { ASSERT_THAT(response.result_error(), IsOk()); EXPECT_EQ(response.request()->GetAddressResults().value().GetCanonicalName(), "correct"); - // TODO(crbug.com/1264933): Fix validation once separate cnames are wired by - // address family. - EXPECT_THAT(response.request()->GetEndpointResults(), - testing::Optional(testing::ElementsAre( - ExpectEndpointResult(_, "correct", "correct")))); + + // GetDnsAliasResults() includes all aliases from all families. + EXPECT_THAT(response.request()->GetDnsAliasResults(), + testing::Optional( + testing::UnorderedElementsAre("correct", "alias", "wrong"))); } TEST_F(HostResolverManagerDnsTest, CanonicalName_V4Only) { @@ -7498,7 +7534,6 @@ TEST_F(HostResolverManagerDnsTest, CanonicalName_V4Only) { HostResolver::ResolveHostParameters params; params.dns_query_type = DnsQueryType::A; - params.include_canonical_name = true; params.source = HostResolverSource::DNS; ResolveHostResponseHelper response(resolver_->CreateRequest( HostPortPair("alias", 80), NetworkIsolationKey(), NetLogWithSource(), @@ -7506,11 +7541,8 @@ TEST_F(HostResolverManagerDnsTest, CanonicalName_V4Only) { ASSERT_THAT(response.result_error(), IsOk()); EXPECT_EQ(response.request()->GetAddressResults().value().GetCanonicalName(), "correct"); - // TODO(crbug.com/1264933): Fix validation once separate cnames are wired by - // address family. - EXPECT_THAT(response.request()->GetEndpointResults(), - testing::Optional(testing::ElementsAre( - ExpectEndpointResult(_, "correct", "correct")))); + EXPECT_THAT(response.request()->GetDnsAliasResults(), + testing::Optional(testing::ElementsAre("correct", "alias"))); } // Test that responses containing CNAME records but no address results are fine @@ -7544,6 +7576,7 @@ TEST_F(HostResolverManagerDnsTest, CanonicalNameWithoutResults) { resolve_context_->host_cache())); ASSERT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED)); + EXPECT_EQ(response.request()->GetDnsAliasResults(), absl::nullopt); // Underlying error should be the typical no-results error // (ERR_NAME_NOT_RESOLVED), not anything more exotic like @@ -7617,9 +7650,8 @@ TEST_F(HostResolverManagerDnsTest, CanonicalNameForcesProc) { EXPECT_EQ(response.request()->GetAddressResults().value().GetCanonicalName(), "canonical"); - EXPECT_THAT(response.request()->GetEndpointResults(), - testing::Optional(testing::ElementsAre( - ExpectEndpointResult(_, "canonical", "canonical")))); + EXPECT_THAT(response.request()->GetDnsAliasResults(), + testing::Optional(testing::ElementsAre("canonical"))); } TEST_F(HostResolverManagerDnsTest, DnsAliases) { @@ -7649,7 +7681,6 @@ TEST_F(HostResolverManagerDnsTest, DnsAliases) { UseMockDnsClient(CreateValidDnsConfig(), std::move(rules)); set_allow_fallback_to_proctask(false); HostResolver::ResolveHostParameters params; - params.include_canonical_name = true; params.source = HostResolverSource::DNS; ResolveHostResponseHelper response(resolver_->CreateRequest( @@ -7663,22 +7694,20 @@ TEST_F(HostResolverManagerDnsTest, DnsAliases) { EXPECT_THAT(response.request()->GetAddressResults().value().dns_aliases(), testing::ElementsAre("fourth.test", "third.test", "second.test", "first.test")); - EXPECT_THAT(response.request()->GetEndpointResults(), - testing::Optional(testing::ElementsAre( - ExpectEndpointResult(_, "fourth.test", "fourth.test")))); EXPECT_THAT(response.request()->GetDnsAliasResults(), testing::Optional(testing::ElementsAre( "fourth.test", "third.test", "second.test", "first.test"))); } -TEST_F(HostResolverManagerDnsTest, DnsAliasesAreSanitized) { +TEST_F(HostResolverManagerDnsTest, DnsAliasesAreFixedUp) { MockDnsClientRuleList rules; DnsResponse expected_A_response = BuildTestDnsResponse( "host.test", dns_protocol::kTypeA, {BuildTestAddressRecord("localhost", IPAddress::IPv4Localhost()), - BuildTestCnameRecord("host.test", "localhost")}); + BuildTestCnameRecord("HOST2.test", "localhost"), + BuildTestCnameRecord("host.test", "HOST2.test")}); AddDnsRule(&rules, "host.test", dns_protocol::kTypeA, std::move(expected_A_response), false /* delay */); @@ -7686,7 +7715,8 @@ TEST_F(HostResolverManagerDnsTest, DnsAliasesAreSanitized) { DnsResponse expected_AAAA_response = BuildTestDnsResponse( "host.test", dns_protocol::kTypeAAAA, {BuildTestAddressRecord("localhost", IPAddress::IPv6Localhost()), - BuildTestCnameRecord("host.test", "localhost")}); + BuildTestCnameRecord("HOST2.test", "localhost"), + BuildTestCnameRecord("host.test", "HOST2.test")}); AddDnsRule(&rules, "host.test", dns_protocol::kTypeAAAA, std::move(expected_AAAA_response), false /* delay */); @@ -7695,28 +7725,26 @@ TEST_F(HostResolverManagerDnsTest, DnsAliasesAreSanitized) { UseMockDnsClient(CreateValidDnsConfig(), std::move(rules)); set_allow_fallback_to_proctask(false); HostResolver::ResolveHostParameters params; - params.include_canonical_name = true; params.source = HostResolverSource::DNS; ResolveHostResponseHelper response(resolver_->CreateRequest( HostPortPair("host.test", 80), NetworkIsolationKey(), NetLogWithSource(), params, resolve_context_.get(), resolve_context_->host_cache())); - // Verify that, while the AddressResults contain the full unsanitized alias + // Verify that, while the AddressResults contain the full unfixed alias // list (which has "localhost" has first element and canonical name i.e. // address record name), the call to ResolveHostRequest::GetDnsAliasResults - // returns a sanitized list. + // returns a fixed up list, including URL hostname canonicalization to + // uncapitalize "HOST.test". ASSERT_THAT(response.result_error(), IsOk()); ASSERT_TRUE(response.request()->GetAddressResults()); EXPECT_EQ(response.request()->GetAddressResults().value().GetCanonicalName(), "localhost"); EXPECT_THAT(response.request()->GetAddressResults().value().dns_aliases(), - testing::ElementsAre("localhost", "host.test")); - EXPECT_THAT(response.request()->GetEndpointResults(), - testing::Optional(testing::ElementsAre( - ExpectEndpointResult(_, "localhost", "localhost")))); - EXPECT_THAT(response.request()->GetDnsAliasResults(), - testing::Optional(testing::ElementsAre("host.test"))); + testing::ElementsAre("localhost", "HOST2.test", "host.test")); + EXPECT_THAT( + response.request()->GetDnsAliasResults(), + testing::Optional(testing::ElementsAre("host2.test", "host.test"))); } TEST_F(HostResolverManagerDnsTest, NoAdditionalDnsAliases) { @@ -7732,7 +7760,6 @@ TEST_F(HostResolverManagerDnsTest, NoAdditionalDnsAliases) { UseMockDnsClient(CreateValidDnsConfig(), std::move(rules)); set_allow_fallback_to_proctask(false); HostResolver::ResolveHostParameters params; - params.include_canonical_name = true; params.source = HostResolverSource::DNS; ResolveHostResponseHelper response(resolver_->CreateRequest( @@ -7745,9 +7772,6 @@ TEST_F(HostResolverManagerDnsTest, NoAdditionalDnsAliases) { "first.test"); EXPECT_THAT(response.request()->GetAddressResults().value().dns_aliases(), testing::ElementsAre("first.test")); - EXPECT_THAT(response.request()->GetEndpointResults(), - testing::Optional(testing::ElementsAre( - ExpectEndpointResult(_, "first.test", "first.test")))); EXPECT_THAT(response.request()->GetDnsAliasResults(), testing::Optional(testing::ElementsAre("first.test"))); } diff --git a/net/dns/host_resolver_results.h b/net/dns/host_resolver_results.h index 602cf0275775b..a03442f8f59bc 100644 --- a/net/dns/host_resolver_results.h +++ b/net/dns/host_resolver_results.h @@ -29,14 +29,6 @@ struct NET_EXPORT_PRIVATE HostResolverEndpointResult { // IP endpoints at which to connect to the service. std::vector<net::IPEndPoint> ip_endpoints; - // The final name in the alias chain (DNS CNAME or HTTPS) at which the - // IPv4 addresses were found. - std::string ipv4_alias_name; - - // The final name in the alias chain (DNS CNAME or HTTPS) at which the - // IPv6 addresses were found. - std::string ipv6_alias_name; - // Additional metadata for creating connections to the endpoint. Typically // sourced from DNS HTTPS records. ConnectionEndpointMetadata metadata; diff --git a/net/dns/host_resolver_results_test_util.cc b/net/dns/host_resolver_results_test_util.cc index 8e361b0e40dde..b779ec3572f56 100644 --- a/net/dns/host_resolver_results_test_util.cc +++ b/net/dns/host_resolver_results_test_util.cc @@ -5,7 +5,6 @@ #include "net/dns/host_resolver_results_test_util.h" #include <ostream> -#include <string> #include <utility> #include <vector> @@ -24,12 +23,8 @@ class EndpointResultMatcher public: EndpointResultMatcher( testing::Matcher<std::vector<IPEndPoint>> ip_endpoints_matcher, - testing::Matcher<std::string> ipv4_alias_name_matcher, - testing::Matcher<std::string> ipv6_alias_name_matcher, testing::Matcher<const ConnectionEndpointMetadata&> metadata_matcher) : ip_endpoints_matcher_(std::move(ip_endpoints_matcher)), - ipv4_alias_name_matcher_(std::move(ipv4_alias_name_matcher)), - ipv6_alias_name_matcher_(std::move(ipv6_alias_name_matcher)), metadata_matcher_(std::move(metadata_matcher)) {} ~EndpointResultMatcher() override = default; @@ -47,16 +42,6 @@ class EndpointResultMatcher &HostResolverEndpointResult::ip_endpoints, ip_endpoints_matcher_), endpoint, result_listener) && - ExplainMatchResult( - testing::Field("ipv4_alias_name", - &HostResolverEndpointResult::ipv4_alias_name, - ipv4_alias_name_matcher_), - endpoint, result_listener) && - ExplainMatchResult( - testing::Field("ipv6_alias_name", - &HostResolverEndpointResult::ipv6_alias_name, - ipv6_alias_name_matcher_), - endpoint, result_listener) && ExplainMatchResult( testing::Field("metadata", &HostResolverEndpointResult::metadata, metadata_matcher_), @@ -76,16 +61,11 @@ class EndpointResultMatcher private: void Describe(std::ostream& os) const { os << "HostResolverEndpointResult {\nip_endpoints: " - << testing::PrintToString(ip_endpoints_matcher_) << "\nipv4_alias_name: " - << testing::PrintToString(ipv4_alias_name_matcher_) - << "\nipv6_alias_name: " - << testing::PrintToString(ipv6_alias_name_matcher_) + << testing::PrintToString(ip_endpoints_matcher_) << "\nmetadata: " << testing::PrintToString(metadata_matcher_) << "\n}"; } testing::Matcher<std::vector<IPEndPoint>> ip_endpoints_matcher_; - testing::Matcher<std::string> ipv4_alias_name_matcher_; - testing::Matcher<std::string> ipv6_alias_name_matcher_; testing::Matcher<const ConnectionEndpointMetadata&> metadata_matcher_; }; @@ -93,20 +73,15 @@ class EndpointResultMatcher testing::Matcher<const HostResolverEndpointResult&> ExpectEndpointResult( testing::Matcher<std::vector<IPEndPoint>> ip_endpoints_matcher, - testing::Matcher<std::string> ipv4_alias_name_matcher, - testing::Matcher<std::string> ipv6_alias_name_matcher, testing::Matcher<const ConnectionEndpointMetadata&> metadata_matcher) { return testing::MakeMatcher(new EndpointResultMatcher( - std::move(ip_endpoints_matcher), std::move(ipv4_alias_name_matcher), - std::move(ipv6_alias_name_matcher), std::move(metadata_matcher))); + std::move(ip_endpoints_matcher), std::move(metadata_matcher))); } std::ostream& operator<<(std::ostream& os, const HostResolverEndpointResult& endpoint_result) { return os << "HostResolverEndpointResult {\nip_endpoints: " << testing::PrintToString(endpoint_result.ip_endpoints) - << "\nipv4_alias_name: " << endpoint_result.ipv4_alias_name - << "\nipv6_alias_name: " << endpoint_result.ipv6_alias_name << "\nmetadata: " << testing::PrintToString(endpoint_result.metadata) << "\n}"; } diff --git a/net/dns/host_resolver_results_test_util.h b/net/dns/host_resolver_results_test_util.h index 3d0f9b92c42e0..73aa28954bdfe 100644 --- a/net/dns/host_resolver_results_test_util.h +++ b/net/dns/host_resolver_results_test_util.h @@ -6,7 +6,6 @@ #define NET_DNS_HOST_RESOLVER_RESULTS_TEST_UTIL_H_ #include <ostream> -#include <string> #include <vector> #include "net/base/connection_endpoint_metadata_test_util.h" @@ -22,8 +21,6 @@ struct HostResolverEndpointResult; testing::Matcher<const HostResolverEndpointResult&> ExpectEndpointResult( testing::Matcher<std::vector<IPEndPoint>> ip_endpoints_matcher = testing::IsEmpty(), - testing::Matcher<std::string> ipv4_alias_name_matcher = testing::_, - testing::Matcher<std::string> ipv6_alias_name_matcher = testing::_, testing::Matcher<const ConnectionEndpointMetadata&> metadata_matcher = ExpectConnectionEndpointMetadata());