grpc 1.58.0 → 1.60.0

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

@@ -19,7 +19,6 @@
 #include <grpc/support/port_platform.h>
 
 #include <algorithm>
-#include <initializer_list>
 #include <vector>
 
 #include "absl/strings/string_view.h"
@@ -73,8 +72,8 @@
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/timer.h"
 
-using grpc_core::ServerAddress;
-using grpc_core::ServerAddressList;
+using grpc_core::EndpointAddresses;
+using grpc_core::EndpointAddressesList;
 
 grpc_core::TraceFlag grpc_trace_cares_address_sorting(false,
                                                       "cares_address_sorting");
@@ -366,9 +365,7 @@ static void on_readable(void* arg, grpc_error_handle error) {
   GRPC_CARES_TRACE_LOG("request:%p readable on %s", fdn->ev_driver->request,
                        fdn->grpc_polled_fd->GetName());
   if (error.ok() && !ev_driver->shutting_down) {
-    do {
-      ares_process_fd(ev_driver->channel, as, ARES_SOCKET_BAD);
-    } while (fdn->grpc_polled_fd->IsFdStillReadableLocked());
+    ares_process_fd(ev_driver->channel, as, ARES_SOCKET_BAD);
   } else {
     // If error is not absl::OkStatus() or the resolution was cancelled, it
     // means the fd has been shutdown or timed out. The pending lookups made on
@@ -438,12 +435,21 @@ static void grpc_ares_notify_on_event_locked(grpc_ares_ev_driver* ev_driver)
         if (ARES_GETSOCK_READABLE(socks_bitmask, i) &&
             !fdn->readable_registered) {
           grpc_ares_ev_driver_ref(ev_driver);
-          GRPC_CARES_TRACE_LOG("request:%p notify read on: %s",
-                               ev_driver->request,
-                               fdn->grpc_polled_fd->GetName());
           GRPC_CLOSURE_INIT(&fdn->read_closure, on_readable, fdn,
                             grpc_schedule_on_exec_ctx);
-          fdn->grpc_polled_fd->RegisterForOnReadableLocked(&fdn->read_closure);
+          if (fdn->grpc_polled_fd->IsFdStillReadableLocked()) {
+            GRPC_CARES_TRACE_LOG("request:%p schedule direct read on: %s",
+                                 ev_driver->request,
+                                 fdn->grpc_polled_fd->GetName());
+            grpc_core::ExecCtx::Run(DEBUG_LOCATION, &fdn->read_closure,
+                                    absl::OkStatus());
+          } else {
+            GRPC_CARES_TRACE_LOG("request:%p notify read on: %s",
+                                 ev_driver->request,
+                                 fdn->grpc_polled_fd->GetName());
+            fdn->grpc_polled_fd->RegisterForOnReadableLocked(
+                &fdn->read_closure);
+          }
           fdn->readable_registered = true;
         }
         // Register write_closure if the socket is writable and write_closure
@@ -550,7 +556,7 @@ grpc_error_handle grpc_ares_ev_driver_create_locked(
 }
 
 static void log_address_sorting_list(const grpc_ares_request* r,
-                                     const ServerAddressList& addresses,
+                                     const EndpointAddressesList& addresses,
                                      const char* input_output_str) {
   for (size_t i = 0; i < addresses.size(); i++) {
     auto addr_str = grpc_sockaddr_to_string(&addresses[i].address(), true);
@@ -564,7 +570,7 @@ static void log_address_sorting_list(const grpc_ares_request* r,
 }
 
 void grpc_cares_wrapper_address_sorting_sort(const grpc_ares_request* r,
-                                             ServerAddressList* addresses) {
+                                             EndpointAddressesList* addresses) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_cares_address_sorting)) {
     log_address_sorting_list(r, *addresses, "input");
   }
@@ -577,10 +583,11 @@ void grpc_cares_wrapper_address_sorting_sort(const grpc_ares_request* r,
     sortables[i].dest_addr.len = (*addresses)[i].address().len;
   }
   address_sorting_rfc_6724_sort(sortables, addresses->size());
-  ServerAddressList sorted;
+  EndpointAddressesList sorted;
   sorted.reserve(addresses->size());
   for (size_t i = 0; i < addresses->size(); ++i) {
-    sorted.emplace_back(*static_cast<ServerAddress*>(sortables[i].user_data));
+    sorted.emplace_back(
+        *static_cast<EndpointAddresses*>(sortables[i].user_data));
   }
   gpr_free(sortables);
   *addresses = std::move(sorted);
@@ -613,7 +620,8 @@ void grpc_ares_complete_request_locked(grpc_ares_request* r)
     // with no addresses along side it
   }
   if (r->balancer_addresses_out != nullptr) {
-    ServerAddressList* balancer_addresses = r->balancer_addresses_out->get();
+    EndpointAddressesList* balancer_addresses =
+        r->balancer_addresses_out->get();
     if (balancer_addresses != nullptr) {
       grpc_cares_wrapper_address_sorting_sort(r, balancer_addresses);
     }
@@ -660,12 +668,12 @@ static void on_hostbyname_done_locked(void* arg, int status, int /*timeouts*/,
     GRPC_CARES_TRACE_LOG(
         "request:%p on_hostbyname_done_locked qtype=%s host=%s ARES_SUCCESS", r,
         hr->qtype, hr->host);
-    std::unique_ptr<ServerAddressList>* address_list_ptr =
+    std::unique_ptr<EndpointAddressesList>* address_list_ptr =
         hr->is_balancer ? r->balancer_addresses_out : r->addresses_out;
     if (*address_list_ptr == nullptr) {
-      *address_list_ptr = std::make_unique<ServerAddressList>();
+      *address_list_ptr = std::make_unique<EndpointAddressesList>();
     }
-    ServerAddressList& addresses = **address_list_ptr;
+    EndpointAddressesList& addresses = **address_list_ptr;
     for (size_t i = 0; hostent->h_addr_list[i] != nullptr; ++i) {
       grpc_core::ChannelArgs args;
       if (hr->is_balancer) {
@@ -897,7 +905,7 @@ grpc_error_handle grpc_dns_lookup_ares_continued(
 
 static bool inner_resolve_as_ip_literal_locked(
     const char* name, const char* default_port,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs, std::string* host,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addrs, std::string* host,
     std::string* port, std::string* hostport) {
   if (!grpc_core::SplitHostPort(name, host, port)) {
     gpr_log(GPR_ERROR,
@@ -923,7 +931,7 @@ static bool inner_resolve_as_ip_literal_locked(
       grpc_parse_ipv6_hostport(hostport->c_str(), &addr,
                                false /* log errors */)) {
     GPR_ASSERT(*addrs == nullptr);
-    *addrs = std::make_unique<ServerAddressList>();
+    *addrs = std::make_unique<EndpointAddressesList>();
     (*addrs)->emplace_back(addr, grpc_core::ChannelArgs());
     return true;
   }
@@ -932,7 +940,7 @@ static bool inner_resolve_as_ip_literal_locked(
 
 static bool resolve_as_ip_literal_locked(
     const char* name, const char* default_port,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs) {
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addrs) {
   std::string host;
   std::string port;
   std::string hostport;
@@ -959,7 +967,7 @@ static bool target_matches_localhost(const char* name) {
 #ifdef GRPC_ARES_RESOLVE_LOCALHOST_MANUALLY
 static bool inner_maybe_resolve_localhost_manually_locked(
     const grpc_ares_request* r, const char* name, const char* default_port,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs, std::string* host,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addrs, std::string* host,
     std::string* port) {
   grpc_core::SplitHostPort(name, host, port);
   if (host->empty()) {
@@ -981,7 +989,7 @@ static bool inner_maybe_resolve_localhost_manually_locked(
   }
   if (gpr_stricmp(host->c_str(), "localhost") == 0) {
     GPR_ASSERT(*addrs == nullptr);
-    *addrs = std::make_unique<grpc_core::ServerAddressList>();
+    *addrs = std::make_unique<grpc_core::EndpointAddressesList>();
     uint16_t numeric_port = grpc_strhtons(port->c_str());
     grpc_resolved_address address;
     // Append the ipv6 loopback address.
@@ -1012,7 +1020,7 @@ static bool inner_maybe_resolve_localhost_manually_locked(
 
 static bool grpc_ares_maybe_resolve_localhost_manually_locked(
     const grpc_ares_request* r, const char* name, const char* default_port,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs) {
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addrs) {
   std::string host;
   std::string port;
   return inner_maybe_resolve_localhost_manually_locked(r, name, default_port,
@@ -1022,7 +1030,7 @@ static bool grpc_ares_maybe_resolve_localhost_manually_locked(
 static bool grpc_ares_maybe_resolve_localhost_manually_locked(
     const grpc_ares_request* /*r*/, const char* /*name*/,
     const char* /*default_port*/,
-    std::unique_ptr<grpc_core::ServerAddressList>* /*addrs*/) {
+    std::unique_ptr<grpc_core::EndpointAddressesList>* /*addrs*/) {
   return false;
 }
 #endif  // GRPC_ARES_RESOLVE_LOCALHOST_MANUALLY
@@ -1030,7 +1038,7 @@ static bool grpc_ares_maybe_resolve_localhost_manually_locked(
 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::EndpointAddressesList>* addrs,
     int query_timeout_ms) {
   grpc_ares_request* r = new grpc_ares_request();
   grpc_core::MutexLock lock(&r->mu);
@@ -1084,7 +1092,7 @@ static grpc_ares_request* grpc_dns_lookup_hostname_ares_impl(
 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,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* balancer_addresses,
     int query_timeout_ms) {
   grpc_ares_request* r = new grpc_ares_request();
   grpc_core::MutexLock lock(&r->mu);
@@ -1161,13 +1169,13 @@ grpc_ares_request* grpc_dns_lookup_txt_ares_impl(
 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::EndpointAddressesList>* 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,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* balancer_addresses,
     int query_timeout_ms) = grpc_dns_lookup_srv_ares_impl;
 
 grpc_ares_request* (*grpc_dns_lookup_txt_ares)(

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

@@ -36,7 +36,7 @@
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
-#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 
 #define GRPC_DNS_ARES_DEFAULT_QUERY_TIMEOUT_MS 120000
 
@@ -63,10 +63,10 @@ struct grpc_ares_request {
   /// closure to call when the request completes
   grpc_closure* on_done ABSL_GUARDED_BY(mu) = nullptr;
   /// the pointer to receive the resolved addresses
-  std::unique_ptr<grpc_core::ServerAddressList>* addresses_out
+  std::unique_ptr<grpc_core::EndpointAddressesList>* addresses_out
       ABSL_GUARDED_BY(mu);
   /// the pointer to receive the resolved balancer addresses
-  std::unique_ptr<grpc_core::ServerAddressList>* balancer_addresses_out
+  std::unique_ptr<grpc_core::EndpointAddressesList>* balancer_addresses_out
       ABSL_GUARDED_BY(mu);
   /// the pointer to receive the service config in JSON
   char** service_config_json_out ABSL_GUARDED_BY(mu) = nullptr;
@@ -92,7 +92,7 @@ struct grpc_ares_request {
 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,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addresses,
     int query_timeout_ms);
 
 // Asynchronously resolve a SRV record.
@@ -100,7 +100,7 @@ extern grpc_ares_request* (*grpc_dns_lookup_hostname_ares)(
 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,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* balancer_addresses,
     int query_timeout_ms);
 
 // Asynchronously resolve a TXT record.
@@ -128,7 +128,8 @@ bool grpc_ares_query_ipv6();
 
 // Sorts destinations in lb_addrs according to RFC 6724.
 void grpc_cares_wrapper_address_sorting_sort(
-    const grpc_ares_request* request, grpc_core::ServerAddressList* addresses);
+    const grpc_ares_request* request,
+    grpc_core::EndpointAddressesList* addresses);
 
 // Exposed in this header for C-core tests only
 extern void (*grpc_ares_test_only_inject_config)(ares_channel* channel);

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

@@ -28,7 +28,7 @@
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/socket_windows.h"
-#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 
 bool grpc_ares_query_ipv6() { return grpc_ipv6_loopback_available(); }
 

data/src/core/ext/filters/client_channel/resolver/dns/event_engine/event_engine_client_channel_resolver.cc

@@ -52,9 +52,9 @@
 #include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/resolver_factory.h"
-#include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/service_config/service_config_impl.h"
 
@@ -149,8 +149,8 @@ class EventEngineClientChannelDNSResolver : public PollingResolver {
     bool is_srv_inflight_ ABSL_GUARDED_BY(on_resolved_mu_) = false;
     bool is_txt_inflight_ ABSL_GUARDED_BY(on_resolved_mu_) = false;
     // Output fields from requests.
-    ServerAddressList addresses_ ABSL_GUARDED_BY(on_resolved_mu_);
-    ServerAddressList balancer_addresses_ ABSL_GUARDED_BY(on_resolved_mu_);
+    EndpointAddressesList addresses_ ABSL_GUARDED_BY(on_resolved_mu_);
+    EndpointAddressesList balancer_addresses_ ABSL_GUARDED_BY(on_resolved_mu_);
     ValidationErrors errors_ ABSL_GUARDED_BY(on_resolved_mu_);
     absl::StatusOr<std::string> service_config_json_
         ABSL_GUARDED_BY(on_resolved_mu_);

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

@@ -18,7 +18,6 @@
 
 #include <algorithm>
 #include <memory>
-#include <string>
 #include <utility>
 #include <vector>
 
@@ -44,9 +43,9 @@
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/resolver_factory.h"
-#include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 #define GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS 1
@@ -127,7 +126,7 @@ void NativeClientChannelDNSResolver::OnResolved(
   // Convert result from iomgr DNS API into Resolver::Result.
   Result result;
   if (addresses_or.ok()) {
-    ServerAddressList addresses;
+    EndpointAddressesList addresses;
     for (auto& addr : *addresses_or) {
       addresses.emplace_back(addr, ChannelArgs());
     }

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

@@ -22,10 +22,9 @@
 #include "src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h"
 
 #include <memory>
+#include <type_traits>
 #include <utility>
 
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/support/log.h>
@@ -37,8 +36,6 @@
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/resolver/resolver_factory.h"
-#include "src/core/lib/resolver/server_address.h"
-#include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
@@ -55,47 +52,38 @@ class FakeResolver : public Resolver {
 
  private:
   friend class FakeResolverResponseGenerator;
-  friend class FakeResolverResponseSetter;
 
   void ShutdownLocked() override;
 
   void MaybeSendResultLocked();
 
-  void ReturnReresolutionResult();
-
   // passed-in parameters
-  ChannelArgs channel_args_;
   std::shared_ptr<WorkSerializer> work_serializer_;
   std::unique_ptr<ResultHandler> result_handler_;
+  ChannelArgs channel_args_;
   RefCountedPtr<FakeResolverResponseGenerator> response_generator_;
-  // If has_next_result_ is true, next_result_ is the next resolution result
-  // to be returned.
-  bool has_next_result_ = false;
-  Result next_result_;
-  // Result to use for the pretended re-resolution in
-  // RequestReresolutionLocked().
-  bool has_reresolution_result_ = false;
-  Result reresolution_result_;
+  // The next resolution result to be returned, if any.  Present when we
+  // get a result before the resolver is started.
+  absl::optional<Result> next_result_;
   // True after the call to StartLocked().
   bool started_ = false;
   // True after the call to ShutdownLocked().
   bool shutdown_ = false;
-  // if true, return failure
-  bool return_failure_ = false;
-  // pending re-resolution
-  bool reresolution_closure_pending_ = false;
 };
 
 FakeResolver::FakeResolver(ResolverArgs args)
     : work_serializer_(std::move(args.work_serializer)),
       result_handler_(std::move(args.result_handler)),
+      channel_args_(
+          // 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. Can't just use GRPC_ARG_NO_SUBCHANNEL_PREFIX, since
+          // that can't be passed into the channel from test code.
+          args.args.Remove(GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR)),
       response_generator_(
           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.
-  channel_args_ = args.args.Remove(GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR);
   if (response_generator_ != nullptr) {
     response_generator_->SetFakeResolver(Ref());
   }
@@ -107,19 +95,9 @@ void FakeResolver::StartLocked() {
 }
 
 void FakeResolver::RequestReresolutionLocked() {
-  if (has_reresolution_result_ || return_failure_) {
-    next_result_ = reresolution_result_;
-    has_next_result_ = true;
-    // Return the result in a different closure, so that we don't call
-    // back into the LB policy while it's still processing the previous
-    // update.
-    if (!reresolution_closure_pending_) {
-      reresolution_closure_pending_ = true;
-      Ref().release();  // ref held by closure
-      work_serializer_->Run([this]() { ReturnReresolutionResult(); },
-                            DEBUG_LOCATION);
-    }
-  }
+  // Re-resolution can't happen until after we return an initial result.
+  GPR_ASSERT(response_generator_ != nullptr);
+  response_generator_->ReresolutionRequested();
 }
 
 void FakeResolver::ShutdownLocked() {
@@ -132,78 +110,13 @@ void FakeResolver::ShutdownLocked() {
 
 void FakeResolver::MaybeSendResultLocked() {
   if (!started_ || shutdown_) return;
-  if (return_failure_) {
-    // TODO(roth): Change resolver result generator to be able to inject
-    // the error to be returned and to be able to independently set errors
-    // for addresses and service config.
-    Result result;
-    result.addresses = absl::UnavailableError("Resolver transient failure");
-    result.service_config = result.addresses.status();
-    result.args = channel_args_;
-    result_handler_->ReportResult(std::move(result));
-    return_failure_ = false;
-  } else if (has_next_result_) {
+  if (next_result_.has_value()) {
     // When both next_results_ and channel_args_ contain an arg with the same
-    // 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;
-  }
-}
-
-void FakeResolver::ReturnReresolutionResult() {
-  reresolution_closure_pending_ = false;
-  MaybeSendResultLocked();
-  Unref();
-}
-
-class FakeResolverResponseSetter {
- public:
-  explicit FakeResolverResponseSetter(RefCountedPtr<FakeResolver> resolver,
-                                      Resolver::Result result,
-                                      bool has_result = false,
-                                      bool immediate = true)
-      : resolver_(std::move(resolver)),
-        result_(std::move(result)),
-        has_result_(has_result),
-        immediate_(immediate) {}
-  void SetResponseLocked();
-  void SetReresolutionResponseLocked();
-  void SetFailureLocked();
-
- private:
-  RefCountedPtr<FakeResolver> resolver_;
-  Resolver::Result result_;
-  bool has_result_;
-  bool immediate_;
-};
-
-// Deletes object when done
-void FakeResolverResponseSetter::SetReresolutionResponseLocked() {
-  if (!resolver_->shutdown_) {
-    resolver_->reresolution_result_ = std::move(result_);
-    resolver_->has_reresolution_result_ = has_result_;
+    // name, use the one in next_results_.
+    next_result_->args = next_result_->args.UnionWith(channel_args_);
+    result_handler_->ReportResult(std::move(*next_result_));
+    next_result_.reset();
   }
-  delete this;
-}
-
-// Deletes object when done
-void FakeResolverResponseSetter::SetResponseLocked() {
-  if (!resolver_->shutdown_) {
-    resolver_->next_result_ = std::move(result_);
-    resolver_->has_next_result_ = true;
-    resolver_->MaybeSendResultLocked();
-  }
-  delete this;
-}
-
-// Deletes object when done
-void FakeResolverResponseSetter::SetFailureLocked() {
-  if (!resolver_->shutdown_) {
-    resolver_->return_failure_ = true;
-    if (immediate_) resolver_->MaybeSendResultLocked();
-  }
-  delete this;
 }
 
 //
@@ -214,89 +127,79 @@ FakeResolverResponseGenerator::FakeResolverResponseGenerator() {}
 
 FakeResolverResponseGenerator::~FakeResolverResponseGenerator() {}
 
-void FakeResolverResponseGenerator::SetResponse(Resolver::Result result) {
+void FakeResolverResponseGenerator::SetResponseAndNotify(
+    Resolver::Result result, Notification* notify_when_set) {
   RefCountedPtr<FakeResolver> resolver;
   {
     MutexLock lock(&mu_);
     if (resolver_ == nullptr) {
-      has_result_ = true;
       result_ = std::move(result);
+      if (notify_when_set != nullptr) notify_when_set->Notify();
       return;
     }
     resolver = resolver_->Ref();
   }
-  FakeResolverResponseSetter* arg =
-      new FakeResolverResponseSetter(resolver, std::move(result));
-  resolver->work_serializer_->Run([arg]() { arg->SetResponseLocked(); },
-                                  DEBUG_LOCATION);
-}
-
-void FakeResolverResponseGenerator::SetReresolutionResponse(
-    Resolver::Result result) {
-  RefCountedPtr<FakeResolver> resolver;
-  {
-    MutexLock lock(&mu_);
-    GPR_ASSERT(resolver_ != nullptr);
-    resolver = resolver_->Ref();
-  }
-  FakeResolverResponseSetter* arg = new FakeResolverResponseSetter(
-      resolver, std::move(result), true /* has_result */);
-  resolver->work_serializer_->Run(
-      [arg]() { arg->SetReresolutionResponseLocked(); }, DEBUG_LOCATION);
+  SendResultToResolver(std::move(resolver), std::move(result), notify_when_set);
 }
 
-void FakeResolverResponseGenerator::UnsetReresolutionResponse() {
-  RefCountedPtr<FakeResolver> resolver;
+void FakeResolverResponseGenerator::SetFakeResolver(
+    RefCountedPtr<FakeResolver> resolver) {
+  Resolver::Result result;
   {
     MutexLock lock(&mu_);
-    GPR_ASSERT(resolver_ != nullptr);
-    resolver = resolver_->Ref();
+    resolver_ = resolver;
+    if (resolver_set_cv_ != nullptr) resolver_set_cv_->SignalAll();
+    if (resolver == nullptr) return;
+    if (!result_.has_value()) return;
+    result = std::move(*result_);
+    result_.reset();
   }
-  FakeResolverResponseSetter* arg =
-      new FakeResolverResponseSetter(resolver, Resolver::Result());
-  resolver->work_serializer_->Run(
-      [arg]() { arg->SetReresolutionResponseLocked(); }, DEBUG_LOCATION);
-}
-
-void FakeResolverResponseGenerator::SetFailure() {
-  RefCountedPtr<FakeResolver> resolver;
-  {
-    MutexLock lock(&mu_);
-    GPR_ASSERT(resolver_ != nullptr);
-    resolver = resolver_->Ref();
+  SendResultToResolver(std::move(resolver), std::move(result), nullptr);
+}
+
+void FakeResolverResponseGenerator::SendResultToResolver(
+    RefCountedPtr<FakeResolver> resolver, Resolver::Result result,
+    Notification* notify_when_set) {
+  auto* resolver_ptr = resolver.get();
+  resolver_ptr->work_serializer_->Run(
+      [resolver = std::move(resolver), result = std::move(result),
+       notify_when_set]() mutable {
+        if (!resolver->shutdown_) {
+          resolver->next_result_ = std::move(result);
+          resolver->MaybeSendResultLocked();
+        }
+        if (notify_when_set != nullptr) notify_when_set->Notify();
+      },
+      DEBUG_LOCATION);
+}
+
+bool FakeResolverResponseGenerator::WaitForResolverSet(absl::Duration timeout) {
+  MutexLock lock(&mu_);
+  if (resolver_ == nullptr) {
+    CondVar condition;
+    resolver_set_cv_ = &condition;
+    condition.WaitWithTimeout(&mu_, timeout);
+    resolver_set_cv_ = nullptr;
   }
-  FakeResolverResponseSetter* arg =
-      new FakeResolverResponseSetter(resolver, Resolver::Result());
-  resolver->work_serializer_->Run([arg]() { arg->SetFailureLocked(); },
-                                  DEBUG_LOCATION);
+  return resolver_ != nullptr;
 }
 
-void FakeResolverResponseGenerator::SetFailureOnReresolution() {
-  RefCountedPtr<FakeResolver> resolver;
-  {
-    MutexLock lock(&mu_);
-    GPR_ASSERT(resolver_ != nullptr);
-    resolver = resolver_->Ref();
+bool FakeResolverResponseGenerator::WaitForReresolutionRequest(
+    absl::Duration timeout) {
+  MutexLock lock(&reresolution_mu_);
+  if (!reresolution_requested_) {
+    CondVar condition;
+    reresolution_cv_ = &condition;
+    condition.WaitWithTimeout(&reresolution_mu_, timeout);
+    reresolution_cv_ = nullptr;
   }
-  FakeResolverResponseSetter* arg = new FakeResolverResponseSetter(
-      resolver, Resolver::Result(), false /* has_result */,
-      false /* immediate */);
-  resolver->work_serializer_->Run([arg]() { arg->SetFailureLocked(); },
-                                  DEBUG_LOCATION);
+  return std::exchange(reresolution_requested_, false);
 }
 
-void FakeResolverResponseGenerator::SetFakeResolver(
-    RefCountedPtr<FakeResolver> resolver) {
-  MutexLock lock(&mu_);
-  resolver_ = std::move(resolver);
-  if (resolver_ == nullptr) return;
-  if (has_result_) {
-    FakeResolverResponseSetter* arg =
-        new FakeResolverResponseSetter(resolver_, std::move(result_));
-    resolver_->work_serializer_->Run([arg]() { arg->SetResponseLocked(); },
-                                     DEBUG_LOCATION);
-    has_result_ = false;
-  }
+void FakeResolverResponseGenerator::ReresolutionRequested() {
+  MutexLock lock(&reresolution_mu_);
+  reresolution_requested_ = true;
+  if (reresolution_cv_ != nullptr) reresolution_cv_->SignalAll();
 }
 
 namespace {
@@ -323,22 +226,6 @@ const grpc_arg_pointer_vtable
         ResponseGeneratorChannelArgCopy, ResponseGeneratorChannelArgDestroy,
         ResponseGeneratorChannelArgCmp};
 
-grpc_arg FakeResolverResponseGenerator::MakeChannelArg(
-    FakeResolverResponseGenerator* generator) {
-  return grpc_channel_arg_pointer_create(
-      const_cast<char*>(GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR), generator,
-      &kChannelArgPointerVtable);
-}
-
-RefCountedPtr<FakeResolverResponseGenerator>
-FakeResolverResponseGenerator::GetFromArgs(const grpc_channel_args* args) {
-  auto* response_generator =
-      grpc_channel_args_find_pointer<FakeResolverResponseGenerator>(
-          args, GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR);
-  if (response_generator == nullptr) return nullptr;
-  return response_generator->Ref();
-}
-
 //
 // Factory
 //