grpc 1.42.0 → 1.43.1

data/src/core/lib/gprpp/table.h

@@ -268,13 +268,25 @@ class Table {
   TypeIndex<I>* set(Args&&... args) {
     auto* p = element_ptr<I>();
     if (set_present<I>(true)) {
-      *p = TypeIndex<I>(std::forward<Args>(args)...);
+      TypeIndex<I> replacement(std::forward<Args>(args)...);
+      *p = std::move(replacement);
     } else {
       new (p) TypeIndex<I>(std::forward<Args>(args)...);
     }
     return p;
   }
 
+  template <size_t I>
+  TypeIndex<I>* set(TypeIndex<I>&& value) {
+    auto* p = element_ptr<I>();
+    if (set_present<I>(true)) {
+      *p = std::forward<TypeIndex<I>>(value);
+    } else {
+      new (p) TypeIndex<I>(std::forward<TypeIndex<I>>(value));
+    }
+    return p;
+  }
+
   // Clear the value for type T, leaving it un-set.
   template <typename T>
   void clear() {

data/src/core/lib/http/httpcli.cc

@@ -27,11 +27,13 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/http/format_request.h"
@@ -40,6 +42,7 @@
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/tcp_client.h"
+#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 namespace grpc_core {
@@ -49,13 +52,13 @@ class InternalRequest {
  public:
   InternalRequest(const grpc_slice& request_text,
                   grpc_httpcli_response* response,
-                  grpc_resource_quota* resource_quota, absl::string_view host,
+                  ResourceQuotaRefPtr resource_quota, absl::string_view host,
                   absl::string_view ssl_host_override, grpc_millis deadline,
                   const grpc_httpcli_handshaker* handshaker,
                   grpc_closure* on_done, grpc_httpcli_context* context,
                   grpc_polling_entity* pollent, const char* name)
       : request_text_(request_text),
-        resource_quota_(resource_quota),
+        resource_quota_(std::move(resource_quota)),
         host_(host),
         ssl_host_override_(ssl_host_override),
         deadline_(deadline),
@@ -91,13 +94,12 @@ class InternalRequest {
     grpc_slice_buffer_destroy_internal(&incoming_);
     grpc_slice_buffer_destroy_internal(&outgoing_);
     GRPC_ERROR_UNREF(overall_error_);
-    grpc_resource_quota_unref_internal(resource_quota_);
   }
 
  private:
   void Finish(grpc_error_handle error) {
     grpc_polling_entity_del_from_pollset_set(pollent_, context_->pollset_set);
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_done_, error);
+    ExecCtx::Run(DEBUG_LOCATION, on_done_, error);
     delete this;
   }
 
@@ -203,10 +205,16 @@ class InternalRequest {
     addr = &addresses_->addrs[next_address_++];
     GRPC_CLOSURE_INIT(&connected_, OnConnected, this,
                       grpc_schedule_on_exec_ctx);
-    grpc_tcp_client_connect(&connected_, &ep_,
-                            grpc_slice_allocator_create(
-                                resource_quota_, grpc_sockaddr_to_uri(addr)),
-                            context_->pollset_set, nullptr, addr, deadline_);
+    grpc_arg rq_arg = grpc_channel_arg_pointer_create(
+        const_cast<char*>(GRPC_ARG_RESOURCE_QUOTA), resource_quota_->c_ptr(),
+        grpc_resource_quota_arg_vtable());
+    grpc_channel_args channel_args{1, &rq_arg};
+    auto* args = CoreConfiguration::Get()
+                     .channel_args_preconditioning()
+                     .PreconditionChannelArgs(&channel_args);
+    grpc_tcp_client_connect(&connected_, &ep_, context_->pollset_set, args,
+                            addr, deadline_);
+    grpc_channel_args_destroy(args);
   }
 
   static void OnResolved(void* arg, grpc_error_handle error) {
@@ -224,7 +232,7 @@ class InternalRequest {
   grpc_resolved_addresses* addresses_ = nullptr;
   size_t next_address_ = 0;
   grpc_endpoint* ep_ = nullptr;
-  grpc_resource_quota* resource_quota_;
+  ResourceQuotaRefPtr resource_quota_;
   std::string host_;
   std::string ssl_host_override_;
   grpc_millis deadline_;
@@ -266,16 +274,14 @@ void grpc_httpcli_context_destroy(grpc_httpcli_context* context) {
   grpc_pollset_set_destroy(context->pollset_set);
 }
 
-static void internal_request_begin(grpc_httpcli_context* context,
-                                   grpc_polling_entity* pollent,
-                                   grpc_resource_quota* resource_quota,
-                                   const grpc_httpcli_request* request,
-                                   grpc_millis deadline, grpc_closure* on_done,
-                                   grpc_httpcli_response* response,
-                                   const char* name,
-                                   const grpc_slice& request_text) {
+static void internal_request_begin(
+    grpc_httpcli_context* context, grpc_polling_entity* pollent,
+    grpc_core::ResourceQuotaRefPtr resource_quota,
+    const grpc_httpcli_request* request, grpc_millis deadline,
+    grpc_closure* on_done, grpc_httpcli_response* response, const char* name,
+    const grpc_slice& request_text) {
   new grpc_core::InternalRequest(
-      request_text, response, resource_quota, request->host,
+      request_text, response, std::move(resource_quota), request->host,
       request->ssl_host_override, deadline,
       request->handshaker ? request->handshaker : &grpc_httpcli_plaintext,
       on_done, context, pollent, name);
@@ -283,37 +289,35 @@ static void internal_request_begin(grpc_httpcli_context* context,
 
 void grpc_httpcli_get(grpc_httpcli_context* context,
                       grpc_polling_entity* pollent,
-                      grpc_resource_quota* resource_quota,
+                      grpc_core::ResourceQuotaRefPtr resource_quota,
                       const grpc_httpcli_request* request, grpc_millis deadline,
                       grpc_closure* on_done, grpc_httpcli_response* response) {
   if (g_get_override && g_get_override(request, deadline, on_done, response)) {
-    grpc_resource_quota_unref_internal(resource_quota);
     return;
   }
   std::string name =
       absl::StrFormat("HTTP:GET:%s:%s", request->host, request->http.path);
-  internal_request_begin(context, pollent, resource_quota, request, deadline,
-                         on_done, response, name.c_str(),
+  internal_request_begin(context, pollent, std::move(resource_quota), request,
+                         deadline, on_done, response, name.c_str(),
                          grpc_httpcli_format_get_request(request));
 }
 
 void grpc_httpcli_post(grpc_httpcli_context* context,
                        grpc_polling_entity* pollent,
-                       grpc_resource_quota* resource_quota,
+                       grpc_core::ResourceQuotaRefPtr resource_quota,
                        const grpc_httpcli_request* request,
                        const char* body_bytes, size_t body_size,
                        grpc_millis deadline, grpc_closure* on_done,
                        grpc_httpcli_response* response) {
   if (g_post_override && g_post_override(request, body_bytes, body_size,
                                          deadline, on_done, response)) {
-    grpc_resource_quota_unref_internal(resource_quota);
     return;
   }
   std::string name =
       absl::StrFormat("HTTP:POST:%s:%s", request->host, request->http.path);
   internal_request_begin(
-      context, pollent, resource_quota, request, deadline, on_done, response,
-      name.c_str(),
+      context, pollent, std::move(resource_quota), request, deadline, on_done,
+      response, name.c_str(),
       grpc_httpcli_format_post_request(request, body_bytes, body_size));
 }
 

data/src/core/lib/http/httpcli.h

@@ -30,7 +30,7 @@
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/pollset_set.h"
-#include "src/core/lib/iomgr/resource_quota.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
 
 /* User agent this library reports */
 #define GRPC_HTTPCLI_USER_AGENT "grpc-httpcli/0.0"
@@ -73,26 +73,28 @@ void grpc_httpcli_context_destroy(grpc_httpcli_context* context);
 
 /* Asynchronously perform a HTTP GET.
    'context' specifies the http context under which to do the get
-   'pollset' indicates a grpc_pollset that is interested in the result
-     of the get - work on this pollset may be used to progress the get
+   'pollent' indicates a grpc_polling_entity that is interested in the result
+     of the get - work on this entity may be used to progress the get
      operation
-   'resource_quota: this function takes ownership of a ref from the caller
-   'request' contains request parameters - these are caller owned and can be
-     destroyed once the call returns
-   'deadline' contains a deadline for the request (or gpr_inf_future)
+   'resource_quota' allows the caller to specify the quota against which to
+   allocate
+   'request' contains request parameters - these are caller owned and
+   can be destroyed once the call returns 'deadline' contains a deadline for the
+   request (or gpr_inf_future)
    'on_response' is a callback to report results to */
 void grpc_httpcli_get(grpc_httpcli_context* context,
                       grpc_polling_entity* pollent,
-                      grpc_resource_quota* resource_quota,
+                      grpc_core::ResourceQuotaRefPtr resource_quota,
                       const grpc_httpcli_request* request, grpc_millis deadline,
                       grpc_closure* on_done, grpc_httpcli_response* response);
 
 /* Asynchronously perform a HTTP POST.
    'context' specifies the http context under which to do the post
-   'pollset' indicates a grpc_pollset that is interested in the result
-     of the post - work on this pollset may be used to progress the post
+   'pollent' indicates a grpc_polling_entity that is interested in the result
+     of the post - work on this entity may be used to progress the post
      operation
-   'resource_quota' - this function takes ownership of a ref from the caller.
+   'resource_quota' allows the caller to specify the quota against which to
+   allocate
    'request' contains request parameters - these are caller owned and can be
      destroyed once the call returns
    'body_bytes' and 'body_size' specify the payload for the post.
@@ -104,7 +106,7 @@ void grpc_httpcli_get(grpc_httpcli_context* context,
    Does not support ?var1=val1&var2=val2 in the path. */
 void grpc_httpcli_post(grpc_httpcli_context* context,
                        grpc_polling_entity* pollent,
-                       grpc_resource_quota* resource_quota,
+                       grpc_core::ResourceQuotaRefPtr resource_quota,
                        const grpc_httpcli_request* request,
                        const char* body_bytes, size_t body_size,
                        grpc_millis deadline, grpc_closure* on_done,

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

@@ -40,14 +40,14 @@ void fill_gpr_from_timestamp(gpr_timespec* gts, const struct timespec* ts) {
   gts->clock_type = GPR_CLOCK_REALTIME;
 }
 
-void default_timestamps_callback(void* /*arg*/, grpc_core::Timestamps* /*ts*/,
+void default_timestamps_callback(void* /*arg*/, Timestamps* /*ts*/,
                                  grpc_error_handle /*shudown_err*/) {
   gpr_log(GPR_DEBUG, "Timestamps callback has not been registered");
 }
 
 /** The saved callback function that will be invoked when we get all the
  * timestamps that we are going to get for a TracedBuffer. */
-void (*timestamps_callback)(void*, grpc_core::Timestamps*,
+void (*timestamps_callback)(void*, Timestamps*,
                             grpc_error_handle shutdown_err) =
     default_timestamps_callback;
 
@@ -62,11 +62,11 @@ T read_unaligned(const void* ptr) {
 
 /* Extracts opt stats from the tcp_info struct \a info to \a metrics */
 void extract_opt_stats_from_tcp_info(ConnectionMetrics* metrics,
-                                     const grpc_core::tcp_info* info) {
+                                     const tcp_info* info) {
   if (info == nullptr) {
     return;
   }
-  if (info->length > offsetof(grpc_core::tcp_info, tcpi_sndbuf_limited)) {
+  if (info->length > offsetof(tcp_info, tcpi_sndbuf_limited)) {
     metrics->recurring_retrans.emplace(info->tcpi_retransmits);
     metrics->is_delivery_rate_app_limited.emplace(
         info->tcpi_delivery_rate_app_limited);
@@ -84,7 +84,7 @@ void extract_opt_stats_from_tcp_info(ConnectionMetrics* metrics,
     metrics->rwnd_limited_usec.emplace(info->tcpi_rwnd_limited);
     metrics->sndbuf_limited_usec.emplace(info->tcpi_sndbuf_limited);
   }
-  if (info->length > offsetof(grpc_core::tcp_info, tcpi_dsack_dups)) {
+  if (info->length > offsetof(tcp_info, tcpi_dsack_dups)) {
     metrics->data_sent.emplace(info->tcpi_bytes_sent);
     metrics->data_retx.emplace(info->tcpi_bytes_retrans);
     metrics->packet_spurious_retx.emplace(info->tcpi_dsack_dups);
@@ -189,9 +189,9 @@ void extract_opt_stats_from_cmsg(ConnectionMetrics* metrics,
   }
 }
 
-static int get_socket_tcp_info(grpc_core::tcp_info* info, int fd) {
+int get_socket_tcp_info(tcp_info* info, int fd) {
   memset(info, 0, sizeof(*info));
-  info->length = offsetof(grpc_core::tcp_info, length);
+  info->length = offsetof(tcp_info, length);
   return getsockopt(fd, IPPROTO_TCP, TCP_INFO, info, &(info->length));
 }
 } /* namespace */
@@ -286,7 +286,7 @@ void TracedBuffer::Shutdown(TracedBuffer** head, void* remaining,
 }
 
 void grpc_tcp_set_write_timestamps_callback(
-    void (*fn)(void*, grpc_core::Timestamps*, grpc_error_handle error)) {
+    void (*fn)(void*, Timestamps*, grpc_error_handle error)) {
   timestamps_callback = fn;
 }
 } /* namespace grpc_core */
@@ -295,7 +295,7 @@ void grpc_tcp_set_write_timestamps_callback(
 
 namespace grpc_core {
 void grpc_tcp_set_write_timestamps_callback(
-    void (*fn)(void*, grpc_core::Timestamps*, grpc_error_handle error)) {
+    void (*fn)(void*, Timestamps*, grpc_error_handle error)) {
   // Cast value of fn to void to avoid unused parameter warning.
   // Can't comment out the name because some compilers and formatters don't
   // like the sequence */* , which would arise from */*fn*/.

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

@@ -96,8 +96,8 @@ struct Timestamps {
   uint32_t byte_offset; /* byte offset relative to the start of the RPC */
 
 #ifdef GRPC_LINUX_ERRQUEUE
-  grpc_core::tcp_info info; /* tcp_info collected on sendmsg */
-#endif                      /* GRPC_LINUX_ERRQUEUE */
+  tcp_info info; /* tcp_info collected on sendmsg */
+#endif           /* GRPC_LINUX_ERRQUEUE */
 };
 
 /** TracedBuffer is a class to keep track of timestamps for a specific buffer in
@@ -105,7 +105,7 @@ struct Timestamps {
  * this class would only be used by Linux platforms. For all other platforms,
  * TracedBuffer would be an empty class.
  *
- * The timestamps collected are according to grpc_core::Timestamps declared
+ * The timestamps collected are according to Timestamps declared
  * above.
  *
  * A TracedBuffer list is kept track of using the head element of the list. If
@@ -120,33 +120,33 @@ class TracedBuffer {
 
   /** Add a new entry in the TracedBuffer list pointed to by head. Also saves
    * sendmsg_time with the current timestamp. */
-  static void AddNewEntry(grpc_core::TracedBuffer** head, uint32_t seq_no,
-                          int fd, void* arg);
+  static void AddNewEntry(TracedBuffer** head, uint32_t seq_no, int fd,
+                          void* arg);
 
   /** Processes a received timestamp based on sock_extended_err and
    * scm_timestamping structures. It will invoke the timestamps callback if the
    * timestamp type is SCM_TSTAMP_ACK. */
-  static void ProcessTimestamp(grpc_core::TracedBuffer** head,
+  static void ProcessTimestamp(TracedBuffer** head,
                                struct sock_extended_err* serr,
                                struct cmsghdr* opt_stats,
                                struct scm_timestamping* tss);
 
   /** Cleans the list by calling the callback for each traced buffer in the list
    * with timestamps that it has. */
-  static void Shutdown(grpc_core::TracedBuffer** head, void* remaining,
+  static void Shutdown(TracedBuffer** head, void* remaining,
                        grpc_error_handle shutdown_err);
 
  private:
-  uint32_t seq_no_; /* The sequence number for the last byte in the buffer */
-  void* arg_;       /* The arg to pass to timestamps_callback */
-  grpc_core::Timestamps ts_; /* The timestamps corresponding to this buffer */
-  grpc_core::TracedBuffer* next_; /* The next TracedBuffer in the list */
+  uint32_t seq_no_;    /* The sequence number for the last byte in the buffer */
+  void* arg_;          /* The arg to pass to timestamps_callback */
+  Timestamps ts_;      /* The timestamps corresponding to this buffer */
+  TracedBuffer* next_; /* The next TracedBuffer in the list */
 };
 #else  /* GRPC_LINUX_ERRQUEUE */
 class TracedBuffer {
  public:
   /* Phony shutdown function */
-  static void Shutdown(grpc_core::TracedBuffer** /*head*/, void* /*remaining*/,
+  static void Shutdown(TracedBuffer** /*head*/, void* /*remaining*/,
                        grpc_error_handle shutdown_err) {
     GRPC_ERROR_UNREF(shutdown_err);
   }
@@ -156,7 +156,7 @@ class TracedBuffer {
 /** Sets the callback function to call when timestamps for a write are
  *  collected. The callback does not own a reference to error. */
 void grpc_tcp_set_write_timestamps_callback(
-    void (*fn)(void*, grpc_core::Timestamps*, grpc_error_handle error));
+    void (*fn)(void*, Timestamps*, grpc_error_handle error));
 
 } /* namespace grpc_core */
 

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

@@ -34,7 +34,7 @@ DebugOnlyTraceFlag grpc_call_combiner_trace(false, "call_combiner");
 namespace {
 
 // grpc_error LSB can be used
-constexpr static intptr_t kErrorBit = 1;
+constexpr intptr_t kErrorBit = 1;
 
 grpc_error_handle DecodeCancelStateError(gpr_atm cancel_state) {
   if (cancel_state & kErrorBit) {
@@ -91,8 +91,7 @@ void CallCombiner::TsanClosure(void* arg, grpc_error_handle error) {
   } else {
     lock.reset();
   }
-  grpc_core::Closure::Run(DEBUG_LOCATION, self->original_closure_,
-                          GRPC_ERROR_REF(error));
+  Closure::Run(DEBUG_LOCATION, self->original_closure_, GRPC_ERROR_REF(error));
   if (lock != nullptr) {
     TSAN_ANNOTATE_RWLOCK_RELEASED(&lock->taken, true);
     bool prev = true;

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

@@ -29,7 +29,6 @@
 
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/pollset_set.h"
-#include "src/core/lib/iomgr/resource_quota.h"
 
 /* An endpoint caps a streaming channel between two communicating processes.
    Examples may be: a tcp socket, <stdin+stdout>, or some shared memory. */

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

@@ -59,10 +59,8 @@ struct CFStreamEndpoint {
 
   std::string peer_string;
   std::string local_address;
-  grpc_slice_allocator* slice_allocator;
 };
 static void CFStreamFree(CFStreamEndpoint* ep) {
-  grpc_slice_allocator_destroy(ep->slice_allocator);
   CFRelease(ep->read_stream);
   CFRelease(ep->write_stream);
   CFSTREAM_HANDLE_UNREF(ep->stream_sync, "free");
@@ -238,17 +236,6 @@ static void WriteAction(void* arg, grpc_error_handle error) {
   grpc_slice_unref_internal(slice);
 }
 
-static void CFStreamReadAllocationDone(void* arg, grpc_error_handle error) {
-  CFStreamEndpoint* ep = static_cast<CFStreamEndpoint*>(arg);
-  if (error == GRPC_ERROR_NONE) {
-    ep->stream_sync->NotifyOnRead(&ep->read_action);
-  } else {
-    grpc_slice_buffer_reset_and_unref_internal(ep->read_slices);
-    CallReadCb(ep, error);
-    EP_UNREF(ep, "read");
-  }
-}
-
 static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
                          grpc_closure* cb, bool urgent) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
@@ -260,13 +247,10 @@ static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
   ep_impl->read_cb = cb;
   ep_impl->read_slices = slices;
   grpc_slice_buffer_reset_and_unref_internal(slices);
+  grpc_slice_buffer_add_indexed(
+      slices, GRPC_SLICE_MALLOC(GRPC_TCP_DEFAULT_READ_SLICE_SIZE));
   EP_REF(ep_impl, "read");
-  if (grpc_slice_allocator_allocate(
-          ep_impl->slice_allocator, GRPC_TCP_DEFAULT_READ_SLICE_SIZE, 1,
-          grpc_slice_allocator_intent::kReadBuffer, ep_impl->read_slices,
-          CFStreamReadAllocationDone, ep_impl)) {
-    ep_impl->stream_sync->NotifyOnRead(&ep_impl->read_action);
-  }
+  ep_impl->stream_sync->NotifyOnRead(&ep_impl->read_action);
 }
 
 static void CFStreamWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,
@@ -337,10 +321,10 @@ static const grpc_endpoint_vtable vtable = {CFStreamRead,
                                             CFStreamGetFD,
                                             CFStreamCanTrackErr};
 
-grpc_endpoint* grpc_cfstream_endpoint_create(
-    CFReadStreamRef read_stream, CFWriteStreamRef write_stream,
-    const char* peer_string, grpc_slice_allocator* slice_allocator,
-    CFStreamHandle* stream_sync) {
+grpc_endpoint* grpc_cfstream_endpoint_create(CFReadStreamRef read_stream,
+                                             CFWriteStreamRef write_stream,
+                                             const char* peer_string,
+                                             CFStreamHandle* stream_sync) {
   CFStreamEndpoint* ep_impl = new CFStreamEndpoint;
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG,
@@ -381,7 +365,6 @@ grpc_endpoint* grpc_cfstream_endpoint_create(
                     static_cast<void*>(ep_impl), grpc_schedule_on_exec_ctx);
   GRPC_CLOSURE_INIT(&ep_impl->write_action, WriteAction,
                     static_cast<void*>(ep_impl), grpc_schedule_on_exec_ctx);
-  ep_impl->slice_allocator = slice_allocator;
 
   return &ep_impl->base;
 }

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

@@ -39,10 +39,10 @@
 #include "src/core/lib/iomgr/cfstream_handle.h"
 #include "src/core/lib/iomgr/endpoint.h"
 
-grpc_endpoint* grpc_cfstream_endpoint_create(
-    CFReadStreamRef read_stream, CFWriteStreamRef write_stream,
-    const char* peer_string, grpc_slice_allocator* slice_allocator,
-    CFStreamHandle* stream_sync);
+grpc_endpoint* grpc_cfstream_endpoint_create(CFReadStreamRef read_stream,
+                                             CFWriteStreamRef write_stream,
+                                             const char* peer_string,
+                                             CFStreamHandle* stream_sync);
 
 #endif /* GRPC_CFSTREAM */
 

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

@@ -40,6 +40,7 @@
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/resource_quota/api.h"
 
 static void create_sockets(int sv[2]) {
   int flags;
@@ -59,18 +60,15 @@ grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char* name,
   create_sockets(sv);
   grpc_core::ExecCtx exec_ctx;
   std::string final_name = absl::StrCat(name, ":client");
-  grpc_resource_quota* resource_quota =
-      grpc_resource_quota_from_channel_args(args, true);
-  p.client = grpc_tcp_create(
-      grpc_fd_create(sv[1], final_name.c_str(), false), args,
-      "socketpair-server",
-      grpc_slice_allocator_create(resource_quota, "server_endpoint", args));
+  const grpc_channel_args* new_args = grpc_core::CoreConfiguration::Get()
+                                          .channel_args_preconditioning()
+                                          .PreconditionChannelArgs(args);
+  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");
-  p.server = grpc_tcp_create(
-      grpc_fd_create(sv[0], final_name.c_str(), false), args,
-      "socketpair-client",
-      grpc_slice_allocator_create(resource_quota, "client_endpoint", args));
-  grpc_resource_quota_unref_internal(resource_quota);
+  p.server = grpc_tcp_create(grpc_fd_create(sv[0], final_name.c_str(), false),
+                             new_args, "socketpair-client");
+  grpc_channel_args_destroy(new_args);
   return p;
 }
 

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

@@ -71,24 +71,15 @@ static void create_sockets(SOCKET sv[2]) {
 }
 
 grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(
-    const char* name, grpc_channel_args* channel_args) {
+    const char*, grpc_channel_args* channel_args) {
   SOCKET sv[2];
   grpc_endpoint_pair p;
   create_sockets(sv);
   grpc_core::ExecCtx exec_ctx;
-  grpc_resource_quota* resource_quota =
-      grpc_resource_quota_from_channel_args(channel_args, true);
-  p.client =
-      grpc_tcp_create(grpc_winsocket_create(sv[1], "endpoint:client"),
-                      channel_args, "endpoint:server",
-                      grpc_slice_allocator_create(
-                          resource_quota, "endpoint:server", channel_args));
-  p.server =
-      grpc_tcp_create(grpc_winsocket_create(sv[0], "endpoint:server"),
-                      channel_args, "endpoint:client",
-                      grpc_slice_allocator_create(
-                          resource_quota, "endpoint:client", channel_args));
-  grpc_resource_quota_unref_internal(resource_quota);
+  p.client = grpc_tcp_create(grpc_winsocket_create(sv[1], "endpoint:client"),
+                             channel_args, "endpoint:server");
+  p.server = grpc_tcp_create(grpc_winsocket_create(sv[0], "endpoint:server"),
+                             channel_args, "endpoint:client");
   return p;
 }
 

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

@@ -39,7 +39,6 @@ namespace {
 
 using ::grpc_event_engine::experimental::EventEngine;
 using ::grpc_event_engine::experimental::ResolvedAddressToURI;
-using ::grpc_event_engine::experimental::SliceAllocator;
 using ::grpc_event_engine::experimental::SliceBuffer;
 
 void endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
@@ -163,8 +162,8 @@ grpc_event_engine_endpoint* grpc_tcp_server_endpoint_create(
   return endpoint;
 }
 
-grpc_endpoint* grpc_tcp_create(const grpc_channel_args* channel_args,
-                               absl::string_view peer_address) {
+grpc_endpoint* grpc_tcp_create(const grpc_channel_args* /* channel_args */,
+                               absl::string_view /* peer_address */) {
   auto endpoint = new grpc_event_engine_endpoint;
   endpoint->base.vtable = &grpc_event_engine_endpoint_vtable;
   return &endpoint->base;

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

@@ -18,7 +18,6 @@
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/event_engine/iomgr.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_server.h"
@@ -38,25 +37,21 @@ grpc_core::DebugOnlyTraceFlag grpc_polling_trace(false, "polling");
 
 namespace {
 
-using ::grpc_event_engine::experimental::DefaultEventEngineFactory;
 using ::grpc_event_engine::experimental::EventEngine;
-
-EventEngine* g_event_engine = nullptr;
+using ::grpc_event_engine::experimental::GetDefaultEventEngine;
 
 // TODO(nnoble): Instantiate the default EventEngine if none have been provided.
-void iomgr_platform_init(void) { GPR_ASSERT(g_event_engine != nullptr); }
+void iomgr_platform_init(void) {}
 
 void iomgr_platform_flush(void) {}
 
-void iomgr_platform_shutdown(void) {
-  delete g_event_engine;
-  g_event_engine = nullptr;
-}
+void iomgr_platform_shutdown(void) {}
 
 void iomgr_platform_shutdown_background_closure(void) {}
 
 bool iomgr_platform_is_any_background_poller_thread(void) {
-  return g_event_engine->IsWorkerThread();
+  return grpc_event_engine::experimental::GetDefaultEventEngine()
+      ->IsWorkerThread();
 }
 
 bool iomgr_platform_add_closure_to_background_poller(
@@ -86,19 +81,4 @@ void grpc_set_default_iomgr_platform() {
 
 bool grpc_iomgr_run_in_background() { return false; }
 
-grpc_event_engine::experimental::EventEngine* grpc_iomgr_event_engine() {
-  return g_event_engine;
-}
-
-namespace grpc_core {
-
-void SetDefaultEventEngine(
-    std::unique_ptr<grpc_event_engine::experimental::EventEngine>
-        event_engine) {
-  GPR_ASSERT(g_event_engine == nullptr);
-  g_event_engine = event_engine.release();
-}
-
-}  // namespace grpc_core
-
 #endif  // GRPC_USE_EVENT_ENGINE