grpc 1.40.0 → 1.41.0

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

@@ -22,13 +22,13 @@
 
 #ifdef GRPC_POSIX_SOCKET_SOCKET_FACTORY
 
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/support/sync.h>
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/socket_factory_posix.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/support/sync.h>
-
 void grpc_socket_factory_init(grpc_socket_factory* factory,
                               const grpc_socket_factory_vtable* vtable) {
   factory->vtable = vtable;

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

@@ -23,6 +23,7 @@
 
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/sync.h>
+
 #include "src/core/lib/iomgr/resolve_address.h"
 
 /** The virtual table of grpc_socket_factory */

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

@@ -21,11 +21,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdbool.h>
+
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/sync.h>
 
-#include <stdbool.h>
-
 /** How is an fd to be used? */
 typedef enum {
   /** Used for client connection */

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

@@ -22,14 +22,14 @@
 
 #ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
 
-#include "src/core/lib/iomgr/socket_utils.h"
-#include "src/core/lib/iomgr/socket_utils_posix.h"
-
 #include <arpa/inet.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <netinet/in.h>
+
+#include "src/core/lib/iomgr/socket_utils.h"
+#include "src/core/lib/iomgr/socket_utils_posix.h"
 #ifdef GRPC_LINUX_TCP_H
 #include <linux/tcp.h>
 #else

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

@@ -22,13 +22,13 @@
 
 #ifdef GRPC_LINUX_SOCKETUTILS
 
-#include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/socket_utils_posix.h"
+#include <sys/socket.h>
+#include <sys/types.h>
 
 #include <grpc/support/log.h>
 
-#include <sys/socket.h>
-#include <sys/types.h>
+#include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/iomgr/socket_utils_posix.h"
 
 int grpc_accept4(int sockfd, grpc_resolved_address* resolved_addr, int nonblock,
                  int cloexec) {

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

@@ -22,14 +22,14 @@
 
 #ifdef GRPC_POSIX_SOCKETUTILS
 
-#include "src/core/lib/iomgr/socket_utils_posix.h"
-
 #include <fcntl.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
 #include <grpc/support/log.h>
+
 #include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/iomgr/socket_utils_posix.h"
 
 int grpc_accept4(int sockfd, grpc_resolved_address* resolved_addr, int nonblock,
                  int cloexec) {

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

@@ -21,13 +21,13 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/resolve_address.h"
-
 #include <sys/socket.h>
 #include <unistd.h>
 
 #include <grpc/impl/codegen/grpc_types.h>
+
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/socket_factory_posix.h"
 #include "src/core/lib/iomgr/socket_mutator.h"
 

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

@@ -22,11 +22,11 @@
 
 #ifdef GRPC_WINDOWS_SOCKETUTILS
 
+#include <grpc/support/log.h>
+
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
 
-#include <grpc/support/log.h>
-
 uint16_t grpc_htons(uint16_t hostshort) { return htons(hostshort); }
 
 uint16_t grpc_ntohs(uint16_t netshort) { return ntohs(netshort); }

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

@@ -23,12 +23,14 @@
 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, interested_parties,
-                                channel_args, addr, deadline);
+  grpc_tcp_client_impl->connect(on_connect, endpoint, slice_allocator,
+                                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

@@ -23,12 +23,15 @@
 
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/time.h>
+
 #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"
 
 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);
@@ -40,6 +43,7 @@ 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,

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

@@ -24,15 +24,13 @@
 #ifdef GRPC_CFSTREAM_CLIENT
 
 #include <CoreFoundation/CoreFoundation.h>
-
+#include <netinet/in.h>
 #include <string.h>
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
-#include <netinet/in.h>
-
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/host_port.h"
@@ -66,14 +64,16 @@ struct CFStreamConnect {
   grpc_endpoint** endpoint;
   int refs;
   std::string addr_name;
-  grpc_resource_quota* resource_quota;
+  grpc_slice_allocator* slice_allocator;
 };
 
 static void CFStreamConnectCleanup(CFStreamConnect* connect) {
-  grpc_resource_quota_unref_internal(connect->resource_quota);
   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;
 }
@@ -130,8 +130,9 @@ 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->resource_quota,
+            connect->addr_name.c_str(), connect->slice_allocator,
             connect->stream_handle);
+        connect->slice_allocator = nullptr;
       }
     } else {
       GRPC_ERROR_REF(error);
@@ -153,6 +154,7 @@ 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,
@@ -161,7 +163,6 @@ static void CFStreamClientConnect(grpc_closure* closure, grpc_endpoint** ep,
   connect->closure = closure;
   connect->endpoint = ep;
   connect->addr_name = grpc_sockaddr_to_uri(resolved_addr);
-  // connect->resource_quota = resource_quota;
   connect->refs = 2;  // One for the connect operation, one for the timer.
   gpr_ref_init(&connect->refcount, 1);
   gpr_mu_init(&connect->mu);
@@ -170,18 +171,7 @@ 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());
   }
