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