grpc 1.48.0 → 1.49.0.pre1

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.cc

@@ -21,6 +21,8 @@
 #include <algorithm>
 #include <vector>
 
+#include "absl/strings/string_view.h"
+
 #include "src/core/lib/iomgr/sockaddr.h"
 
 // IWYU pragma: no_include <arpa/nameser.h>
@@ -41,7 +43,6 @@
 #include <address_sorting/address_sorting.h>
 #include <ares.h>
 
-#include "absl/container/inlined_vector.h"
 #include "absl/memory/memory.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -598,12 +599,10 @@ static void grpc_ares_request_unref_locked(grpc_ares_request* r)
 
 void grpc_ares_complete_request_locked(grpc_ares_request* r)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(r->mu) {
-  /* Invoke on_done callback and destroy the
-     request */
+  // Invoke on_done callback and destroy the request
   r->ev_driver = nullptr;
-  ServerAddressList* addresses = r->addresses_out->get();
-  if (addresses != nullptr) {
-    grpc_cares_wrapper_address_sorting_sort(r, addresses);
+  if (r->addresses_out != nullptr && *r->addresses_out != nullptr) {
+    grpc_cares_wrapper_address_sorting_sort(r, r->addresses_out->get());
     GRPC_ERROR_UNREF(r->error);
     r->error = GRPC_ERROR_NONE;
     // TODO(apolcyn): allow c-ares to return a service config
@@ -664,13 +663,10 @@ static void on_hostbyname_done_locked(void* arg, int status, int /*timeouts*/,
     }
     ServerAddressList& addresses = **address_list_ptr;
     for (size_t i = 0; hostent->h_addr_list[i] != nullptr; ++i) {
-      absl::InlinedVector<grpc_arg, 1> args_to_add;
+      grpc_core::ChannelArgs args;
       if (hr->is_balancer) {
-        args_to_add.emplace_back(grpc_channel_arg_string_create(
-            const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY), hr->host));
+        args = args.Set(GRPC_ARG_DEFAULT_AUTHORITY, hr->host);
       }
-      grpc_channel_args* args = grpc_channel_args_copy_and_add(
-          nullptr, args_to_add.data(), args_to_add.size());
       switch (hostent->h_addrtype) {
         case AF_INET6: {
           size_t addr_len = sizeof(struct sockaddr_in6);
@@ -816,6 +812,7 @@ static void on_txt_done_locked(void* arg, int status, int /*timeouts*/,
   }
   // Clean up.
   ares_free_data(reply);
+  grpc_ares_request_unref_locked(r);
   return;
 fail:
   std::string error_msg =
@@ -827,38 +824,14 @@ fail:
   r->error = grpc_error_add_child(error, r->error);
 }
 
-void grpc_dns_lookup_ares_continue_after_check_localhost_and_ip_literals_locked(
-    grpc_ares_request* r, const char* dns_server, const char* name,
-    const char* default_port, grpc_pollset_set* interested_parties,
-    int query_timeout_ms) ABSL_EXCLUSIVE_LOCKS_REQUIRED(r->mu) {
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  grpc_ares_hostbyname_request* hr = nullptr;
-  /* parse name, splitting it into host and port parts */
-  std::string host;
-  std::string port;
-  grpc_core::SplitHostPort(name, &host, &port);
-  if (host.empty()) {
-    error = grpc_error_set_str(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("unparseable host:port"),
-        GRPC_ERROR_STR_TARGET_ADDRESS, name);
-    goto error_cleanup;
-  } else if (port.empty()) {
-    if (default_port == nullptr || strlen(default_port) == 0) {
-      error = grpc_error_set_str(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("no port in name"),
-          GRPC_ERROR_STR_TARGET_ADDRESS, name);
-      goto error_cleanup;
-    }
-    port = default_port;
-  }
-  error = grpc_ares_ev_driver_create_locked(&r->ev_driver, interested_parties,
-                                            query_timeout_ms, r);
-  if (!GRPC_ERROR_IS_NONE(error)) goto error_cleanup;
-  // If dns_server is specified, use it.
-  if (dns_server != nullptr && dns_server[0] != '\0') {
-    GRPC_CARES_TRACE_LOG("request:%p Using DNS server %s", r, dns_server);
+grpc_error_handle set_request_dns_server(grpc_ares_request* r,
+                                         absl::string_view dns_server)
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(r->mu) {
+  if (!dns_server.empty()) {
+    GRPC_CARES_TRACE_LOG("request:%p Using DNS server %s", r,
+                         dns_server.data());
     grpc_resolved_address addr;
-    if (grpc_parse_ipv4_hostport(dns_server, &addr, false /* log_errors */)) {
+    if (grpc_parse_ipv4_hostport(dns_server, &addr, /*log_errors=*/false)) {
       r->dns_server_addr.family = AF_INET;
       struct sockaddr_in* in = reinterpret_cast<struct sockaddr_in*>(addr.addr);
       memcpy(&r->dns_server_addr.addr.addr4, &in->sin_addr,
@@ -866,7 +839,7 @@ void grpc_dns_lookup_ares_continue_after_check_localhost_and_ip_literals_locked(
       r->dns_server_addr.tcp_port = grpc_sockaddr_get_port(&addr);
       r->dns_server_addr.udp_port = grpc_sockaddr_get_port(&addr);
     } else if (grpc_parse_ipv6_hostport(dns_server, &addr,
-                                        false /* log_errors */)) {
+                                        /*log_errors=*/false)) {
       r->dns_server_addr.family = AF_INET6;
       struct sockaddr_in6* in6 =
           reinterpret_cast<struct sockaddr_in6*>(addr.addr);
@@ -875,51 +848,49 @@ void grpc_dns_lookup_ares_continue_after_check_localhost_and_ip_literals_locked(
       r->dns_server_addr.tcp_port = grpc_sockaddr_get_port(&addr);
       r->dns_server_addr.udp_port = grpc_sockaddr_get_port(&addr);
     } else {
-      error = grpc_error_set_str(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("cannot parse authority"),
-          GRPC_ERROR_STR_TARGET_ADDRESS, name);
-      goto error_cleanup;
+      return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+          absl::StrCat("cannot parse authority ", dns_server));
     }
     int status =
         ares_set_servers_ports(r->ev_driver->channel, &r->dns_server_addr);
     if (status != ARES_SUCCESS) {
-      error = GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+      return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
           "C-ares status is not ARES_SUCCESS: ", ares_strerror(status)));
-      goto error_cleanup;
     }
   }
-  r->pending_queries = 1;
-  if (grpc_ares_query_ipv6()) {
-    hr = create_hostbyname_request_locked(r, host.c_str(),
-                                          grpc_strhtons(port.c_str()),
-                                          /*is_balancer=*/false, "AAAA");
-    ares_gethostbyname(r->ev_driver->channel, hr->host, AF_INET6,
-                       on_hostbyname_done_locked, hr);
-  }
-  hr = create_hostbyname_request_locked(r, host.c_str(),
-                                        grpc_strhtons(port.c_str()),
-                                        /*is_balancer=*/false, "A");
-  ares_gethostbyname(r->ev_driver->channel, hr->host, AF_INET,
-                     on_hostbyname_done_locked, hr);
-  if (r->balancer_addresses_out != nullptr) {
-    /* Query the SRV record */
-    std::string service_name = absl::StrCat("_grpclb._tcp.", host);
-    GrpcAresQuery* srv_query = new GrpcAresQuery(r, service_name);
-    ares_query(r->ev_driver->channel, service_name.c_str(), ns_c_in, ns_t_srv,
-               on_srv_query_done_locked, srv_query);
-  }
-  if (r->service_config_json_out != nullptr) {
-    std::string config_name = absl::StrCat("_grpc_config.", host);
-    GrpcAresQuery* txt_query = new GrpcAresQuery(r, config_name);
-    ares_search(r->ev_driver->channel, config_name.c_str(), ns_c_in, ns_t_txt,
-                on_txt_done_locked, txt_query);
-  }
-  grpc_ares_ev_driver_start_locked(r->ev_driver);
-  grpc_ares_request_unref_locked(r);
-  return;
+  return GRPC_ERROR_NONE;
+}
 
-error_cleanup:
-  grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
+// Common logic for all lookup methods.
+// If an error occurs, callers must run the client callback.
+grpc_error_handle grpc_dns_lookup_ares_continued(
+    grpc_ares_request* r, const char* dns_server, const char* name,
+    const char* default_port, grpc_pollset_set* interested_parties,
+    int query_timeout_ms, std::string* host, std::string* port, bool check_port)
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(r->mu) {
+  grpc_error_handle error = GRPC_ERROR_NONE;
+  /* parse name, splitting it into host and port parts */
+  grpc_core::SplitHostPort(name, host, port);
+  if (host->empty()) {
+    error = grpc_error_set_str(
+        GRPC_ERROR_CREATE_FROM_STATIC_STRING("unparseable host:port"),
+        GRPC_ERROR_STR_TARGET_ADDRESS, name);
+    return error;
+  } else if (check_port && port->empty()) {
+    if (default_port == nullptr || strlen(default_port) == 0) {
+      error = grpc_error_set_str(
+          GRPC_ERROR_CREATE_FROM_STATIC_STRING("no port in name"),
+          GRPC_ERROR_STR_TARGET_ADDRESS, name);
+      return error;
+    }
+    *port = default_port;
+  }
+  error = grpc_ares_ev_driver_create_locked(&r->ev_driver, interested_parties,
+                                            query_timeout_ms, r);
+  if (!GRPC_ERROR_IS_NONE(error)) return error;
+  // If dns_server is specified, use it.
+  error = set_request_dns_server(r, dns_server);
+  return error;
 }
 
 static bool inner_resolve_as_ip_literal_locked(
@@ -951,7 +922,7 @@ static bool inner_resolve_as_ip_literal_locked(
                                false /* log errors */)) {
     GPR_ASSERT(*addrs == nullptr);
     *addrs = absl::make_unique<ServerAddressList>();
-    (*addrs)->emplace_back(addr.addr, addr.len, nullptr /* args */);
+    (*addrs)->emplace_back(addr.addr, addr.len, grpc_core::ChannelArgs());
     return true;
   }
   return false;
@@ -1017,7 +988,7 @@ static bool inner_maybe_resolve_localhost_manually_locked(
     ipv6_loopback_addr.sin6_family = AF_INET6;
     ipv6_loopback_addr.sin6_port = numeric_port;
     (*addrs)->emplace_back(&ipv6_loopback_addr, sizeof(ipv6_loopback_addr),
-                           nullptr /* args */);
+                           grpc_core::ChannelArgs() /* args */);
     // Append the ipv4 loopback address.
     struct sockaddr_in ipv4_loopback_addr;
     memset(&ipv4_loopback_addr, 0, sizeof(ipv4_loopback_addr));
@@ -1026,7 +997,7 @@ static bool inner_maybe_resolve_localhost_manually_locked(
     ipv4_loopback_addr.sin_family = AF_INET;
     ipv4_loopback_addr.sin_port = numeric_port;
     (*addrs)->emplace_back(&ipv4_loopback_addr, sizeof(ipv4_loopback_addr),
-                           nullptr /* args */);
+                           grpc_core::ChannelArgs() /* args */);
     // Let the address sorter figure out which one should be tried first.
     grpc_cares_wrapper_address_sorting_sort(r, addrs->get());
     return true;
@@ -1051,21 +1022,18 @@ static bool grpc_ares_maybe_resolve_localhost_manually_locked(
 }
 #endif /* GRPC_ARES_RESOLVE_LOCALHOST_MANUALLY */
 
-static grpc_ares_request* grpc_dns_lookup_ares_impl(
+static grpc_ares_request* grpc_dns_lookup_hostname_ares_impl(
     const char* dns_server, const char* name, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
     std::unique_ptr<grpc_core::ServerAddressList>* addrs,
-    std::unique_ptr<grpc_core::ServerAddressList>* balancer_addrs,
-    char** service_config_json, int query_timeout_ms) {
+    int query_timeout_ms) {
   grpc_ares_request* r = new grpc_ares_request();
   grpc_core::MutexLock lock(&r->mu);
   r->ev_driver = nullptr;
   r->on_done = on_done;
   r->addresses_out = addrs;
-  r->balancer_addresses_out = balancer_addrs;
-  r->service_config_json_out = service_config_json;
   GRPC_CARES_TRACE_LOG(
-      "request:%p c-ares grpc_dns_lookup_ares_impl name=%s, "
+      "request:%p c-ares grpc_dns_lookup_hostname_ares_impl name=%s, "
       "default_port=%s",
       r, name, default_port);
   // Early out if the target is an ipv4 or ipv6 literal.
@@ -1079,26 +1047,129 @@ static grpc_ares_request* grpc_dns_lookup_ares_impl(
     grpc_ares_complete_request_locked(r);
     return r;
   }
-  // Don't query for SRV and TXT records if the target is "localhost", so
-  // as to cut down on lookups over the network, especially in tests:
-  // https://github.com/grpc/proposal/pull/79
+  // Look up name using c-ares lib.
+  std::string host;
+  std::string port;
+  grpc_error_handle error = grpc_dns_lookup_ares_continued(
+      r, dns_server, name, default_port, interested_parties, query_timeout_ms,
+      &host, &port, true);
+  if (!GRPC_ERROR_IS_NONE(error)) {
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
+    return r;
+  }
+  r->pending_queries = 1;
+  grpc_ares_hostbyname_request* hr = nullptr;
+  if (grpc_ares_query_ipv6()) {
+    hr = create_hostbyname_request_locked(r, host.c_str(),
+                                          grpc_strhtons(port.c_str()),
+                                          /*is_balancer=*/false, "AAAA");
+    ares_gethostbyname(r->ev_driver->channel, hr->host, AF_INET6,
+                       on_hostbyname_done_locked, hr);
+  }
+  hr = create_hostbyname_request_locked(r, host.c_str(),
+                                        grpc_strhtons(port.c_str()),
+                                        /*is_balancer=*/false, "A");
+  ares_gethostbyname(r->ev_driver->channel, hr->host, AF_INET,
+                     on_hostbyname_done_locked, hr);
+  grpc_ares_ev_driver_start_locked(r->ev_driver);
+  grpc_ares_request_unref_locked(r);
+  return r;
+}
+
+grpc_ares_request* grpc_dns_lookup_srv_ares_impl(
+    const char* dns_server, const char* name,
+    grpc_pollset_set* interested_parties, grpc_closure* on_done,
+    std::unique_ptr<grpc_core::ServerAddressList>* balancer_addresses,
+    int query_timeout_ms) {
+  grpc_ares_request* r = new grpc_ares_request();
+  grpc_core::MutexLock lock(&r->mu);
+  r->ev_driver = nullptr;
+  r->on_done = on_done;
+  r->balancer_addresses_out = balancer_addresses;
+  GRPC_CARES_TRACE_LOG(
+      "request:%p c-ares grpc_dns_lookup_srv_ares_impl name=%s", r, name);
+  grpc_error_handle error = GRPC_ERROR_NONE;
+  // Don't query for SRV records if the target is "localhost"
+  if (target_matches_localhost(name)) {
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
+    return r;
+  }
+  // Look up name using c-ares lib.
+  std::string host;
+  std::string port;
+  error = grpc_dns_lookup_ares_continued(r, dns_server, name, nullptr,
+                                         interested_parties, query_timeout_ms,
+                                         &host, &port, false);
+  if (!GRPC_ERROR_IS_NONE(error)) {
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
+    return r;
+  }
+  r->pending_queries = 1;
+  /* Query the SRV record */
+  std::string service_name = absl::StrCat("_grpclb._tcp.", host);
+  GrpcAresQuery* srv_query = new GrpcAresQuery(r, service_name);
+  ares_query(r->ev_driver->channel, service_name.c_str(), ns_c_in, ns_t_srv,
+             on_srv_query_done_locked, srv_query);
+  grpc_ares_ev_driver_start_locked(r->ev_driver);
+  grpc_ares_request_unref_locked(r);
+  return r;
+}
+
+grpc_ares_request* grpc_dns_lookup_txt_ares_impl(
+    const char* dns_server, const char* name,
+    grpc_pollset_set* interested_parties, grpc_closure* on_done,
+    char** service_config_json, int query_timeout_ms) {
+  grpc_ares_request* r = new grpc_ares_request();
+  grpc_core::MutexLock lock(&r->mu);
+  r->ev_driver = nullptr;
+  r->on_done = on_done;
+  r->service_config_json_out = service_config_json;
+  GRPC_CARES_TRACE_LOG(
+      "request:%p c-ares grpc_dns_lookup_txt_ares_impl name=%s", r, name);
+  grpc_error_handle error = GRPC_ERROR_NONE;
+  // Don't query for TXT records if the target is "localhost"
   if (target_matches_localhost(name)) {
-    r->balancer_addresses_out = nullptr;
-    r->service_config_json_out = nullptr;
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
+    return r;
   }
   // Look up name using c-ares lib.
-  grpc_dns_lookup_ares_continue_after_check_localhost_and_ip_literals_locked(
-      r, dns_server, name, default_port, interested_parties, query_timeout_ms);
+  std::string host;
+  std::string port;
+  error = grpc_dns_lookup_ares_continued(r, dns_server, name, nullptr,
+                                         interested_parties, query_timeout_ms,
+                                         &host, &port, false);
+  if (!GRPC_ERROR_IS_NONE(error)) {
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
+    return r;
+  }
+  r->pending_queries = 1;
+  /* Query the TXT record */
+  std::string config_name = absl::StrCat("_grpc_config.", host);
+  GrpcAresQuery* txt_query = new GrpcAresQuery(r, config_name);
+  ares_search(r->ev_driver->channel, config_name.c_str(), ns_c_in, ns_t_txt,
+              on_txt_done_locked, txt_query);
+  grpc_ares_ev_driver_start_locked(r->ev_driver);
+  grpc_ares_request_unref_locked(r);
   return r;
 }
 
-grpc_ares_request* (*grpc_dns_lookup_ares)(
+grpc_ares_request* (*grpc_dns_lookup_hostname_ares)(
     const char* dns_server, const char* name, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
     std::unique_ptr<grpc_core::ServerAddressList>* addrs,
-    std::unique_ptr<grpc_core::ServerAddressList>* balancer_addrs,
+    int query_timeout_ms) = grpc_dns_lookup_hostname_ares_impl;
+
+grpc_ares_request* (*grpc_dns_lookup_srv_ares)(
+    const char* dns_server, const char* name,
+    grpc_pollset_set* interested_parties, grpc_closure* on_done,
+    std::unique_ptr<grpc_core::ServerAddressList>* balancer_addresses,
+    int query_timeout_ms) = grpc_dns_lookup_srv_ares_impl;
+
+grpc_ares_request* (*grpc_dns_lookup_txt_ares)(
+    const char* dns_server, const char* name,
+    grpc_pollset_set* interested_parties, grpc_closure* on_done,
     char** service_config_json,
-    int query_timeout_ms) = grpc_dns_lookup_ares_impl;
+    int query_timeout_ms) = grpc_dns_lookup_txt_ares_impl;
 
 static void grpc_cancel_ares_request_impl(grpc_ares_request* r) {
   GPR_ASSERT(r != nullptr);

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h

@@ -78,23 +78,36 @@ struct grpc_ares_request {
   grpc_error_handle error ABSL_GUARDED_BY(mu) = GRPC_ERROR_NONE;
 };
 
-/* Asynchronously resolve \a name. It will try to resolve grpclb SRV records in
-  addition to the normal address records. For normal address records, it uses
-  \a default_port if a port isn't designated in \a name, otherwise it uses the
-  port in \a name. grpc_ares_init() must be called at least once before this
-  function. The returned grpc_ares_request object is owned by the caller and it
-  is safe to free after on_done is called back.
+/* Asynchronously resolve \a name (A/AAAA records only).
+  It uses \a default_port if a port isn't designated in \a name, otherwise it
+  uses the port in \a name. grpc_ares_init() must be called at least once before
+  this function. The returned grpc_ares_request object is owned by the caller
+  and it is safe to free after on_done is called back.
 
   Note on synchronization: \a as on_done might be called from another thread
   ~immediately, access to the grpc_ares_request* return value must be
   synchronized by the caller. TODO(apolcyn): we should remove this requirement
   by changing this API to use two phase initialization - one API to create
   the grpc_ares_request* and another to start the async work. */
-extern grpc_ares_request* (*grpc_dns_lookup_ares)(
+extern grpc_ares_request* (*grpc_dns_lookup_hostname_ares)(
     const char* dns_server, const char* name, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
     std::unique_ptr<grpc_core::ServerAddressList>* addresses,
+    int query_timeout_ms);
+
+// Asynchronously resolve a SRV record.
+// See \a grpc_dns_lookup_hostname_ares for usage details and caveats.
+extern grpc_ares_request* (*grpc_dns_lookup_srv_ares)(
+    const char* dns_server, const char* name,
+    grpc_pollset_set* interested_parties, grpc_closure* on_done,
     std::unique_ptr<grpc_core::ServerAddressList>* balancer_addresses,
+    int query_timeout_ms);
+
+// Asynchronously resolve a TXT record.
+// See \a grpc_dns_lookup_hostname_ares for usage details and caveats.
+extern grpc_ares_request* (*grpc_dns_lookup_txt_ares)(
+    const char* dns_server, const char* name,
+    grpc_pollset_set* interested_parties, grpc_closure* on_done,
     char** service_config_json, int query_timeout_ms);
 
 /* Cancel the pending grpc_ares_request \a request */

data/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc

@@ -16,8 +16,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <limits.h>
-
 #include <algorithm>
 #include <memory>
 #include <string>
@@ -31,6 +29,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
+#include "absl/types/optional.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.h>
@@ -70,7 +69,7 @@ TraceFlag grpc_trace_dns_resolver(false, "dns_resolver");
 class NativeClientChannelDNSResolver : public PollingResolver {
  public:
   NativeClientChannelDNSResolver(ResolverArgs args,
-                                 const grpc_channel_args* channel_args);
+                                 const ChannelArgs& channel_args);
   ~NativeClientChannelDNSResolver() override;
 
   OrphanablePtr<Orphanable> StartRequest() override;
@@ -91,12 +90,14 @@ class NativeClientChannelDNSResolver : public PollingResolver {
 };
 
 NativeClientChannelDNSResolver::NativeClientChannelDNSResolver(
-    ResolverArgs args, const grpc_channel_args* channel_args)
+    ResolverArgs args, const ChannelArgs& channel_args)
     : PollingResolver(
           std::move(args), channel_args,
-          Duration::Milliseconds(grpc_channel_args_find_integer(
-              channel_args, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS,
-              {1000 * 30, 0, INT_MAX})),
+          std::max(Duration::Zero(),
+                   channel_args
+                       .GetDurationFromIntMillis(
+                           GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS)
+                       .value_or(Duration::Seconds(30))),
           BackOff::Options()
               .set_initial_backoff(Duration::Milliseconds(
                   GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS * 1000))
@@ -118,9 +119,10 @@ NativeClientChannelDNSResolver::~NativeClientChannelDNSResolver() {
 
 OrphanablePtr<Orphanable> NativeClientChannelDNSResolver::StartRequest() {
   Ref(DEBUG_LOCATION, "dns_request").release();
-  auto dns_request_handle = GetDNSResolver()->ResolveName(
-      name_to_resolve(), kDefaultSecurePort, interested_parties(),
-      absl::bind_front(&NativeClientChannelDNSResolver::OnResolved, this));
+  auto dns_request_handle = GetDNSResolver()->LookupHostname(
+      absl::bind_front(&NativeClientChannelDNSResolver::OnResolved, this),
+      name_to_resolve(), kDefaultSecurePort, kDefaultDNSRequestTimeout,
+      interested_parties(), /*name_server=*/"");
   if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_dns_resolver)) {
     gpr_log(GPR_DEBUG, "[dns_resolver=%p] starting request=%p", this,
             DNSResolver::HandleToString(dns_request_handle).c_str());
@@ -139,7 +141,7 @@ void NativeClientChannelDNSResolver::OnResolved(
   if (addresses_or.ok()) {
     ServerAddressList addresses;
     for (auto& addr : *addresses_or) {
-      addresses.emplace_back(addr, nullptr /* args */);
+      addresses.emplace_back(addr, ChannelArgs());
     }
     result.addresses = std::move(addresses);
   } else {
@@ -147,7 +149,7 @@ void NativeClientChannelDNSResolver::OnResolved(
         absl::StrCat("DNS resolution failed for ", name_to_resolve(), ": ",
                      addresses_or.status().ToString()));
   }
-  result.args = grpc_channel_args_copy(channel_args());
+  result.args = channel_args();
   OnRequestComplete(std::move(result));
   Unref(DEBUG_LOCATION, "dns_request");
 }
@@ -174,9 +176,9 @@ class NativeClientChannelDNSResolverFactory : public ResolverFactory {
 
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     if (!IsValidUri(args.uri)) return nullptr;
-    const grpc_channel_args* channel_args = args.args;
-    return MakeOrphanable<NativeClientChannelDNSResolver>(std::move(args),
-                                                          channel_args);
+    auto channel_args = args.args;
+    return MakeOrphanable<NativeClientChannelDNSResolver>(
+        std::move(args), std::move(channel_args));
   }
 };
 

data/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.cc

@@ -36,7 +36,7 @@
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/resolver/resolver_factory.h"
 #include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/resolver/server_address.h"
@@ -59,8 +59,6 @@ class FakeResolver : public Resolver {
   friend class FakeResolverResponseGenerator;
   friend class FakeResolverResponseSetter;
 
-  ~FakeResolver() override;
-
   void ShutdownLocked() override;
 
   void MaybeSendResultLocked();
@@ -68,7 +66,7 @@ class FakeResolver : public Resolver {
   void ReturnReresolutionResult();
 
   // passed-in parameters
-  grpc_channel_args* channel_args_ = nullptr;
+  ChannelArgs channel_args_;
   std::shared_ptr<WorkSerializer> work_serializer_;
   std::unique_ptr<ResultHandler> result_handler_;
   RefCountedPtr<FakeResolverResponseGenerator> response_generator_;
@@ -94,21 +92,17 @@ FakeResolver::FakeResolver(ResolverArgs args)
     : work_serializer_(std::move(args.work_serializer)),
       result_handler_(std::move(args.result_handler)),
       response_generator_(
-          FakeResolverResponseGenerator::GetFromArgs(args.args)) {
+          args.args.GetObjectRef<FakeResolverResponseGenerator>()) {
   // Channels sharing the same subchannels may have different resolver response
   // generators. If we don't remove this arg, subchannel pool will create new
   // subchannels for the same address instead of reusing existing ones because
   // of different values of this channel arg.
-  const char* args_to_remove[] = {GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR};
-  channel_args_ = grpc_channel_args_copy_and_remove(
-      args.args, args_to_remove, GPR_ARRAY_SIZE(args_to_remove));
+  channel_args_ = args.args.Remove(GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR);
   if (response_generator_ != nullptr) {
     response_generator_->SetFakeResolver(Ref());
   }
 }
 
-FakeResolver::~FakeResolver() { grpc_channel_args_destroy(channel_args_); }
-
 void FakeResolver::StartLocked() {
   started_ = true;
   MaybeSendResultLocked();
@@ -147,17 +141,13 @@ void FakeResolver::MaybeSendResultLocked() {
     Result result;
     result.addresses = absl::UnavailableError("Resolver transient failure");
     result.service_config = result.addresses.status();
-    result.args = grpc_channel_args_copy(channel_args_);
+    result.args = channel_args_;
     result_handler_->ReportResult(std::move(result));
     return_failure_ = false;
   } else if (has_next_result_) {
     // When both next_results_ and channel_args_ contain an arg with the same
-    // name, only the one in next_results_ will be kept since next_results_ is
-    // before channel_args_.
-    grpc_channel_args* new_args =
-        grpc_channel_args_union(next_result_.args, channel_args_);
-    grpc_channel_args_destroy(next_result_.args);
-    next_result_.args = new_args;
+    // name, only the one in next_results_.
+    next_result_.args = next_result_.args.UnionWith(channel_args_);
     result_handler_->ReportResult(std::move(next_result_));
     has_next_result_ = false;
   }

data/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h

@@ -20,9 +20,11 @@
 #include <grpc/support/port_platform.h>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/strings/string_view.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
 
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -82,6 +84,15 @@ class FakeResolverResponseGenerator
   static RefCountedPtr<FakeResolverResponseGenerator> GetFromArgs(
       const grpc_channel_args* args);
 
+  static absl::string_view ChannelArgName() {
+    return GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR;
+  }
+
+  static int ChannelArgsCompare(const FakeResolverResponseGenerator* a,
+                                const FakeResolverResponseGenerator* b) {
+    return QsortCompare(a, b);
+  }
+
  private:
   friend class FakeResolver;
   // Set the corresponding FakeResolver to this generator.