grpc 1.45.0 → 1.47.0

data/src/core/lib/iomgr/endpoint.h

@@ -38,9 +38,9 @@ typedef struct grpc_endpoint_vtable grpc_endpoint_vtable;
 
 struct grpc_endpoint_vtable {
   void (*read)(grpc_endpoint* ep, grpc_slice_buffer* slices, grpc_closure* cb,
-               bool urgent);
+               bool urgent, int min_progress_size);
   void (*write)(grpc_endpoint* ep, grpc_slice_buffer* slices, grpc_closure* cb,
-                void* arg);
+                void* arg, int max_frame_size);
   void (*add_to_pollset)(grpc_endpoint* ep, grpc_pollset* pollset);
   void (*add_to_pollset_set)(grpc_endpoint* ep, grpc_pollset_set* pollset);
   void (*delete_from_pollset_set)(grpc_endpoint* ep, grpc_pollset_set* pollset);
@@ -58,7 +58,7 @@ struct grpc_endpoint_vtable {
    Valid slices may be placed into \a slices even when the callback is
    invoked with error != GRPC_ERROR_NONE. */
 void grpc_endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                        grpc_closure* cb, bool urgent);
+                        grpc_closure* cb, bool urgent, int min_progress_size);
 
 absl::string_view grpc_endpoint_get_peer(grpc_endpoint* ep);
 
@@ -79,9 +79,11 @@ int grpc_endpoint_get_fd(grpc_endpoint* ep);
    it is a valid slice buffer.
    \a arg is platform specific. It is currently only used by TCP on linux
    platforms as an argument that would be forwarded to the timestamps callback.
+   \a max_frame_size. A hint to the endpoint implementation to construct
+   frames which do not exceed the specified size.
    */
 void grpc_endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                         grpc_closure* cb, void* arg);
+                         grpc_closure* cb, void* arg, int max_frame_size);
 
 /* Causes any pending and future read/write callbacks to run immediately with
    success==0 */

data/src/core/lib/iomgr/endpoint_cfstream.cc

@@ -237,7 +237,8 @@ static void WriteAction(void* arg, grpc_error_handle error) {
 }
 
 static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                         grpc_closure* cb, bool urgent) {
+                         grpc_closure* cb, bool urgent,
+                         int /*min_progress_size*/) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p read (%p, %p) length:%zu", ep_impl,
@@ -254,7 +255,7 @@ static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
 }
 
 static void CFStreamWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                          grpc_closure* cb, void* arg) {
+                          grpc_closure* cb, void* arg, int /*max_frame_size*/) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p write (%p, %p) length:%zu",
@@ -351,11 +352,13 @@ grpc_endpoint* grpc_cfstream_endpoint_create(CFReadStreamRef read_stream,
   if (native_handle) {
     CFRelease(native_handle);
   }
+  absl::StatusOr<std::string> addr_uri;
   if (getsockname(sockfd, reinterpret_cast<sockaddr*>(resolved_local_addr.addr),
-                  &resolved_local_addr.len) < 0) {
+                  &resolved_local_addr.len) < 0 ||
+      !(addr_uri = grpc_sockaddr_to_uri(&resolved_local_addr)).ok()) {
     ep_impl->local_address = "";
   } else {
-    ep_impl->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
+    ep_impl->local_address = addr_uri.value();
   }
   ep_impl->read_cb = nil;
   ep_impl->write_cb = nil;

data/src/core/lib/iomgr/endpoint_pair_posix.cc

@@ -62,7 +62,8 @@ grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char* name,
   std::string final_name = absl::StrCat(name, ":client");
   const grpc_channel_args* new_args = grpc_core::CoreConfiguration::Get()
                                           .channel_args_preconditioning()
-                                          .PreconditionChannelArgs(args);
+                                          .PreconditionChannelArgs(args)
+                                          .ToC();
   p.client = grpc_tcp_create(grpc_fd_create(sv[1], final_name.c_str(), false),
                              new_args, "socketpair-server");
   final_name = absl::StrCat(name, ":server");

