grpc 1.47.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

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

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/grpc.h>
+
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_EV
@@ -74,44 +76,7 @@ grpc_poll_function_type grpc_poll_function = aix_poll;
 grpc_wakeup_fd grpc_global_wakeup_fd;
 
 static const grpc_event_engine_vtable* g_event_engine = nullptr;
-static const char* g_poll_strategy_name = nullptr;
-
-typedef const grpc_event_engine_vtable* (*event_engine_factory_fn)(
-    bool explicit_request);
-
-struct event_engine_factory {
-  const char* name;
-  event_engine_factory_fn factory;
-};
-namespace {
-
-grpc_poll_function_type real_poll_function;
-
-int phony_poll(struct pollfd fds[], nfds_t nfds, int timeout) {
-  if (timeout == 0) {
-    return real_poll_function(fds, nfds, 0);
-  } else {
-    gpr_log(GPR_ERROR, "Attempted a blocking poll when declared non-polling.");
-    GPR_ASSERT(false);
-    return -1;
-  }
-}
-
-const grpc_event_engine_vtable* init_non_polling(bool explicit_request) {
-  if (!explicit_request) {
-    return nullptr;
-  }
-  // return the simplest engine as a phony but also override the poller
-  auto ret = grpc_init_poll_posix(explicit_request);
-  real_poll_function = grpc_poll_function;
-  grpc_poll_function = phony_poll;
-
-  return ret;
-}
-}  // namespace
-
-#define ENGINE_HEAD_CUSTOM "head_custom"
-#define ENGINE_TAIL_CUSTOM "tail_custom"
+static gpr_once g_choose_engine = GPR_ONCE_INIT;
 
 // The global array of event-engine factories. Each entry is a pair with a name
 // and an event-engine generator function (nullptr if there is no generator
@@ -124,13 +89,18 @@ const grpc_event_engine_vtable* init_non_polling(bool explicit_request) {
 // specific poller that is requested by name in the GRPC_POLL_STRATEGY
 // 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},
-    {"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 const grpc_event_engine_vtable* g_vtables[] = {
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    &grpc_ev_epoll1_posix,
+    &grpc_ev_poll_posix,
+    &grpc_ev_none_posix,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
 };
 
 static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
@@ -163,77 +133,69 @@ static bool is(const char* want, const char* have) {
 }
 
 static void try_engine(const char* engine) {
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_factories); i++) {
-    if (g_factories[i].factory != nullptr && is(engine, g_factories[i].name)) {
-      if ((g_event_engine = g_factories[i].factory(
-               0 == strcmp(engine, g_factories[i].name)))) {
-        g_poll_strategy_name = g_factories[i].name;
-        gpr_log(GPR_DEBUG, "Using polling engine: %s", g_factories[i].name);
-        return;
-      }
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_vtables); i++) {
+    if (g_vtables[i] != nullptr && is(engine, g_vtables[i]->name) &&
+        g_vtables[i]->check_engine_available(
+            0 == strcmp(engine, g_vtables[i]->name))) {
+      g_event_engine = g_vtables[i];
+      gpr_log(GPR_DEBUG, "Using polling engine: %s", g_event_engine->name);
+      return;
     }
   }
 }
 
 /* Call this before calling grpc_event_engine_init() */
-void grpc_register_event_engine_factory(const char* name,
-                                        event_engine_factory_fn factory,
+void grpc_register_event_engine_factory(const grpc_event_engine_vtable* vtable,
                                         bool add_at_head) {
-  const char* custom_match =
-      add_at_head ? ENGINE_HEAD_CUSTOM : ENGINE_TAIL_CUSTOM;
+  const grpc_event_engine_vtable** first_null = nullptr;
+  const grpc_event_engine_vtable** last_null = nullptr;
 
   // Overwrite an existing registration if already registered
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_factories); i++) {
-    if (0 == strcmp(name, g_factories[i].name)) {
-      g_factories[i].factory = factory;
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_vtables); i++) {
+    if (g_vtables[i] == nullptr) {
+      if (first_null == nullptr) first_null = &g_vtables[i];
+      last_null = &g_vtables[i];
+    } else if (0 == strcmp(g_vtables[i]->name, vtable->name)) {
+      g_vtables[i] = vtable;
       return;
     }
   }
 
