grpc 1.42.0 → 1.45.0

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

@@ -1,20 +1,18 @@
-/*
- *
- * Copyright 2015 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 2015 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>
 
@@ -43,29 +41,83 @@
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolve_address_windows.h"
 #include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/transport/error_utils.h"
+
+namespace grpc_core {
+namespace {
+
+class NativeDNSRequest : public DNSResolver::Request {
+ public:
+  NativeDNSRequest(
+      absl::string_view name, absl::string_view default_port,
+      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+          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
+  static void DoRequestThread(void* rp, grpc_error_handle /*error*/) {
+    NativeDNSRequest* r = static_cast<NativeDNSRequest*>(rp);
+    auto result =
+        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();
+  }
 
-struct request {
-  char* name;
-  char* default_port;
-  grpc_closure request_closure;
-  grpc_closure* on_done;
-  grpc_resolved_addresses** addresses;
+  const std::string name_;
+  const std::string default_port_;
+  const std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+      on_done_;
+  grpc_closure request_closure_;
 };
-static grpc_error_handle windows_blocking_resolve_address(
-    const char* name, const char* default_port,
-    grpc_resolved_addresses** addresses) {
-  grpc_core::ExecCtx exec_ctx;
+
+}  // namespace
+
+NativeDNSResolver* NativeDNSResolver::GetOrCreate() {
+  static NativeDNSResolver* instance = new NativeDNSResolver();
+  return instance;
+}
+
+OrphanablePtr<DNSResolver::Request> 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));
+}
+
+absl::StatusOr<std::vector<grpc_resolved_address>>
+NativeDNSResolver::ResolveNameBlocking(absl::string_view name,
+                                       absl::string_view default_port) {
+  ExecCtx exec_ctx;
   struct addrinfo hints;
   struct addrinfo *result = NULL, *resp;
   int s;
   size_t i;
   grpc_error_handle error = GRPC_ERROR_NONE;
+  std::vector<grpc_resolved_address> addresses;
 
-  /* parse name, splitting it into host and port parts */
+  // parse name, splitting it into host and port parts
   std::string host;
   std::string port;
-  grpc_core::SplitHostPort(name, &host, &port);
+  SplitHostPort(name, &host, &port);
   if (host.empty()) {
     error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
         absl::StrFormat("unparseable host:port: '%s'", name));
@@ -77,10 +129,10 @@ static grpc_error_handle windows_blocking_resolve_address(
           absl::StrFormat("no port in name '%s'", name));
       goto done;
     }
-    port = default_port;
+    port = std::string(default_port);
   }
 
-  /* Call getaddrinfo */
+  // Call getaddrinfo
   memset(&hints, 0, sizeof(hints));
   hints.ai_family = AF_UNSPEC;     /* ipv4 or ipv6 */
   hints.ai_socktype = SOCK_STREAM; /* stream socket */
@@ -94,59 +146,26 @@ static grpc_error_handle windows_blocking_resolve_address(
     goto done;
   }
 
-  /* Success path: set addrs non-NULL, fill it in */
-  (*addresses) =
-      (grpc_resolved_addresses*)gpr_malloc(sizeof(grpc_resolved_addresses));
-  (*addresses)->naddrs = 0;
-  for (resp = result; resp != NULL; resp = resp->ai_next) {
-    (*addresses)->naddrs++;
-  }
-  (*addresses)->addrs = (grpc_resolved_address*)gpr_malloc(
-      sizeof(grpc_resolved_address) * (*addresses)->naddrs);
-  i = 0;
+  // Success path: set addrs non-NULL, fill it in
   for (resp = result; resp != NULL; resp = resp->ai_next) {
-    memcpy(&(*addresses)->addrs[i].addr, resp->ai_addr, resp->ai_addrlen);
-    (*addresses)->addrs[i].len = resp->ai_addrlen;
-    i++;
+    grpc_resolved_address addr;
+    memcpy(&addr.addr, resp->ai_addr, resp->ai_addrlen);
+    addr.len = resp->ai_addrlen;
+    addresses.push_back(addr);
   }
 
 done:
   if (result) {
     freeaddrinfo(result);
   }
-  return error;
-}
-
-/* Callback to be passed to grpc_executor to asynch-ify
- * grpc_blocking_resolve_address */
-static void do_request_thread(void* rp, grpc_error_handle error) {
-  request* r = (request*)rp;
   if (error == GRPC_ERROR_NONE) {
-    error =
-        grpc_blocking_resolve_address(r->name, r->default_port, r->addresses);
-  } else {
-    GRPC_ERROR_REF(error);
+    return addresses;
   }
-  grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
-  gpr_free(r->name);
-  gpr_free(r->default_port);
-  gpr_free(r);
+  auto error_result = grpc_error_to_absl_status(error);
+  GRPC_ERROR_UNREF(error);
+  return error_result;
 }
 
