Fixup HostResolver alias results

Remove the `ipv*_alias_name` values from HostResolverEndpointResult.
We've decided that we won't need them.

Also make some adjustments to the behavior around
ResolveHostParameters::include_canonical_name to match our needs going
forward. The parameter now always ensures the system resolver is used
(DCHECKing on cases where other parameters prevent that) and the
GetDnsAliasResults() now returns exactly the single canonical name
received from the system resolver without any modification (matching
what could currently be read from
`GetAddressResults()->GetCanonicalName()`. While theoretically a
behavior change, this shouldn't actually affect any of the current
non-test usage because the parameter is only set when the system
resolver can be used and only getting the name from GetCanonicalName().
And alias names are now always included, if known, in
GetDnsAliasResults() regardless of the parameter (as was already the
case, but now it's documented and tested as such).

Also some test cleanups to add more reliance on GetDnsAiasResults() in
anticipation of reducing alias availability in address results.

Bug: 1264933
Change-Id: Iedc5f1eaa7aa01d3a34753e1ff0687d294b2b057
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3346200
Reviewed-by: David Benjamin <davidben@chromium.org>
Commit-Queue: Eric Orth <ericorth@chromium.org>
Cr-Commit-Position: refs/heads/main@{#953923}

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;

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

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(

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;

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")));
 }

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;

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}";
 }

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());