data/src/core/lib/iomgr/ev_posix.cc

@@ -32,7 +32,6 @@
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/iomgr/ev_epoll1_linux.h"
-#include "src/core/lib/iomgr/ev_epollex_linux.h"
 #include "src/core/lib/iomgr/ev_poll_posix.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/internal_errqueue.h"
@@ -126,12 +125,12 @@ const grpc_event_engine_vtable* init_non_polling(bool explicit_request) {
 // environment variable if that variable is set (which should be a
 // comma-separated list of one or more event engine names)
 static event_engine_factory g_factories[] = {
-    {ENGINE_HEAD_CUSTOM, nullptr},        {ENGINE_HEAD_CUSTOM, nullptr},
-    {ENGINE_HEAD_CUSTOM, nullptr},        {ENGINE_HEAD_CUSTOM, nullptr},
-    {"epollex", grpc_init_epollex_linux}, {"epoll1", grpc_init_epoll1_linux},
-    {"poll", grpc_init_poll_posix},       {"none", init_non_polling},
-    {ENGINE_TAIL_CUSTOM, nullptr},        {ENGINE_TAIL_CUSTOM, nullptr},
-    {ENGINE_TAIL_CUSTOM, nullptr},        {ENGINE_TAIL_CUSTOM, nullptr},
+    {ENGINE_HEAD_CUSTOM, nullptr},      {ENGINE_HEAD_CUSTOM, nullptr},
+    {ENGINE_HEAD_CUSTOM, nullptr},      {ENGINE_HEAD_CUSTOM, nullptr},
+    {"epoll1", grpc_init_epoll1_linux}, {"poll", grpc_init_poll_posix},
+    {"none", init_non_polling},         {ENGINE_TAIL_CUSTOM, nullptr},
+    {ENGINE_TAIL_CUSTOM, nullptr},      {ENGINE_TAIL_CUSTOM, nullptr},
+    {ENGINE_TAIL_CUSTOM, nullptr},
 };
 
 static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
@@ -238,10 +237,7 @@ void grpc_event_engine_shutdown(void) {
 
 bool grpc_event_engine_can_track_errors(void) {
   /* Only track errors if platform supports errqueue. */
-  if (grpc_core::kernel_supports_errqueue()) {
-    return g_event_engine->can_track_err;
-  }
-  return false;
+  return grpc_core::KernelSupportsErrqueue() && g_event_engine->can_track_err;
 }
 
 bool grpc_event_engine_run_in_background(void) {

data/src/core/lib/iomgr/exec_ctx.h

@@ -204,8 +204,6 @@ class ExecCtx {
   /** Gets pointer to current exec_ctx. */
   static ExecCtx* Get() { return exec_ctx_; }
 
-  static void Set(ExecCtx* exec_ctx) { exec_ctx_ = exec_ctx; }
-
   static void Run(const DebugLocation& location, grpc_closure* closure,
                   grpc_error_handle error);
 
@@ -220,6 +218,7 @@ class ExecCtx {
 
  private:
   /** Set exec_ctx_ to exec_ctx. */
+  static void Set(ExecCtx* exec_ctx) { exec_ctx_ = exec_ctx; }
 
   grpc_closure_list closure_list_ = GRPC_CLOSURE_LIST_INIT;
   CombinerData combiner_data_ = {nullptr, nullptr};

data/src/core/lib/iomgr/fork_posix.cc

@@ -67,7 +67,7 @@ void grpc_prefork() {
   if (poll_strategy_name == nullptr ||
       (strcmp(poll_strategy_name, "epoll1") != 0 &&
        strcmp(poll_strategy_name, "poll") != 0)) {
-    gpr_log(GPR_ERROR,
+    gpr_log(GPR_INFO,
             "Fork support is only compatible with the epoll1 and poll polling "
             "strategies");
     return;

data/src/core/lib/iomgr/internal_errqueue.cc

@@ -1,20 +1,16 @@
-/*
- *
- * Copyright 2018 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+// Copyright 2018 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <grpc/support/port_platform.h>
 
@@ -32,37 +28,32 @@
 #include <sys/utsname.h>
 
 namespace grpc_core {
-static bool errqueue_supported = false;
 
-bool kernel_supports_errqueue() { return errqueue_supported; }
-
-void grpc_errqueue_init() {
-/* Both-compile time and run-time linux kernel versions should be at least 4.0.0
- */
+bool KernelSupportsErrqueue() {
+  static const bool errqueue_supported = []() {
 #ifdef GRPC_LINUX_ERRQUEUE
-  struct utsname buffer;
-  if (uname(&buffer) != 0) {
-    gpr_log(GPR_ERROR, "uname: %s", strerror(errno));
-    return;
-  }
-  char* release = buffer.release;
-  if (release == nullptr) {
-    return;
-  }
-
-  if (strtol(release, nullptr, 10) >= 4) {
-    errqueue_supported = true;
-  } else {
-    gpr_log(GPR_DEBUG, "ERRQUEUE support not enabled");
-  }
-#endif /* GRPC_LINUX_ERRQUEUE */
+    // Both-compile time and run-time linux kernel versions should be at
+    // least 4.0.0
+    struct utsname buffer;
+    if (uname(&buffer) != 0) {
+      gpr_log(GPR_ERROR, "uname: %s", strerror(errno));
+      return false;
+    }
+    char* release = buffer.release;
+    if (release == nullptr) {
+      return false;
+    }
+
+    if (strtol(release, nullptr, 10) >= 4) {
+      return true;
+    } else {
+      gpr_log(GPR_DEBUG, "ERRQUEUE support not enabled");
+    }
+#endif  // GRPC_LINUX_ERRQUEUE
+    return false;
+  }();
+  return errqueue_supported;
 }
-} /* namespace grpc_core */
-
-#else
-
-namespace grpc_core {
-void grpc_errqueue_init() {}
-} /* namespace grpc_core */
+}  // namespace grpc_core
 
-#endif /* GRPC_POSIX_SOCKET_TCP */
+#endif  // GRPC_POSIX_SOCKET_TCP

data/src/core/lib/iomgr/internal_errqueue.h

@@ -177,15 +177,10 @@ struct tcp_info {
 /* Returns true if kernel is capable of supporting errqueue and timestamping.
  * Currently allowing only linux kernels above 4.0.0
  */
-bool kernel_supports_errqueue();
+bool KernelSupportsErrqueue();
 
 } /* namespace grpc_core */
 
 #endif /* GRPC_POSIX_SOCKET_TCP */
 
-namespace grpc_core {
-/* Initializes errqueue support */
-void grpc_errqueue_init();
-} /* namespace grpc_core */
-
 #endif /* GRPC_CORE_LIB_IOMGR_INTERNAL_ERRQUEUE_H */

data/src/core/lib/iomgr/iomgr.cc

@@ -64,7 +64,6 @@ void grpc_iomgr_init() {
   g_root_object.name = const_cast<char*>("root");
   grpc_iomgr_platform_init();
   grpc_timer_list_init();
-  grpc_core::grpc_errqueue_init();
   g_grpc_abort_on_leaks = GPR_GLOBAL_CONFIG_GET(grpc_abort_on_leaks);
 }
 

data/src/core/lib/iomgr/{event_engine/pollset.h → iomgr_fwd.h}

@@ -1,4 +1,4 @@
-// Copyright 2021 The gRPC Authors
+// Copyright 2022 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,15 +11,15 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#ifndef GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_POLLSET_H
-#define GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_POLLSET_H
 
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_CORE_LIB_IOMGR_IOMGR_FWD_H
+#define GRPC_CORE_LIB_IOMGR_IOMGR_FWD_H
+
+// A bunch of forward declarations that are useful to higher level things that
+// don't want to depend on all of iomgr.
 
-#ifdef GRPC_USE_EVENT_ENGINE
+#include <grpc/support/port_platform.h>
 
-/// Signals pollset_work that some work has been done.
-void grpc_pollset_ee_broadcast_event();
+typedef struct grpc_pollset_set grpc_pollset_set;
 
-#endif
-#endif  // GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_POLLSET_H
+#endif  // GRPC_CORE_LIB_IOMGR_IOMGR_FWD_H

data/src/core/lib/iomgr/pollset_set.h

@@ -21,6 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/pollset.h"
 
 /* A grpc_pollset_set is a set of pollsets that are interested in an
@@ -28,8 +29,6 @@
    fd's (etc) that have been registered with the set_set to that pollset.
    Registering fd's automatically adds them to all current pollsets. */
 
-typedef struct grpc_pollset_set grpc_pollset_set;
-
 typedef struct grpc_pollset_set_vtable {
   grpc_pollset_set* (*create)(void);
   void (*destroy)(grpc_pollset_set* pollset_set);

data/src/core/lib/iomgr/port.h

@@ -25,9 +25,7 @@
 #ifdef GPR_WINDOWS
 #define GRPC_ARES_RESOLVE_LOCALHOST_MANUALLY 1
 #endif
-#if defined(GRPC_USE_EVENT_ENGINE)
-// Do Nothing
-#elif defined(GPR_WINDOWS)
+#if defined(GPR_WINDOWS)
 #define GRPC_WINSOCK_SOCKET 1
 #define GRPC_WINDOWS_SOCKETUTILS 1
 #define GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER 1
@@ -107,7 +105,6 @@
 #define GRPC_POSIX_SOCKET_ARES_EV_DRIVER 1
 #define GRPC_POSIX_SOCKET_EV 1
 #define GRPC_POSIX_SOCKET_EV_EPOLL1 1
-#define GRPC_POSIX_SOCKET_EV_EPOLLEX 1
 #define GRPC_POSIX_SOCKET_EV_POLL 1
 #define GRPC_POSIX_SOCKET_IF_NAMETOINDEX 1
 #define GRPC_POSIX_SOCKET_RESOLVE_ADDRESS 1
@@ -156,6 +153,17 @@
 #define GRPC_POSIX_SOCKET 1
 #define GRPC_POSIX_SOCKETUTILS 1
 #define GRPC_POSIX_WAKEUP_FD 1
+#elif defined(GPR_NETBSD)
+#define GRPC_HAVE_ARPA_NAMESER 1
+#define GRPC_HAVE_IFADDRS 1
+#define GRPC_HAVE_IPV6_RECVPKTINFO 1
+#define GRPC_HAVE_SO_NOSIGPIPE 1
+#define GRPC_HAVE_UNIX_SOCKET 1
+#define GRPC_POSIX_FORK 1
+#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1
+#define GRPC_POSIX_SOCKET 1
+#define GRPC_POSIX_SOCKETUTILS 1
+#define GRPC_POSIX_WAKEUP_FD 1
 #elif defined(GPR_NACL)
 #define GRPC_HAVE_ARPA_NAMESER 1
 #define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1
@@ -178,21 +186,30 @@
 // TODO(rudominer) Check this does something we want.
 #define GRPC_POSIX_SOCKETUTILS 1
 #define GRPC_TIMER_USE_GENERIC 1
+#elif defined(GPR_HAIKU)
+#define GRPC_HAVE_ARPA_NAMESER 1
+#define GRPC_HAVE_IFADDRS 1
+#define GRPC_HAVE_IPV6_RECVPKTINFO 1
+#define GRPC_HAVE_UNIX_SOCKET 1
+#define GRPC_POSIX_FORK 1
+#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1
+#define GRPC_POSIX_SOCKET 1
+#define GRPC_POSIX_SOCKETUTILS 1
+#define GRPC_POSIX_WAKEUP_FD 1
 #elif !defined(GPR_NO_AUTODETECT_PLATFORM)
 #error "Platform not recognized"
 #endif
 
-#if defined(GRPC_POSIX_SOCKET) + defined(GRPC_WINSOCK_SOCKET) +    \
-        defined(GRPC_CFSTREAM) + defined(GRPC_USE_EVENT_ENGINE) != \
+#if defined(GRPC_POSIX_SOCKET) + defined(GRPC_WINSOCK_SOCKET) + \
+        defined(GRPC_CFSTREAM) !=                               \
     1
 #error \
-    "Must define exactly one of GRPC_POSIX_SOCKET, GRPC_WINSOCK_SOCKET, GRPC_CFSTREAM, GRPC_USE_EVENT_ENGINE"
+    "Must define exactly one of GRPC_POSIX_SOCKET, GRPC_WINSOCK_SOCKET, GRPC_CFSTREAM"
 #endif
 
 #ifdef GRPC_POSIX_SOCKET
 #define GRPC_POSIX_SOCKET_ARES_EV_DRIVER 1
 #define GRPC_POSIX_SOCKET_EV 1
-#define GRPC_POSIX_SOCKET_EV_EPOLLEX 1
 #define GRPC_POSIX_SOCKET_EV_POLL 1
 #define GRPC_POSIX_SOCKET_EV_EPOLL1 1
 #define GRPC_POSIX_SOCKET_IF_NAMETOINDEX 1

data/src/core/lib/iomgr/resolve_address.cc

@@ -19,6 +19,8 @@
 
 #include "src/core/lib/iomgr/resolve_address.h"
 
+#include "absl/strings/str_cat.h"
+
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/alloc.h>
 
@@ -29,8 +31,14 @@ namespace {
 DNSResolver* g_dns_resolver;
 }
 
+constexpr DNSResolver::TaskHandle DNSResolver::kNullHandle;
+
 void SetDNSResolver(DNSResolver* resolver) { g_dns_resolver = resolver; }
 
 DNSResolver* GetDNSResolver() { return g_dns_resolver; }
 
+std::string DNSResolver::HandleToString(TaskHandle handle) {
+  return absl::StrCat("{", handle.keys[0], ",", handle.keys[1], "}");
+}
+
 }  // namespace grpc_core

data/src/core/lib/iomgr/resolve_address.h

@@ -25,6 +25,8 @@
 
 #include "absl/status/statusor.h"
 
+#include <grpc/event_engine/event_engine.h>
+
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/port.h"
@@ -39,37 +41,42 @@ constexpr int kDefaultSecurePortInt = 443;
 // A singleton class used for async and blocking DNS resolution
 class DNSResolver {
  public:
-  // Tracks a single asynchronous DNS resolution attempt. The DNS
-  // resolution should be arranged to be cancelled as soon as possible
-  // when Orphan is called.
-  class Request : public InternallyRefCounted<Request> {
-   public:
-    // Begins async DNS resolution
-    virtual void Start() = 0;
-  };
+  using TaskHandle = ::grpc_event_engine::experimental::EventEngine::
+      DNSResolver::LookupTaskHandle;
+  static constexpr TaskHandle kNullHandle{0, 0};
 
   virtual ~DNSResolver() {}
 
+  static std::string HandleToString(TaskHandle handle);
+
   // Asynchronously resolve name. Use \a default_port if a port isn't designated
   // in \a name, otherwise use the port in \a name. On completion, \a on_done is
   // invoked with the result.
   //
   // Note for implementations: calls may acquire locks in \a on_done which
-  // were previously held while calling Request::Start(). Therefore,
-  // implementations must not invoke \a on_done inline from the call to
-  // Request::Start(). The DNSCallbackExecCtxScheduler utility may help address
-  // this.
-  virtual OrphanablePtr<Request> ResolveName(
+  // were previously held while starting the request. Therefore,
+  // implementations must not invoke \a on_done inline from the call site that
+  // starts the request. The DNSCallbackExecCtxScheduler utility may help
+  // address this.
+  //
+  // \a interested_parties may be deleted after a request is cancelled.
+  virtual TaskHandle ResolveName(
       absl::string_view name, absl::string_view default_port,
       grpc_pollset_set* interested_parties,
       std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-          on_done) GRPC_MUST_USE_RESULT = 0;
+          on_done) = 0;
 
   // Resolve name in a blocking fashion. Use \a default_port if a port isn't
   // designated in \a name, otherwise use the port in \a name.
   virtual absl::StatusOr<std::vector<grpc_resolved_address>>
   ResolveNameBlocking(absl::string_view name,
                       absl::string_view default_port) = 0;
+
+  // This shares the same semantics with \a EventEngine::Cancel: successfully
+  // cancelled lookups will not have their callbacks executed, and this
+  // method returns true. If a TaskHandle is unknown, this method should return
+  // false.
+  virtual bool Cancel(TaskHandle handle) = 0;
 };
 
 // Override the active DNS resolver which should be used for all DNS

data/src/core/lib/iomgr/resolve_address_impl.h

@@ -26,9 +26,8 @@
 
 namespace grpc_core {
 
-// A fire and forget class used by DNSResolver::Request implementations to
-// schedule DNS  resolution callbacks on the ExecCtx, which is frequently
-// necessary to avoid lock inversion related problems.
+// A fire and forget class to schedule DNS resolution callbacks on the ExecCtx,
+// which is frequently necessary to avoid lock inversion related problems.
 class DNSCallbackExecCtxScheduler {
  public:
   DNSCallbackExecCtxScheduler(

data/src/core/lib/iomgr/resolve_address_posix.cc

@@ -45,7 +45,7 @@
 namespace grpc_core {
 namespace {
 
-class NativeDNSRequest : public DNSResolver::Request {
+class NativeDNSRequest {
  public:
   NativeDNSRequest(
       absl::string_view name, absl::string_view default_port,
@@ -53,18 +53,9 @@ class NativeDNSRequest : public DNSResolver::Request {
           on_done)
       : name_(name), default_port_(default_port), on_done_(std::move(on_done)) {
     GRPC_CLOSURE_INIT(&request_closure_, DoRequestThread, this, nullptr);
-  }
-
-  // Starts the resolution
-  void Start() override {
-    Ref().release();  // ref held by callback
     Executor::Run(&request_closure_, GRPC_ERROR_NONE, ExecutorType::RESOLVER);
   }
 
-  // This is a no-op for the native resolver. Note
-  // that no I/O polling is required for the resolution to finish.
-  void Orphan() override { Unref(); }
-
  private:
   // Callback to be passed to grpc Executor to asynch-ify
   // ResolveNameBlocking
@@ -74,7 +65,7 @@ class NativeDNSRequest : public DNSResolver::Request {
         GetDNSResolver()->ResolveNameBlocking(r->name_, r->default_port_);
     // running inline is safe since we've already been scheduled on the executor
     r->on_done_(std::move(result));
-    r->Unref();
+    delete r;
   }
 
   const std::string name_;
@@ -91,13 +82,14 @@ NativeDNSResolver* NativeDNSResolver::GetOrCreate() {
   return instance;
 }
 
-OrphanablePtr<DNSResolver::Request> NativeDNSResolver::ResolveName(
+DNSResolver::TaskHandle NativeDNSResolver::ResolveName(
     absl::string_view name, absl::string_view default_port,
     grpc_pollset_set* /* interested_parties */,
     std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
         on_done) {
-  return MakeOrphanable<NativeDNSRequest>(name, default_port,
-                                          std::move(on_done));
+  // self-deleting class
+  new NativeDNSRequest(name, default_port, std::move(on_done));
+  return kNullHandle;
 }
 
 absl::StatusOr<std::vector<grpc_resolved_address>>
@@ -181,6 +173,8 @@ done:
   return error_result;
 }
 
+bool NativeDNSResolver::Cancel(TaskHandle /*handle*/) { return false; }
+
 }  // namespace grpc_core
 
 #endif

data/src/core/lib/iomgr/resolve_address_posix.h

@@ -32,14 +32,17 @@ class NativeDNSResolver : public DNSResolver {
   // Gets the singleton instance, creating it first if it doesn't exist
   static NativeDNSResolver* GetOrCreate();
 
-  OrphanablePtr<DNSResolver::Request> ResolveName(
+  TaskHandle ResolveName(
       absl::string_view name, absl::string_view default_port,
-      grpc_pollset_set* interested_parties,
+      grpc_pollset_set* /* interested_parties */,
       std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
           on_done) override;
 
   absl::StatusOr<std::vector<grpc_resolved_address>> ResolveNameBlocking(
       absl::string_view name, absl::string_view default_port) override;
+
+  // NativeDNSResolver does not support cancellation.
+  bool Cancel(TaskHandle handle) override;
 };
 
 }  // namespace grpc_core

data/src/core/lib/iomgr/resolve_address_windows.cc

@@ -48,7 +48,7 @@
 namespace grpc_core {
 namespace {
 
-class NativeDNSRequest : public DNSResolver::Request {
+class NativeDNSRequest {
  public:
   NativeDNSRequest(
       absl::string_view name, absl::string_view default_port,
@@ -56,18 +56,9 @@ class NativeDNSRequest : public DNSResolver::Request {
           on_done)
       : name_(name), default_port_(default_port), on_done_(std::move(on_done)) {
     GRPC_CLOSURE_INIT(&request_closure_, DoRequestThread, this, nullptr);
-  }
-
-  // Starts the resolution
-  void Start() override {
-    Ref().release();  // ref held by callback
     Executor::Run(&request_closure_, GRPC_ERROR_NONE, ExecutorType::RESOLVER);
   }
 
-  // This is a no-op for the native resolver. Note
-  // that no I/O polling is required for the resolution to finish.
-  void Orphan() override { Unref(); }
-
  private:
   // Callback to be passed to grpc Executor to asynch-ify
   // ResolveNameBlocking
@@ -77,7 +68,7 @@ class NativeDNSRequest : public DNSResolver::Request {
         GetDNSResolver()->ResolveNameBlocking(r->name_, r->default_port_);
     // running inline is safe since we've already been scheduled on the executor
     r->on_done_(std::move(result));
-    r->Unref();
+    delete r;
   }
 
   const std::string name_;
@@ -94,13 +85,13 @@ NativeDNSResolver* NativeDNSResolver::GetOrCreate() {
   return instance;
 }
 
-OrphanablePtr<DNSResolver::Request> NativeDNSResolver::ResolveName(
+DNSResolver::TaskHandle NativeDNSResolver::ResolveName(
     absl::string_view name, absl::string_view default_port,
     grpc_pollset_set* /* interested_parties */,
     std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
         on_done) {
-  return MakeOrphanable<NativeDNSRequest>(name, default_port,
-                                          std::move(on_done));
+  new NativeDNSRequest(name, default_port, std::move(on_done));
+  return kNullHandle;
 }
 
 absl::StatusOr<std::vector<grpc_resolved_address>>
@@ -166,6 +157,8 @@ done:
   return error_result;
 }
 
+bool NativeDNSResolver::Cancel(TaskHandle /*handle*/) { return false; }
+
 }  // namespace grpc_core
 
 #endif

data/src/core/lib/iomgr/resolve_address_windows.h

@@ -32,14 +32,17 @@ class NativeDNSResolver : public DNSResolver {
   // Gets the singleton instance, creating it first if it doesn't exist
   static NativeDNSResolver* GetOrCreate();
 
-  OrphanablePtr<DNSResolver::Request> ResolveName(
+  TaskHandle ResolveName(
       absl::string_view name, absl::string_view default_port,
-      grpc_pollset_set* interested_parties,
+      grpc_pollset_set* /* interested_parties */,
       std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
           on_done) override;
 
   absl::StatusOr<std::vector<grpc_resolved_address>> ResolveNameBlocking(
       absl::string_view name, absl::string_view default_port) override;
+
+  // NativeDNSResolver does not support cancellation.
+  bool Cancel(TaskHandle handle) override;
 };
 
 }  // namespace grpc_core