-static void windows_resolve_address(const char* name, const char* default_port,
-                                    grpc_pollset_set* interested_parties,
-                                    grpc_closure* on_done,
-                                    grpc_resolved_addresses** addresses) {
-  request* r = (request*)gpr_malloc(sizeof(request));
-  GRPC_CLOSURE_INIT(&r->request_closure, do_request_thread, r, nullptr);
-  r->name = gpr_strdup(name);
-  r->default_port = gpr_strdup(default_port);
-  r->on_done = on_done;
-  r->addresses = addresses;
-  grpc_core::Executor::Run(&r->request_closure, GRPC_ERROR_NONE,
-                           grpc_core::ExecutorType::RESOLVER);
-}
+}  // namespace grpc_core
 
-grpc_address_resolver_vtable grpc_windows_resolver_vtable = {
-    windows_resolve_address, windows_blocking_resolve_address};
 #endif

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

@@ -0,0 +1,47 @@
+//
+// Copyright 2015 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.
+//
+
+#ifndef GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_WINDOWS_H
+#define GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_WINDOWS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <functional>
+
+#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+
+namespace grpc_core {
+
+// A DNS resolver which uses the native platform's getaddrinfo API.
+class NativeDNSResolver : public DNSResolver {
+ public:
+  // Gets the singleton instance, creating it first if it doesn't exist
+  static NativeDNSResolver* GetOrCreate();
+
+  OrphanablePtr<DNSResolver::Request> 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) override;
+
+  absl::StatusOr<std::vector<grpc_resolved_address>> ResolveNameBlocking(
+      absl::string_view name, absl::string_view default_port) override;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_WINDOWS_H

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

@@ -0,0 +1,39 @@
+// Copyright 2021 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.
+
+#ifndef GRPC_CORE_LIB_IOMGR_RESOLVED_ADDRESS_H
+#define GRPC_CORE_LIB_IOMGR_RESOLVED_ADDRESS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_WINSOCK_SOCKET
+#include <ws2tcpip.h>
+#endif
+
+#if defined(GRPC_POSIX_SOCKET) || defined(GRPC_CFSTREAM)
+#include <sys/socket.h>
+#endif
+
+#define GRPC_MAX_SOCKADDR_SIZE 128
+
+struct grpc_resolved_address {
+  char addr[GRPC_MAX_SOCKADDR_SIZE];
+  socklen_t len;
+};
+
+#endif /* GRPC_CORE_LIB_IOMGR_RESOLVED_ADDRESS_H */

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

@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright 2015 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>
+
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
+
+#include "src/core/lib/iomgr/socket_utils.h"
+#ifdef GRPC_LINUX_TCP_H
+#include <linux/tcp.h>
+#else
+#include <netinet/tcp.h>
+#endif
+#include <stdio.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <string>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+
+#include "src/core/lib/iomgr/sockaddr.h"
+
+uint16_t grpc_htons(uint16_t hostshort) { return htons(hostshort); }
+
+uint16_t grpc_ntohs(uint16_t netshort) { return ntohs(netshort); }
+
+uint32_t grpc_htonl(uint32_t hostlong) { return htonl(hostlong); }
+
+uint32_t grpc_ntohl(uint32_t netlong) { return ntohl(netlong); }
+
+int grpc_inet_pton(int af, const char* src, void* dst) {
+  return inet_pton(af, src, dst);
+}
+
+const char* grpc_inet_ntop(int af, const void* src, char* dst, size_t size) {
+  GPR_ASSERT(size <= (socklen_t)-1);
+  return inet_ntop(af, src, dst, static_cast<socklen_t>(size));
+}
+
+#endif

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

@@ -495,21 +495,4 @@ grpc_error_handle grpc_create_dualstack_socket_using_factory(
   return error_for_fd(*newfd, resolved_addr);
 }
 
-uint16_t grpc_htons(uint16_t hostshort) { return htons(hostshort); }
-
-uint16_t grpc_ntohs(uint16_t netshort) { return ntohs(netshort); }
-
-uint32_t grpc_htonl(uint32_t hostlong) { return htonl(hostlong); }
-
-uint32_t grpc_ntohl(uint32_t netlong) { return ntohl(netlong); }
-
-int grpc_inet_pton(int af, const char* src, void* dst) {
-  return inet_pton(af, src, dst);
-}
-
-const char* grpc_inet_ntop(int af, const void* src, char* dst, size_t size) {
-  GPR_ASSERT(size <= (socklen_t)-1);
-  return inet_ntop(af, src, dst, static_cast<socklen_t>(size));
-}
-
 #endif

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

@@ -23,14 +23,12 @@
 grpc_tcp_client_vtable* grpc_tcp_client_impl;
 
 void grpc_tcp_client_connect(grpc_closure* on_connect, grpc_endpoint** endpoint,
-                             grpc_slice_allocator* slice_allocator,
                              grpc_pollset_set* interested_parties,
                              const grpc_channel_args* channel_args,
                              const grpc_resolved_address* addr,
-                             grpc_millis deadline) {
-  grpc_tcp_client_impl->connect(on_connect, endpoint, slice_allocator,
-                                interested_parties, channel_args, addr,
-                                deadline);
+                             grpc_core::Timestamp deadline) {
+  grpc_tcp_client_impl->connect(on_connect, endpoint, interested_parties,
+                                channel_args, addr, deadline);
 }
 
 void grpc_set_tcp_client_impl(grpc_tcp_client_vtable* impl) {

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

@@ -27,14 +27,14 @@
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/resource_quota.h"
+#include "src/core/lib/resource_quota/memory_quota.h"
 
 typedef struct grpc_tcp_client_vtable {
   void (*connect)(grpc_closure* on_connect, grpc_endpoint** endpoint,
-                  grpc_slice_allocator* slice_allocator,
                   grpc_pollset_set* interested_parties,
                   const grpc_channel_args* channel_args,
-                  const grpc_resolved_address* addr, grpc_millis deadline);
+                  const grpc_resolved_address* addr,
+                  grpc_core::Timestamp deadline);
 } grpc_tcp_client_vtable;
 
 /* Asynchronously connect to an address (specified as (addr, len)), and call
@@ -43,11 +43,10 @@ typedef struct grpc_tcp_client_vtable {
    interested_parties points to a set of pollsets that would be interested
    in this connection being established (in order to continue their work) */
 void grpc_tcp_client_connect(grpc_closure* on_connect, grpc_endpoint** endpoint,
-                             grpc_slice_allocator* slice_allocator,
                              grpc_pollset_set* interested_parties,
                              const grpc_channel_args* channel_args,
                              const grpc_resolved_address* addr,
-                             grpc_millis deadline);
+                             grpc_core::Timestamp deadline);
 
 void grpc_tcp_client_global_init();
 

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