-
-  grpc_resource_quota* resource_quota = grpc_resource_quota_create(NULL);
-  if (channel_args != NULL) {
-    for (size_t i = 0; i < channel_args->num_args; i++) {
-      if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_RESOURCE_QUOTA)) {
-        grpc_resource_quota_unref_internal(resource_quota);
-        resource_quota = grpc_resource_quota_ref_internal(
-            (grpc_resource_quota*)channel_args->args[i].value.pointer.p);
-      }
-    }
-  }
-  connect->resource_quota = resource_quota;
+  connect->slice_allocator = slice_allocator;
 
   CFReadStreamRef read_stream;
   CFWriteStreamRef write_stream;

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

@@ -18,8 +18,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/port.h"
-
 #include <string.h>
 
 #include <grpc/support/alloc.h>
@@ -28,6 +26,7 @@
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_custom.h"
+#include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_custom.h"
 #include "src/core/lib/iomgr/timer.h"
@@ -43,12 +42,14 @@ struct grpc_custom_tcp_connect {
   grpc_endpoint** endpoint;
   int refs;
   std::string addr_name;
-  grpc_resource_quota* resource_quota;
+  grpc_slice_allocator* slice_allocator;
 };
 
 static void custom_tcp_connect_cleanup(grpc_custom_tcp_connect* connect) {
+  if (connect->slice_allocator != nullptr) {
+    grpc_slice_allocator_destroy(connect->slice_allocator);
+  }
   grpc_custom_socket* socket = connect->socket;
-  grpc_resource_quota_unref_internal(connect->resource_quota);
   delete connect;
   socket->refs--;
   if (socket->refs == 0) {
@@ -87,7 +88,8 @@ static void custom_connect_callback_internal(grpc_custom_socket* socket,
   grpc_timer_cancel(&connect->alarm);
   if (error == GRPC_ERROR_NONE) {
     *connect->endpoint = custom_tcp_endpoint_create(
-        socket, connect->resource_quota, connect->addr_name.c_str());
+        socket, connect->slice_allocator, connect->addr_name.c_str());
+    connect->slice_allocator = nullptr;
   }
   done = (--connect->refs == 0);
   if (done) {
@@ -111,6 +113,7 @@ static void custom_connect_callback(grpc_custom_socket* socket,
 }
 
 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* resolved_addr,
@@ -118,17 +121,6 @@ static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
   (void)channel_args;
   (void)interested_parties;
-  grpc_resource_quota* resource_quota = grpc_resource_quota_create(nullptr);
-  if (channel_args != nullptr) {
-    for (size_t i = 0; i < channel_args->num_args; i++) {
-      if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_RESOURCE_QUOTA)) {
-        grpc_resource_quota_unref_internal(resource_quota);
-        resource_quota =
-            grpc_resource_quota_ref_internal(static_cast<grpc_resource_quota*>(
-                channel_args->args[i].value.pointer.p));
-      }
-    }
-  }
   grpc_custom_socket* socket =
       static_cast<grpc_custom_socket*>(gpr_malloc(sizeof(grpc_custom_socket)));
   socket->refs = 2;
@@ -137,7 +129,7 @@ static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
   connect->closure = closure;
   connect->endpoint = ep;
   connect->addr_name = grpc_sockaddr_to_uri(resolved_addr);
-  connect->resource_quota = resource_quota;
+  connect->slice_allocator = slice_allocator;
   connect->socket = socket;
   socket->connector = connect;
   socket->endpoint = nullptr;

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

@@ -22,8 +22,6 @@
 
 #ifdef GRPC_POSIX_SOCKET_TCP_CLIENT
 
-#include "src/core/lib/iomgr/tcp_client_posix.h"
-
 #include <errno.h>
 #include <netinet/in.h>
 #include <string.h>
@@ -44,6 +42,7 @@
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_mutator.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
+#include "src/core/lib/iomgr/tcp_client_posix.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
@@ -63,6 +62,7 @@ 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,14 +118,18 @@ 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) {
-  return grpc_tcp_create(fd, channel_args, addr_str);
+    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);
 }
 
 static void on_writable(void* acp, grpc_error_handle error) {
@@ -174,8 +178,9 @@ 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());
+      *ep = grpc_tcp_client_create_from_fd(
+          fd, ac->channel_args, ac->addr_str.c_str(), ac->slice_allocator);
+      ac->slice_allocator = nullptr;
       fd = nullptr;
       break;
     case ENOBUFS:
@@ -237,6 +242,10 @@ 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;
   }
@@ -279,7 +288,8 @@ 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_millis deadline, grpc_endpoint** ep,
+    grpc_slice_allocator* slice_allocator) {
   int err;
   do {
     err = connect(fd, reinterpret_cast<const grpc_sockaddr*>(addr->addr),
@@ -291,11 +301,13 @@ 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());
+                                         grpc_sockaddr_to_uri(addr).c_str(),
+                                         slice_allocator);
     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,
@@ -315,6 +327,7 @@ 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);
@@ -332,6 +345,7 @@ 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,
@@ -342,12 +356,13 @@ static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
   *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);
+                                          ep, slice_allocator);
 }
 
 grpc_tcp_client_vtable grpc_posix_tcp_client_vtable = {tcp_connect};

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

@@ -30,10 +30,12 @@
    fd: a connected FD. Ownership is taken.
    channel_args: may contain custom settings for the endpoint
    addr_str: destination address in printable format
+   slice_allocator: ownership is taken by client.
    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_fd* fd, const grpc_channel_args* channel_args, const char* addr_str,
+    grpc_slice_allocator* slice_allocator);
 
 /* Return a configured, unbound, unconnected TCP client fd.
 
@@ -62,6 +64,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_millis deadline, grpc_endpoint** ep,
+    grpc_slice_allocator* slice_allocator);
 
 #endif /* GRPC_CORE_LIB_IOMGR_TCP_CLIENT_POSIX_H */

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

@@ -18,13 +18,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/port.h"
-
 #include <inttypes.h>
 
-#ifdef GRPC_WINSOCK_SOCKET
+#include "src/core/lib/iomgr/port.h"
 
-#include "src/core/lib/iomgr/sockaddr_windows.h"
+#ifdef GRPC_WINSOCK_SOCKET
 
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
@@ -35,6 +33,7 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/iomgr/sockaddr_windows.h"
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_windows.h"
@@ -52,6 +51,7 @@ 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,6 +61,9 @@ 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);
@@ -106,8 +109,10 @@ 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());
-        socket = NULL;
+        *ep = grpc_tcp_create(socket, ac->channel_args, ac->addr_name.c_str(),
+                              ac->slice_allocator);
+        ac->slice_allocator = nullptr;
+        socket = nullptr;
       }
     } else {
       error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("socket is null");
@@ -123,6 +128,7 @@ 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,
@@ -202,6 +208,7 @@ 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);
 
@@ -221,6 +228,7 @@ failure:
                          GRPC_ERROR_STR_TARGET_ADDRESS,
                          grpc_slice_from_cpp_string(std::move(target_uri)));
   GRPC_ERROR_UNREF(error);