-  // Otherwise fill in an available custom slot
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_factories); i++) {
-    if (0 == strcmp(g_factories[i].name, custom_match)) {
-      g_factories[i].name = name;
-      g_factories[i].factory = factory;
-      return;
-    }
-  }
-
-  // Otherwise fail
-  GPR_ASSERT(false);
+  *(add_at_head ? first_null : last_null) = vtable;
 }
 
 /*If grpc_event_engine_init() has been called, returns the poll_strategy_name.
  * Otherwise, returns nullptr. */
-const char* grpc_get_poll_strategy_name() { return g_poll_strategy_name; }
+const char* grpc_get_poll_strategy_name() { return g_event_engine->name; }
 
 void grpc_event_engine_init(void) {
-  grpc_core::UniquePtr<char> value = GPR_GLOBAL_CONFIG_GET(grpc_poll_strategy);
+  gpr_once_init(&g_choose_engine, []() {
+    grpc_core::UniquePtr<char> value =
+        GPR_GLOBAL_CONFIG_GET(grpc_poll_strategy);
 
-  char** strings = nullptr;
-  size_t nstrings = 0;
-  split(value.get(), &strings, &nstrings);
+    char** strings = nullptr;
+    size_t nstrings = 0;
+    split(value.get(), &strings, &nstrings);
 
-  for (size_t i = 0; g_event_engine == nullptr && i < nstrings; i++) {
-    try_engine(strings[i]);
-  }
+    for (size_t i = 0; g_event_engine == nullptr && i < nstrings; i++) {
+      try_engine(strings[i]);
+    }
 
-  for (size_t i = 0; i < nstrings; i++) {
-    gpr_free(strings[i]);
-  }
-  gpr_free(strings);
+    for (size_t i = 0; i < nstrings; i++) {
+      gpr_free(strings[i]);
+    }
+    gpr_free(strings);
 
-  if (g_event_engine == nullptr) {
-    gpr_log(GPR_ERROR, "No event engine could be initialized from %s",
-            value.get());
-    abort();
-  }
+    if (g_event_engine == nullptr) {
+      gpr_log(GPR_ERROR, "No event engine could be initialized from %s",
+              value.get());
+      abort();
+    }
+  });
+  g_event_engine->init_engine();
 }
 