@@ -64,16 +64,12 @@ struct CFStreamConnect {
   grpc_endpoint** endpoint;
   int refs;
   std::string addr_name;
-  grpc_slice_allocator* slice_allocator;
 };
 
 static void CFStreamConnectCleanup(CFStreamConnect* connect) {
   CFSTREAM_HANDLE_UNREF(connect->stream_handle, "async connect clean up");
   CFRelease(connect->read_stream);
   CFRelease(connect->write_stream);
-  if (connect->slice_allocator != nullptr) {
-    grpc_slice_allocator_destroy(connect->slice_allocator);
-  }
   gpr_mu_destroy(&connect->mu);
   delete connect;
 }
@@ -132,9 +128,7 @@ static void OnOpen(void* arg, grpc_error_handle error) {
       if (error == GRPC_ERROR_NONE) {
         *endpoint = grpc_cfstream_endpoint_create(
             connect->read_stream, connect->write_stream,
-            connect->addr_name.c_str(), connect->slice_allocator,
-            connect->stream_handle);
-        connect->slice_allocator = nullptr;
+            connect->addr_name.c_str(), connect->stream_handle);
       }
     } else {
       (void)GRPC_ERROR_REF(error);
@@ -156,11 +150,10 @@ static void ParseResolvedAddress(const grpc_resolved_address* addr,
 }
 
 static void CFStreamClientConnect(grpc_closure* closure, grpc_endpoint** ep,
-                                  grpc_slice_allocator* slice_allocator,
                                   grpc_pollset_set* interested_parties,
                                   const grpc_channel_args* channel_args,
                                   const grpc_resolved_address* resolved_addr,
-                                  grpc_millis deadline) {
+                                  grpc_core::Timestamp deadline) {
   CFStreamConnect* connect = new CFStreamConnect();
   connect->closure = closure;
   connect->endpoint = ep;
@@ -173,7 +166,6 @@ static void CFStreamClientConnect(grpc_closure* closure, grpc_endpoint** ep,
     gpr_log(GPR_DEBUG, "CLIENT_CONNECT: %p, %s: asynchronously connecting",
             connect, connect->addr_name.c_str());
   }
-  connect->slice_allocator = slice_allocator;
 
   CFReadStreamRef read_stream;
   CFWriteStreamRef write_stream;

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

@@ -62,7 +62,6 @@ struct async_connect {
   grpc_endpoint** ep;
   grpc_closure* closure;
   grpc_channel_args* channel_args;
-  grpc_slice_allocator* slice_allocator;
 };
 
 static grpc_error_handle prepare_socket(const grpc_resolved_address* addr,
@@ -118,18 +117,15 @@ static void tc_on_alarm(void* acp, grpc_error_handle error) {
   gpr_mu_unlock(&ac->mu);
   if (done) {
     gpr_mu_destroy(&ac->mu);
-    if (ac->slice_allocator != nullptr) {
-      grpc_slice_allocator_destroy(ac->slice_allocator);
-    }
     grpc_channel_args_destroy(ac->channel_args);
     delete ac;
   }
 }
 
 grpc_endpoint* grpc_tcp_client_create_from_fd(
-    grpc_fd* fd, const grpc_channel_args* channel_args, const char* addr_str,
-    grpc_slice_allocator* slice_allocator) {
-  return grpc_tcp_create(fd, channel_args, addr_str, slice_allocator);
+    grpc_fd* fd, const grpc_channel_args* channel_args,
+    absl::string_view addr_str) {
+  return grpc_tcp_create(fd, channel_args, addr_str);
 }
 
 static void on_writable(void* acp, grpc_error_handle error) {
@@ -177,9 +173,7 @@ static void on_writable(void* acp, grpc_error_handle error) {
   switch (so_error) {
     case 0:
       grpc_pollset_set_del_fd(ac->interested_parties, fd);
-      *ep = grpc_tcp_client_create_from_fd(
-          fd, ac->channel_args, ac->addr_str.c_str(), ac->slice_allocator);
-      ac->slice_allocator = nullptr;
+      *ep = grpc_tcp_client_create_from_fd(fd, ac->channel_args, ac->addr_str);
       fd = nullptr;
       break;
     case ENOBUFS:
@@ -234,10 +228,6 @@ finish:
     // This is safe even outside the lock, because "done", the sentinel, is
     // populated *inside* the lock.
     gpr_mu_destroy(&ac->mu);
-    if (ac->slice_allocator != nullptr) {
-      grpc_slice_allocator_destroy(ac->slice_allocator);
-      ac->slice_allocator = nullptr;
-    }
     grpc_channel_args_destroy(ac->channel_args);
     delete ac;
   }
@@ -280,8 +270,7 @@ grpc_error_handle grpc_tcp_client_prepare_fd(
 void grpc_tcp_client_create_from_prepared_fd(
     grpc_pollset_set* interested_parties, grpc_closure* closure, const int fd,
     const grpc_channel_args* channel_args, const grpc_resolved_address* addr,
-    grpc_millis deadline, grpc_endpoint** ep,
-    grpc_slice_allocator* slice_allocator) {
+    grpc_core::Timestamp deadline, grpc_endpoint** ep) {
   int err;
   do {
     err = connect(fd, reinterpret_cast<const grpc_sockaddr*>(addr->addr),
@@ -293,13 +282,11 @@ void grpc_tcp_client_create_from_prepared_fd(
 
   if (err >= 0) {
     *ep = grpc_tcp_client_create_from_fd(fdobj, channel_args,
-                                         grpc_sockaddr_to_uri(addr).c_str(),
-                                         slice_allocator);
+                                         grpc_sockaddr_to_uri(addr));
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
     return;
   }
   if (errno != EWOULDBLOCK && errno != EINPROGRESS) {
-    grpc_slice_allocator_destroy(slice_allocator);
     grpc_error_handle error = GRPC_OS_ERROR(errno, "connect");
     error = grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS,
                                grpc_sockaddr_to_uri(addr));
@@ -318,7 +305,6 @@ void grpc_tcp_client_create_from_prepared_fd(
   ac->addr_str = grpc_sockaddr_to_uri(addr);
   gpr_mu_init(&ac->mu);
   ac->refs = 2;
-  ac->slice_allocator = slice_allocator;
   GRPC_CLOSURE_INIT(&ac->write_closure, on_writable, ac,
                     grpc_schedule_on_exec_ctx);
   ac->channel_args = grpc_channel_args_copy(channel_args);
@@ -336,24 +322,22 @@ void grpc_tcp_client_create_from_prepared_fd(
 }
 
 static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
-                        grpc_slice_allocator* slice_allocator,
                         grpc_pollset_set* interested_parties,
                         const grpc_channel_args* channel_args,
                         const grpc_resolved_address* addr,
-                        grpc_millis deadline) {
+                        grpc_core::Timestamp deadline) {
   grpc_resolved_address mapped_addr;
   int fd = -1;
   grpc_error_handle error;
   *ep = nullptr;
   if ((error = grpc_tcp_client_prepare_fd(channel_args, addr, &mapped_addr,
                                           &fd)) != GRPC_ERROR_NONE) {
-    grpc_slice_allocator_destroy(slice_allocator);
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
     return;
   }
   grpc_tcp_client_create_from_prepared_fd(interested_parties, closure, fd,
                                           channel_args, &mapped_addr, deadline,
-                                          ep, slice_allocator);
+                                          ep);
 }
 
 grpc_tcp_client_vtable grpc_posix_tcp_client_vtable = {tcp_connect};

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

@@ -34,8 +34,8 @@
    Returns: a new endpoint
 */
 grpc_endpoint* grpc_tcp_client_create_from_fd(
-    grpc_fd* fd, const grpc_channel_args* channel_args, const char* addr_str,
-    grpc_slice_allocator* slice_allocator);
+    grpc_fd* fd, const grpc_channel_args* channel_args,
+    absl::string_view addr_str);
 
 /* Return a configured, unbound, unconnected TCP client fd.
 
@@ -64,7 +64,6 @@ grpc_error_handle grpc_tcp_client_prepare_fd(
 void grpc_tcp_client_create_from_prepared_fd(
     grpc_pollset_set* interested_parties, grpc_closure* closure, const int fd,
     const grpc_channel_args* channel_args, const grpc_resolved_address* addr,
-    grpc_millis deadline, grpc_endpoint** ep,
-    grpc_slice_allocator* slice_allocator);
+    grpc_core::Timestamp deadline, grpc_endpoint** ep);
 
 #endif /* GRPC_CORE_LIB_IOMGR_TCP_CLIENT_POSIX_H */

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

@@ -51,7 +51,6 @@ struct async_connect {
   grpc_closure on_connect;
   grpc_endpoint** endpoint;
   grpc_channel_args* channel_args;
-  grpc_slice_allocator* slice_allocator;
 };
 
 static void async_connect_unlock_and_cleanup(async_connect* ac,
@@ -61,9 +60,6 @@ static void async_connect_unlock_and_cleanup(async_connect* ac,
   if (done) {
     grpc_channel_args_destroy(ac->channel_args);
     gpr_mu_destroy(&ac->mu);
-    if (ac->slice_allocator != nullptr) {
-      grpc_slice_allocator_destroy(ac->slice_allocator);
-    }
     delete ac;
   }
   if (socket != NULL) grpc_winsocket_destroy(socket);
@@ -109,9 +105,7 @@ static void on_connect(void* acp, grpc_error_handle error) {
         error = GRPC_WSA_ERROR(WSAGetLastError(), "ConnectEx");
         closesocket(socket->socket);
       } else {
-        *ep = grpc_tcp_create(socket, ac->channel_args, ac->addr_name.c_str(),
-                              ac->slice_allocator);
-        ac->slice_allocator = nullptr;
+        *ep = grpc_tcp_create(socket, ac->channel_args, ac->addr_name);
         socket = nullptr;
       }
     } else {
@@ -128,11 +122,10 @@ static void on_connect(void* acp, grpc_error_handle error) {
 /* Tries to issue one async connection, then schedules both an IOCP
    notification request for the connection, and one timeout alert. */
 static void tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
-                        grpc_slice_allocator* slice_allocator,
                         grpc_pollset_set* interested_parties,
                         const grpc_channel_args* channel_args,
                         const grpc_resolved_address* addr,
-                        grpc_millis deadline) {
+                        grpc_core::Timestamp deadline) {
   SOCKET sock = INVALID_SOCKET;
   BOOL success;
   int status;
@@ -208,7 +201,6 @@ static void tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   ac->refs = 2;
   ac->addr_name = grpc_sockaddr_to_uri(addr);
   ac->endpoint = endpoint;
-  ac->slice_allocator = slice_allocator;
   ac->channel_args = grpc_channel_args_copy(channel_args);
   GRPC_CLOSURE_INIT(&ac->on_connect, on_connect, ac, grpc_schedule_on_exec_ctx);
 
@@ -227,7 +219,6 @@ failure:
                              "Failed to connect", &error, 1),
                          GRPC_ERROR_STR_TARGET_ADDRESS, target_uri);
   GRPC_ERROR_UNREF(error);
-  grpc_slice_allocator_destroy(slice_allocator);
   if (socket != NULL) {
     grpc_winsocket_destroy(socket);
   } else if (sock != INVALID_SOCKET) {