+  grpc_slice_allocator_destroy(slice_allocator);
   if (socket != NULL) {
     grpc_winsocket_destroy(socket);
   } else if (sock != INVALID_SOCKET) {

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

@@ -18,13 +18,12 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/tcp_custom.h"
 
 #include <limits.h>
 #include <string.h>
 
 #include <grpc/slice_buffer.h>
-
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -32,9 +31,9 @@
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_custom.h"
+#include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/resource_quota.h"
 #include "src/core/lib/iomgr/tcp_client.h"
-#include "src/core/lib/iomgr/tcp_custom.h"
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
@@ -64,8 +63,7 @@ struct custom_tcp_endpoint {
   grpc_slice_buffer* read_slices = nullptr;
   grpc_slice_buffer* write_slices = nullptr;
 
-  grpc_resource_user* resource_user;
-  grpc_resource_user_slice_allocator slice_allocator;
+  grpc_slice_allocator* slice_allocator;
 
   bool shutting_down;
 
@@ -75,7 +73,7 @@ struct custom_tcp_endpoint {
 static void tcp_free(grpc_custom_socket* s) {
   custom_tcp_endpoint* tcp =
       reinterpret_cast<custom_tcp_endpoint*>(s->endpoint);
-  grpc_resource_user_unref(tcp->resource_user);
+  grpc_slice_allocator_destroy(tcp->slice_allocator);
   delete tcp;
   s->refs--;
   if (s->refs == 0) {
@@ -203,9 +201,10 @@ static void endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
   tcp->read_slices = read_slices;
   grpc_slice_buffer_reset_and_unref_internal(read_slices);
   TCP_REF(tcp, "read");
-  if (grpc_resource_user_alloc_slices(&tcp->slice_allocator,
-                                      GRPC_TCP_DEFAULT_READ_SLICE_SIZE, 1,
-                                      tcp->read_slices)) {
+  if (grpc_slice_allocator_allocate(
+          tcp->slice_allocator, GRPC_TCP_DEFAULT_READ_SLICE_SIZE, 1,
+          grpc_slice_allocator_intent::kReadBuffer, tcp->read_slices,
+          tcp_read_allocation_done, tcp)) {
     tcp_read_allocation_done(tcp, GRPC_ERROR_NONE);
   }
 }
@@ -254,8 +253,7 @@ static void endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* write_slices,
   tcp->write_slices = write_slices;
   GPR_ASSERT(tcp->write_slices->count <= UINT_MAX);
   if (tcp->write_slices->count == 0) {
-    // No slices means we don't have to do anything,
-    // and libuv doesn't like empty writes
+    // No slices means we don't have to do anything
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, GRPC_ERROR_NONE);
     return;
   }
@@ -297,7 +295,6 @@ static void endpoint_shutdown(grpc_endpoint* ep, grpc_error_handle why) {
     // GRPC_ERROR_REF(why));
     // grpc_core::ExecCtx::Run(DEBUG_LOCATION,tcp->write_cb,
     // GRPC_ERROR_REF(why)); tcp->read_cb = nullptr; tcp->write_cb = nullptr;
-    grpc_resource_user_shutdown(tcp->resource_user);
     grpc_custom_socket_vtable->shutdown(tcp->socket);
   }
   GRPC_ERROR_UNREF(why);
@@ -332,11 +329,6 @@ static absl::string_view endpoint_get_local_address(grpc_endpoint* ep) {
   return tcp->local_address;
 }
 
-static grpc_resource_user* endpoint_get_resource_user(grpc_endpoint* ep) {
-  custom_tcp_endpoint* tcp = reinterpret_cast<custom_tcp_endpoint*>(ep);
-  return tcp->resource_user;
-}
-
 static int endpoint_get_fd(grpc_endpoint* /*ep*/) { return -1; }
 
 static bool endpoint_can_track_err(grpc_endpoint* /*ep*/) { return false; }
@@ -348,14 +340,13 @@ static grpc_endpoint_vtable vtable = {endpoint_read,
                                       endpoint_delete_from_pollset_set,
                                       endpoint_shutdown,
                                       endpoint_destroy,
-                                      endpoint_get_resource_user,
                                       endpoint_get_peer,
                                       endpoint_get_local_address,
                                       endpoint_get_fd,
                                       endpoint_can_track_err};
 
 grpc_endpoint* custom_tcp_endpoint_create(grpc_custom_socket* socket,
-                                          grpc_resource_quota* resource_quota,
+                                          grpc_slice_allocator* slice_allocator,
                                           const char* peer_string) {
   custom_tcp_endpoint* tcp = new custom_tcp_endpoint;
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
@@ -381,9 +372,6 @@ grpc_endpoint* custom_tcp_endpoint_create(grpc_custom_socket* socket,
     tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
   }
   tcp->shutting_down = false;
-  tcp->resource_user = grpc_resource_user_create(resource_quota, peer_string);
-  grpc_resource_user_slice_allocator_init(
-      &tcp->slice_allocator, tcp->resource_user, tcp_read_allocation_done, tcp);
-
+  tcp->slice_allocator = slice_allocator;
   return &tcp->base;
 }