-void grpc_event_engine_shutdown(void) {
-  g_event_engine->shutdown_engine();
-  g_event_engine = nullptr;
-}
+void grpc_event_engine_shutdown(void) { g_event_engine->shutdown_engine(); }
 
 bool grpc_event_engine_can_track_errors(void) {
   /* Only track errors if platform supports errqueue. */

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

@@ -85,6 +85,9 @@ typedef struct grpc_event_engine_vtable {
   void (*pollset_set_del_fd)(grpc_pollset_set* pollset_set, grpc_fd* fd);
 
   bool (*is_any_background_poller_thread)(void);
+  const char* name;
+  bool (*check_engine_available)(bool explicit_request);
+  void (*init_engine)();
   void (*shutdown_background_closure)(void);
   void (*shutdown_engine)(void);
   bool (*add_closure_to_background_poller)(grpc_closure* closure,
@@ -92,9 +95,8 @@ typedef struct grpc_event_engine_vtable {
 } grpc_event_engine_vtable;
 
 /* register a new event engine factory */
-void grpc_register_event_engine_factory(
-    const char* name, const grpc_event_engine_vtable* (*factory)(bool),
-    bool add_at_head);
+void grpc_register_event_engine_factory(const grpc_event_engine_vtable* vtable,
+                                        bool add_at_head);
 
 void grpc_event_engine_init(void);
 void grpc_event_engine_shutdown(void);

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

@@ -37,18 +37,10 @@ static void exec_ctx_run(grpc_closure* closure) {
             closure->line_initiated);
   }
 #endif
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
   grpc_error_handle error =
       grpc_core::internal::StatusMoveFromHeapPtr(closure->error_data.error);
   closure->error_data.error = 0;
   closure->cb(closure->cb_arg, std::move(error));
-#else
-  grpc_error_handle error =
-      reinterpret_cast<grpc_error_handle>(closure->error_data.error);
-  closure->error_data.error = 0;
-  closure->cb(closure->cb_arg, error);
-  GRPC_ERROR_UNREF(error);
-#endif
 #ifndef NDEBUG
   if (grpc_trace_closure.enabled()) {
     gpr_log(GPR_DEBUG, "closure %p finished", closure);
@@ -118,11 +110,7 @@ void ExecCtx::Run(const DebugLocation& location, grpc_closure* closure,
   closure->run = false;
   GPR_ASSERT(closure->cb != nullptr);
 #endif
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
   closure->error_data.error = internal::StatusAllocHeapPtr(error);
-#else
-  closure->error_data.error = reinterpret_cast<intptr_t>(error);
-#endif
   exec_ctx_sched(closure);
 }
 

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

@@ -121,18 +121,10 @@ size_t Executor::RunClosures(const char* executor_name,
 #else
     EXECUTOR_TRACE("(%s) run %p", executor_name, c);
 #endif
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
     grpc_error_handle error =
         internal::StatusMoveFromHeapPtr(c->error_data.error);
     c->error_data.error = 0;
     c->cb(c->cb_arg, std::move(error));
-#else
-    grpc_error_handle error =
-        reinterpret_cast<grpc_error_handle>(c->error_data.error);
-    c->error_data.error = 0;
-    c->cb(c->cb_arg, error);
-    GRPC_ERROR_UNREF(error);
-#endif
     c = next;
     n++;
     ExecCtx::Get()->Flush();
@@ -456,6 +448,4 @@ void Executor::SetThreadingDefault(bool enable) {
   executors[static_cast<size_t>(ExecutorType::DEFAULT)]->SetThreading(enable);
 }
 
-void grpc_executor_global_init() {}
-
 }  // namespace grpc_core

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

@@ -114,9 +114,6 @@ class Executor {
   gpr_spinlock adding_thread_lock_;
 };
 
-// Global initializer for executor
-void grpc_executor_global_init();
-
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_IOMGR_EXECUTOR_H */

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

@@ -73,7 +73,7 @@ void grpc_prefork() {
     return;
   }
   if (!grpc_core::Fork::BlockExecCtx()) {
-    gpr_log(GPR_ERROR,
+    gpr_log(GPR_INFO,
             "Other threads are currently calling into gRPC, skipping fork() "
             "handlers");
     return;

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

@@ -45,6 +45,13 @@ GPR_GLOBAL_CONFIG_DEFINE_BOOL(grpc_abort_on_leaks, false,
                               "A debugging aid to cause a call to abort() when "
                               "gRPC objects are leaked past grpc_shutdown()");
 
+GPR_GLOBAL_CONFIG_DEFINE_BOOL(
+    grpc_experimental_enable_tcp_frame_size_tuning, false,
+    "If set, enables TCP to use RPC size estimation made by higher layers. TCP "
+    "would not indicate completion of a read operation until a specified "
+    "number of bytes have been read over the socket. Buffers are also "
+    "allocated according to estimated RPC sizes.");
+
 static gpr_mu g_mu;
 static gpr_cv g_rcv;
 static int g_shutdown;

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

@@ -80,6 +80,7 @@ void grpc_set_default_iomgr_platform() {
   grpc_set_pollset_vtable(&grpc_posix_pollset_vtable);
   grpc_set_pollset_set_vtable(&grpc_posix_pollset_set_vtable);
   grpc_core::SetDNSResolver(grpc_core::NativeDNSResolver::GetOrCreate());
+  grpc_tcp_client_global_init();
   grpc_set_iomgr_platform_vtable(&vtable);
 }
 

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

@@ -177,6 +177,7 @@ void grpc_set_default_iomgr_platform() {
     grpc_set_pollset_set_vtable(&grpc_apple_pollset_set_vtable);
     grpc_set_iomgr_platform_vtable(&apple_vtable);
   }
+  grpc_tcp_client_global_init();
   grpc_set_timer_impl(&grpc_generic_timer_vtable);
   grpc_core::SetDNSResolver(grpc_core::NativeDNSResolver::GetOrCreate());
 }

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

@@ -66,7 +66,7 @@ grpc_error_handle grpc_load_file(const char* filename, int add_null_terminator,
 end:
   *output = result;
   if (file != nullptr) fclose(file);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_error_handle error_out =
         grpc_error_set_str(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                                "Failed to load file", &error, 1),

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

@@ -77,11 +77,7 @@ void LockfreeEvent::DestroyEvent() {
   do {
     curr = gpr_atm_no_barrier_load(&state_);
     if (curr & kShutdownBit) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
       internal::StatusFreeHeapPtr(curr & ~kShutdownBit);
-#else
-      GRPC_ERROR_UNREF((grpc_error_handle)(curr & ~kShutdownBit));
-#endif
     } else {
       GPR_ASSERT(curr == kClosureNotReady || curr == kClosureReady);
     }
@@ -143,13 +139,8 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
            contains a pointer to the shutdown-error). If the fd is shutdown,
            schedule the closure with the shutdown error */
         if ((curr & kShutdownBit) > 0) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
           grpc_error_handle shutdown_err =
               internal::StatusGetFromHeapPtr(curr & ~kShutdownBit);
-#else
-          grpc_error_handle shutdown_err =
-              reinterpret_cast<grpc_error_handle>(curr & ~kShutdownBit);
-#endif
           ExecCtx::Run(DEBUG_LOCATION, closure,
                        GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                            "FD Shutdown", &shutdown_err, 1));
@@ -169,12 +160,8 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
 }
 
 bool LockfreeEvent::SetShutdown(grpc_error_handle shutdown_error) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
   intptr_t status_ptr = internal::StatusAllocHeapPtr(shutdown_error);
   gpr_atm new_state = status_ptr | kShutdownBit;
-#else
-  gpr_atm new_state = reinterpret_cast<gpr_atm>(shutdown_error) | kShutdownBit;
-#endif
 
   while (true) {
     gpr_atm curr = gpr_atm_no_barrier_load(&state_);
@@ -198,11 +185,7 @@ bool LockfreeEvent::SetShutdown(grpc_error_handle shutdown_error) {
 
         /* If fd is already shutdown, we are done */
         if ((curr & kShutdownBit) > 0) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
           internal::StatusFreeHeapPtr(status_ptr);
-#else
-          GRPC_ERROR_UNREF(shutdown_error);
-#endif
           return false;
         }
 

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

@@ -20,6 +20,9 @@
 
 #include <grpc/support/port_platform.h>
 
+// IWYU pragma: no_include <features.h>
+// IWYU pragma: no_include <linux/version.h>
+
 /* This needs to be separate from the other conditions because it needs to
  * apply to custom sockets too */
 #ifdef GPR_WINDOWS

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

@@ -37,6 +37,7 @@
 namespace grpc_core {
 extern const char* kDefaultSecurePort;
 constexpr int kDefaultSecurePortInt = 443;
+constexpr Duration kDefaultDNSRequestTimeout = Duration::Minutes(2);
 
 // A singleton class used for async and blocking DNS resolution
 class DNSResolver {
@@ -60,17 +61,39 @@ class DNSResolver {
   // 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,
+  virtual TaskHandle LookupHostname(
       std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-          on_done) = 0;
+          on_resolved,
+      absl::string_view name, absl::string_view default_port, Duration timeout,
+      grpc_pollset_set* interested_parties, absl::string_view name_server) = 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;
+  LookupHostnameBlocking(absl::string_view name,
+                         absl::string_view default_port) = 0;
+
+  // Asynchronously resolve an SRV Record to Hostnames.
+  // On completion, \a on_done is invoked with the result.
+  //
+  // The same caveats in \a LookupHostname apply here as well.
+  //
+  // TODO(hork): return std::vector<SRVRecord> and ask the client to do the
+  // subsequent hostname lookups.
+  virtual TaskHandle LookupSRV(
+      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+          on_resolved,
+      absl::string_view name, Duration timeout,
+      grpc_pollset_set* interested_parties, absl::string_view name_server) = 0;
+
+  // Asynchronously resolve a TXT Record. On completion, \a on_done is invoked
+  // with the resulting string.
+  //
+  // The same caveats in \a LookupHostname apply here.
+  virtual TaskHandle LookupTXT(
+      std::function<void(absl::StatusOr<std::string>)> on_resolved,
+      absl::string_view name, Duration timeout,
+      grpc_pollset_set* interested_parties, absl::string_view name_server) = 0;
 
   // This shares the same semantics with \a EventEngine::Cancel: successfully
   // cancelled lookups will not have their callbacks executed, and this

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

@@ -29,6 +29,7 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 
+#include "src/core/lib/event_engine/default_event_engine.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/host_port.h"
@@ -45,6 +46,8 @@
 namespace grpc_core {
 namespace {
 
+using ::grpc_event_engine::experimental::GetDefaultEventEngine;
+
 class NativeDNSRequest {
  public:
   NativeDNSRequest(
@@ -58,11 +61,11 @@ class NativeDNSRequest {
 
  private:
   // Callback to be passed to grpc Executor to asynch-ify
-  // ResolveNameBlocking
+  // LookupHostnameBlocking
   static void DoRequestThread(void* rp, grpc_error_handle /*error*/) {
     NativeDNSRequest* r = static_cast<NativeDNSRequest*>(rp);
     auto result =
-        GetDNSResolver()->ResolveNameBlocking(r->name_, r->default_port_);
+        GetDNSResolver()->LookupHostnameBlocking(r->name_, r->default_port_);
     // running inline is safe since we've already been scheduled on the executor
     r->on_done_(std::move(result));
     delete r;
@@ -82,19 +85,20 @@ NativeDNSResolver* NativeDNSResolver::GetOrCreate() {
   return instance;
 }
 
-DNSResolver::TaskHandle NativeDNSResolver::ResolveName(
-    absl::string_view name, absl::string_view default_port,
-    grpc_pollset_set* /* interested_parties */,
+DNSResolver::TaskHandle NativeDNSResolver::LookupHostname(
     std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-        on_done) {
+        on_done,
+    absl::string_view name, absl::string_view default_port,
+    Duration /* timeout */, grpc_pollset_set* /* interested_parties */,
+    absl::string_view /* name_server */) {
   // self-deleting class
   new NativeDNSRequest(name, default_port, std::move(on_done));
   return kNullHandle;
 }
 
 absl::StatusOr<std::vector<grpc_resolved_address>>
-NativeDNSResolver::ResolveNameBlocking(absl::string_view name,
-                                       absl::string_view default_port) {
+NativeDNSResolver::LookupHostnameBlocking(absl::string_view name,
+                                          absl::string_view default_port) {
   ExecCtx exec_ctx;
   struct addrinfo hints;
   struct addrinfo *result = nullptr, *resp;
@@ -165,7 +169,7 @@ done:
   if (result) {
     freeaddrinfo(result);
   }
-  if (err == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(err)) {
     return addresses;
   }
   auto error_result = grpc_error_to_absl_status(err);
@@ -173,6 +177,32 @@ done:
   return error_result;
 }
 
+DNSResolver::TaskHandle NativeDNSResolver::LookupSRV(
+    std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+        on_resolved,
+    absl::string_view /* name */, Duration /* timeout */,
+    grpc_pollset_set* /* interested_parties */,
+    absl::string_view /* name_server */) {
+  GetDefaultEventEngine()->Run([on_resolved] {
+    on_resolved(absl::UnimplementedError(
+        "The Native resolver does not support looking up SRV records"));
+  });
+  return {-1, -1};
+};
+
+DNSResolver::TaskHandle NativeDNSResolver::LookupTXT(
+    std::function<void(absl::StatusOr<std::string>)> on_resolved,
+    absl::string_view /* name */, Duration /* timeout */,
+    grpc_pollset_set* /* interested_parties */,
+    absl::string_view /* name_server */) {
+  // Not supported
+  GetDefaultEventEngine()->Run([on_resolved] {
+    on_resolved(absl::UnimplementedError(
+        "The Native resolver does not support looking up TXT records"));
+  });
+  return {-1, -1};
+};
+
 bool NativeDNSResolver::Cancel(TaskHandle /*handle*/) { return false; }
 
 }  // namespace grpc_core

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

@@ -32,15 +32,29 @@ class NativeDNSResolver : public DNSResolver {
   // Gets the singleton instance, creating it first if it doesn't exist
   static NativeDNSResolver* GetOrCreate();
 
-  TaskHandle ResolveName(
-      absl::string_view name, absl::string_view default_port,
-      grpc_pollset_set* /* interested_parties */,
+  TaskHandle LookupHostname(
       std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-          on_done) override;
+          on_done,
+      absl::string_view name, absl::string_view default_port, Duration timeout,
+      grpc_pollset_set* interested_parties,
+      absl::string_view name_server) override;
 
-  absl::StatusOr<std::vector<grpc_resolved_address>> ResolveNameBlocking(
+  absl::StatusOr<std::vector<grpc_resolved_address>> LookupHostnameBlocking(
       absl::string_view name, absl::string_view default_port) override;
 
+  TaskHandle LookupSRV(
+      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+          on_resolved,
+      absl::string_view name, Duration timeout,
+      grpc_pollset_set* interested_parties,
+      absl::string_view name_server) override;
+
+  TaskHandle LookupTXT(
+      std::function<void(absl::StatusOr<std::string>)> on_resolved,
+      absl::string_view name, Duration timeout,
+      grpc_pollset_set* interested_parties,
+      absl::string_view name_server) override;
+
   // NativeDNSResolver does not support cancellation.
   bool Cancel(TaskHandle handle) override;
 };