grpc 1.39.0.pre1 → 1.41.0.pre2

data/src/core/ext/transport/chttp2/alpn/alpn.cc

@@ -18,9 +18,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/log.h>
 #include "src/core/ext/transport/chttp2/alpn/alpn.h"
 
+#include <grpc/support/log.h>
+
 #include "src/core/lib/gpr/useful.h"
 
 /* in order of preference */

data/src/core/ext/transport/chttp2/client/chttp2_connector.cc

@@ -20,21 +20,20 @@
 
 #include "src/core/ext/transport/chttp2/client/chttp2_connector.h"
 
-#include <grpc/grpc.h>
-
 #include <string.h>
 
+#include <grpc/grpc.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/ext/filters/client_channel/connector.h"
-#include "src/core/ext/filters/client_channel/http_connect_handshaker.h"
 #include "src/core/ext/filters/client_channel/subchannel.h"
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/handshaker.h"
-#include "src/core/lib/channel/handshaker_registry.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/slice/slice_internal.h"
 
@@ -45,7 +44,12 @@ Chttp2Connector::Chttp2Connector() {
 }
 
 Chttp2Connector::~Chttp2Connector() {
-  if (endpoint_ != nullptr) grpc_endpoint_destroy(endpoint_);
+  if (resource_quota_ != nullptr) {
+    grpc_resource_quota_unref_internal(resource_quota_);
+  }
+  if (endpoint_ != nullptr) {
+    grpc_endpoint_destroy(endpoint_);
+  }
 }
 
 void Chttp2Connector::Connect(const Args& args, Result* result,
@@ -63,6 +67,11 @@ void Chttp2Connector::Connect(const Args& args, Result* result,
     connecting_ = true;
     GPR_ASSERT(endpoint_ == nullptr);
     ep = &endpoint_;
+    if (resource_quota_ != nullptr) {
+      grpc_resource_quota_unref_internal(resource_quota_);
+    }
+    resource_quota_ =
+        grpc_resource_quota_from_channel_args(args.channel_args, true);
   }
   // In some implementations, the closure can be flushed before
   // grpc_tcp_client_connect() returns, and since the closure requires access
@@ -71,8 +80,12 @@ void Chttp2Connector::Connect(const Args& args, Result* result,
   // grpc_tcp_client_connect() will fill endpoint_ with proper contents, and we
   // make sure that we still exist at that point by taking a ref.
   Ref().release();  // Ref held by callback.
-  grpc_tcp_client_connect(&connected_, ep, args.interested_parties,
-                          args.channel_args, &addr, args.deadline);
+  grpc_tcp_client_connect(
+      &connected_, ep,
+      grpc_slice_allocator_create(resource_quota_,
+                                  grpc_sockaddr_to_string(&addr, false),
+                                  args.channel_args),
+      args.interested_parties, args.channel_args, &addr, args.deadline);
 }
 
 void Chttp2Connector::Shutdown(grpc_error_handle error) {
@@ -120,9 +133,9 @@ void Chttp2Connector::Connected(void* arg, grpc_error_handle error) {
 
 void Chttp2Connector::StartHandshakeLocked() {
   handshake_mgr_ = MakeRefCounted<HandshakeManager>();
-  HandshakerRegistry::AddHandshakers(HANDSHAKER_CLIENT, args_.channel_args,
-                                     args_.interested_parties,
-                                     handshake_mgr_.get());
+  CoreConfiguration::Get().handshaker_registry().AddHandshakers(
+      HANDSHAKER_CLIENT, args_.channel_args, args_.interested_parties,
+      handshake_mgr_.get());
   grpc_endpoint_add_to_pollset_set(endpoint_, args_.interested_parties);
   handshake_mgr_->DoHandshake(endpoint_, args_.channel_args, args_.deadline,
                               nullptr /* acceptor */, OnHandshakeDone, this);
@@ -165,8 +178,12 @@ void Chttp2Connector::OnHandshakeDone(void* arg, grpc_error_handle error) {
       self->result_->Reset();
       NullThenSchedClosure(DEBUG_LOCATION, &self->notify_, error);
     } else if (args->endpoint != nullptr) {
-      self->result_->transport =
-          grpc_create_chttp2_transport(args->args, args->endpoint, true);
+      self->result_->transport = grpc_create_chttp2_transport(
+          args->args, args->endpoint, true,
+          grpc_resource_user_create(
+              self->resource_quota_,
+              absl::StrCat(grpc_endpoint_get_peer(args->endpoint),
+                           ":connector_transport")));
       self->result_->socket_node =
           grpc_chttp2_transport_get_socket_node(self->result_->transport);
       self->result_->channel_args = args->args;

data/src/core/ext/transport/chttp2/client/chttp2_connector.h

@@ -24,6 +24,7 @@
 #include "src/core/ext/filters/client_channel/connector.h"
 #include "src/core/lib/channel/handshaker.h"
 #include "src/core/lib/channel/handshaker_registry.h"
+#include "src/core/lib/iomgr/resource_quota.h"
 
 namespace grpc_core {
 
@@ -68,6 +69,7 @@ class Chttp2Connector : public SubchannelConnector {
   grpc_closure on_timeout_;
   absl::optional<grpc_error_handle> notify_error_;
   RefCountedPtr<HandshakeManager> handshake_mgr_;
+  grpc_resource_quota* resource_quota_ = nullptr;
 };
 
 }  // namespace grpc_core

data/src/core/ext/transport/chttp2/client/insecure/channel_create.cc

@@ -18,10 +18,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/grpc.h>
-
 #include <string.h>
 
+#include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
@@ -68,7 +67,7 @@ grpc_channel* CreateChannel(const char* target, const grpc_channel_args* args,
   grpc_channel_args* new_args =
       grpc_channel_args_copy_and_add_and_remove(args, to_remove, 1, &arg, 1);
   grpc_channel* channel = grpc_channel_create(
-      target, new_args, GRPC_CLIENT_CHANNEL, nullptr, nullptr, error);
+      target, new_args, GRPC_CLIENT_CHANNEL, nullptr, nullptr, 0, error);
   grpc_channel_args_destroy(new_args);
   return channel;
 }

data/src/core/ext/transport/chttp2/client/insecure/channel_create_posix.cc

@@ -49,17 +49,21 @@ grpc_channel* grpc_insecure_channel_create_from_fd(
 
   int flags = fcntl(fd, F_GETFL, 0);
   GPR_ASSERT(fcntl(fd, F_SETFL, flags | O_NONBLOCK) == 0);
-
+  grpc_resource_quota* resource_quota =
+      grpc_resource_quota_from_channel_args(args, true);
+  grpc_slice_allocator* allocator = grpc_slice_allocator_create(
+      resource_quota, "fd-client:endpoint", final_args);
   grpc_endpoint* client = grpc_tcp_client_create_from_fd(
-      grpc_fd_create(fd, "client", true), args, "fd-client");
-
-  grpc_transport* transport =
-      grpc_create_chttp2_transport(final_args, client, true);
+      grpc_fd_create(fd, "client", true), args, "fd-client", allocator);
+  grpc_transport* transport = grpc_create_chttp2_transport(
+      final_args, client, true,
+      grpc_resource_user_create(resource_quota, "fd-client:transport"));
+  grpc_resource_quota_unref_internal(resource_quota);
   GPR_ASSERT(transport);
   grpc_error_handle error = GRPC_ERROR_NONE;
   grpc_channel* channel =
       grpc_channel_create(target, final_args, GRPC_CLIENT_DIRECT_CHANNEL,
-                          transport, nullptr, &error);
+                          transport, nullptr, 0, &error);
   grpc_channel_args_destroy(final_args);
   if (channel != nullptr) {
     grpc_chttp2_transport_start_reading(transport, nullptr, nullptr, nullptr);

data/src/core/ext/transport/chttp2/client/secure/secure_channel_create.cc

@@ -18,10 +18,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/grpc.h>
-
 #include <string.h>
 
+#include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
@@ -146,7 +145,7 @@ grpc_channel* CreateChannel(const char* target, const grpc_channel_args* args,
   grpc_channel_args* new_args =
       grpc_channel_args_copy_and_add_and_remove(args, to_remove, 1, &arg, 1);
   grpc_channel* channel = grpc_channel_create(
-      target, new_args, GRPC_CLIENT_CHANNEL, nullptr, nullptr, error);
+      target, new_args, GRPC_CLIENT_CHANNEL, nullptr, nullptr, 0, error);
   grpc_channel_args_destroy(new_args);
   return channel;
 }

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -23,6 +23,7 @@
 #include <inttypes.h>
 #include <limits.h>
 #include <string.h>
+
 #include <vector>
 
 #include "absl/strings/match.h"
@@ -41,7 +42,7 @@
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/handshaker.h"
-#include "src/core/lib/channel/handshaker_registry.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/endpoint.h"
@@ -72,7 +73,8 @@ class Chttp2ServerListener : public Server::ListenerInterface {
 
   // Do not instantiate directly.  Use one of the factory methods above.
   Chttp2ServerListener(Server* server, grpc_channel_args* args,
-                       Chttp2ServerArgsModifier args_modifier);
+                       Chttp2ServerArgsModifier args_modifier,
+                       grpc_resource_quota* resource_quota);
   ~Chttp2ServerListener() override;
 
   void Start(Server* server,
@@ -110,7 +112,8 @@ class Chttp2ServerListener : public Server::ListenerInterface {
       HandshakingState(RefCountedPtr<ActiveConnection> connection_ref,
                        grpc_pollset* accepting_pollset,
                        grpc_tcp_server_acceptor* acceptor,
-                       grpc_channel_args* args);
+                       grpc_channel_args* args,
+                       grpc_resource_user* channel_resource_user);
 
       ~HandshakingState() override;
 
@@ -127,7 +130,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
       static void OnHandshakeDone(void* arg, grpc_error_handle error);
       RefCountedPtr<ActiveConnection> const connection_;
       grpc_pollset* const accepting_pollset_;
-      grpc_tcp_server_acceptor* const acceptor_;
+      grpc_tcp_server_acceptor* acceptor_;
       RefCountedPtr<HandshakeManager> handshake_mgr_
           ABSL_GUARDED_BY(&connection_->mu_);
       // State for enforcing handshake timeout on receiving HTTP/2 settings.
@@ -136,11 +139,13 @@ class Chttp2ServerListener : public Server::ListenerInterface {
       grpc_closure on_timeout_ ABSL_GUARDED_BY(&connection_->mu_);
       grpc_closure on_receive_settings_ ABSL_GUARDED_BY(&connection_->mu_);
       grpc_pollset_set* const interested_parties_;
+      grpc_resource_user* channel_resource_user_;
     };
 
     ActiveConnection(grpc_pollset* accepting_pollset,
                      grpc_tcp_server_acceptor* acceptor,
-                     grpc_channel_args* args);
+                     grpc_channel_args* args,
+                     grpc_resource_user* channel_resource_user);
     ~ActiveConnection() override;
 
     void Orphan() override;
@@ -234,6 +239,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
   grpc_closure tcp_server_shutdown_complete_ ABSL_GUARDED_BY(mu_);
   grpc_closure* on_destroy_done_ ABSL_GUARDED_BY(mu_) = nullptr;
   RefCountedPtr<channelz::ListenSocketNode> channelz_listen_socket_;
+  grpc_resource_quota* resource_quota_;
 };
 
 //
@@ -305,21 +311,26 @@ grpc_millis GetConnectionDeadline(const grpc_channel_args* args) {
 Chttp2ServerListener::ActiveConnection::HandshakingState::HandshakingState(
     RefCountedPtr<ActiveConnection> connection_ref,
     grpc_pollset* accepting_pollset, grpc_tcp_server_acceptor* acceptor,
-    grpc_channel_args* args)
+    grpc_channel_args* args, grpc_resource_user* channel_resource_user)
     : connection_(std::move(connection_ref)),
       accepting_pollset_(accepting_pollset),
       acceptor_(acceptor),
       handshake_mgr_(MakeRefCounted<HandshakeManager>()),
       deadline_(GetConnectionDeadline(args)),
-      interested_parties_(grpc_pollset_set_create()) {
+      interested_parties_(grpc_pollset_set_create()),
+      channel_resource_user_(channel_resource_user) {
   grpc_pollset_set_add_pollset(interested_parties_, accepting_pollset_);
-  HandshakerRegistry::AddHandshakers(HANDSHAKER_SERVER, args,
-                                     interested_parties_, handshake_mgr_.get());
+  CoreConfiguration::Get().handshaker_registry().AddHandshakers(
+      HANDSHAKER_SERVER, args, interested_parties_, handshake_mgr_.get());
 }
 
 Chttp2ServerListener::ActiveConnection::HandshakingState::~HandshakingState() {
   grpc_pollset_set_del_pollset(interested_parties_, accepting_pollset_);
   grpc_pollset_set_destroy(interested_parties_);
+  if (channel_resource_user_ != nullptr) {
+    grpc_resource_user_unref(channel_resource_user_);
+  }
+  gpr_free(acceptor_);
 }
 
 void Chttp2ServerListener::ActiveConnection::HandshakingState::Orphan() {
@@ -379,16 +390,12 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
   OrphanablePtr<HandshakingState> handshaking_state_ref;
   RefCountedPtr<HandshakeManager> handshake_mgr;
   bool cleanup_connection = false;
-  bool free_resource_quota = false;
-  grpc_resource_user* resource_user =
-      self->connection_->listener_->server_->default_resource_user();
   {
     MutexLock connection_lock(&self->connection_->mu_);
     if (error != GRPC_ERROR_NONE || self->connection_->shutdown_) {
       std::string error_str = grpc_error_std_string(error);
       gpr_log(GPR_DEBUG, "Handshaking failed: %s", error_str.c_str());
       cleanup_connection = true;
-      free_resource_quota = true;
       if (error == GRPC_ERROR_NONE && args->endpoint != nullptr) {
         // We were shut down or stopped serving after handshaking completed
         // successfully, so destroy the endpoint here.
@@ -408,12 +415,17 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
       // code, so we can just clean up here without creating a transport.
       if (args->endpoint != nullptr) {
         grpc_transport* transport = grpc_create_chttp2_transport(
-            args->args, args->endpoint, false, resource_user);
+            args->args, args->endpoint, false,
+            grpc_resource_user_create(
+                self->connection_->listener_->resource_quota_,
+                absl::StrCat(grpc_endpoint_get_peer(args->endpoint),
+                             ":chttp2_server_transport")));
         grpc_error_handle channel_init_err =
             self->connection_->listener_->server_->SetupTransport(
                 transport, self->accepting_pollset_, args->args,
                 grpc_chttp2_transport_get_socket_node(transport),
-                resource_user);
+                self->channel_resource_user_, GRPC_RESOURCE_QUOTA_CHANNEL_SIZE);
+        self->channel_resource_user_ = nullptr;
         if (channel_init_err == GRPC_ERROR_NONE) {
           // Use notify_on_receive_settings callback to enforce the
           // handshake deadline.
@@ -461,12 +473,10 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
           grpc_slice_buffer_destroy_internal(args->read_buffer);
           gpr_free(args->read_buffer);
           cleanup_connection = true;
-          free_resource_quota = true;
           grpc_channel_args_destroy(args->args);
         }
       } else {
         cleanup_connection = true;
-        free_resource_quota = true;
       }
     }
     // Since the handshake manager is done, the connection no longer needs to
@@ -477,9 +487,11 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
     handshaking_state_ref = std::move(self->connection_->handshaking_state_);
   }
   gpr_free(self->acceptor_);
+  self->acceptor_ = nullptr;
   OrphanablePtr<ActiveConnection> connection;
-  if (free_resource_quota && resource_user != nullptr) {
-    grpc_resource_user_free(resource_user, GRPC_RESOURCE_QUOTA_CHANNEL_SIZE);
+  if (self->channel_resource_user_ != nullptr) {
+    grpc_resource_user_free(self->channel_resource_user_,
+                            GRPC_RESOURCE_QUOTA_CHANNEL_SIZE);
   }
   if (cleanup_connection) {
     MutexLock listener_lock(&self->connection_->listener_->mu_);
@@ -499,9 +511,9 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
 
 Chttp2ServerListener::ActiveConnection::ActiveConnection(
     grpc_pollset* accepting_pollset, grpc_tcp_server_acceptor* acceptor,
-    grpc_channel_args* args)
+    grpc_channel_args* args, grpc_resource_user* channel_resource_user)
     : handshaking_state_(MakeOrphanable<HandshakingState>(
-          Ref(), accepting_pollset, acceptor, args)) {
+          Ref(), accepting_pollset, acceptor, args, channel_resource_user)) {
   GRPC_CLOSURE_INIT(&on_close_, ActiveConnection::OnClose, this,
                     grpc_schedule_on_exec_ctx);
 }
@@ -585,9 +597,14 @@ grpc_error_handle Chttp2ServerListener::Create(
   // easier without using goto.
   grpc_error_handle error = [&]() {
     // Create Chttp2ServerListener.
-    listener = new Chttp2ServerListener(server, args, args_modifier);
-    error = grpc_tcp_server_create(&listener->tcp_server_shutdown_complete_,
-                                   args, &listener->tcp_server_);
+    listener = new Chttp2ServerListener(
+        server, args, args_modifier,
+        grpc_resource_quota_from_channel_args(args, true));
+    grpc_resource_quota_ref_internal(listener->resource_quota_);
+    error = grpc_tcp_server_create(
+        &listener->tcp_server_shutdown_complete_, args,
+        grpc_slice_allocator_factory_create(listener->resource_quota_),
+        &listener->tcp_server_);
     if (error != GRPC_ERROR_NONE) return error;
     if (server->config_fetcher() != nullptr) {
       listener->resolved_address_ = *addr;
@@ -628,10 +645,14 @@ grpc_error_handle Chttp2ServerListener::Create(
 grpc_error_handle Chttp2ServerListener::CreateWithAcceptor(
     Server* server, const char* name, grpc_channel_args* args,
     Chttp2ServerArgsModifier args_modifier) {
-  Chttp2ServerListener* listener =
-      new Chttp2ServerListener(server, args, args_modifier);
+  Chttp2ServerListener* listener = new Chttp2ServerListener(
+      server, args, args_modifier,
+      grpc_resource_quota_from_channel_args(args, true));
+  grpc_resource_quota_ref_internal(listener->resource_quota_);
   grpc_error_handle error = grpc_tcp_server_create(
-      &listener->tcp_server_shutdown_complete_, args, &listener->tcp_server_);
+      &listener->tcp_server_shutdown_complete_, args,
+      grpc_slice_allocator_factory_create(listener->resource_quota_),
+      &listener->tcp_server_);
   if (error != GRPC_ERROR_NONE) {
     delete listener;
     return error;
@@ -646,8 +667,11 @@ grpc_error_handle Chttp2ServerListener::CreateWithAcceptor(
 
 Chttp2ServerListener::Chttp2ServerListener(
     Server* server, grpc_channel_args* args,
-    Chttp2ServerArgsModifier args_modifier)
-    : server_(server), args_modifier_(args_modifier), args_(args) {
+    Chttp2ServerArgsModifier args_modifier, grpc_resource_quota* resource_quota)
+    : server_(server),
+      args_modifier_(args_modifier),
+      args_(args),
+      resource_quota_(resource_quota) {
   GRPC_CLOSURE_INIT(&tcp_server_shutdown_complete_, TcpServerShutdownComplete,
                     this, grpc_schedule_on_exec_ctx);
 }
@@ -660,6 +684,7 @@ Chttp2ServerListener::~Chttp2ServerListener() {
     ExecCtx::Run(DEBUG_LOCATION, on_destroy_done_, GRPC_ERROR_NONE);
     ExecCtx::Get()->Flush();
   }
+  grpc_resource_quota_unref_internal(resource_quota_);
   grpc_channel_args_destroy(args_);
 }
 
@@ -728,8 +753,8 @@ void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
     if (!args_result.ok()) {
       gpr_log(GPR_DEBUG, "Closing connection: %s",
               args_result.status().ToString().c_str());
-      endpoint_cleanup(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          args_result.status().ToString().c_str()));
+      endpoint_cleanup(
+          GRPC_ERROR_CREATE_FROM_CPP_STRING(args_result.status().ToString()));
       return;
     }
     grpc_error_handle error = GRPC_ERROR_NONE;
@@ -742,8 +767,13 @@ void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
       return;
     }
   }
-  auto connection =
-      MakeOrphanable<ActiveConnection>(accepting_pollset, acceptor, args);
+  grpc_resource_user* channel_resource_user = grpc_resource_user_create(
+      self->resource_quota_,
+      absl::StrCat(grpc_endpoint_get_peer(tcp), ":server_channel"));
+  auto connection = MakeOrphanable<ActiveConnection>(
+      accepting_pollset, acceptor, args, channel_resource_user);
+  // We no longer own acceptor
+  acceptor = nullptr;
   // Hold a ref to connection to allow starting handshake outside the
   // critical region
   RefCountedPtr<ActiveConnection> connection_ref = connection->Ref();
@@ -752,13 +782,10 @@ void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
     MutexLock lock(&self->mu_);
     // Shutdown the the connection if listener's stopped serving.
     if (!self->shutdown_ && self->is_serving_) {
-      grpc_resource_user* resource_user =
-          self->server_->default_resource_user();
-      if (resource_user != nullptr &&
-          !grpc_resource_user_safe_alloc(resource_user,
+      if (!grpc_resource_user_safe_alloc(channel_resource_user,
                                          GRPC_RESOURCE_QUOTA_CHANNEL_SIZE)) {
         gpr_log(
-            GPR_ERROR,
+            GPR_INFO,
             "Memory quota exhausted, rejecting connection, no handshaking.");
       } else {
         // This ref needs to be taken in the critical region after having made

data/src/core/ext/transport/chttp2/server/insecure/server_chttp2.cc

@@ -19,7 +19,6 @@
 #include <grpc/support/port_platform.h>
 
 #include <grpc/grpc.h>
-
 #include <grpc/support/log.h>
 
 #include "src/core/ext/transport/chttp2/server/chttp2_server.h"

data/src/core/ext/transport/chttp2/server/insecure/server_chttp2_posix.cc

@@ -45,14 +45,20 @@ void grpc_server_add_insecure_channel_from_fd(grpc_server* server,
 
   const grpc_channel_args* server_args = core_server->channel_args();
   std::string name = absl::StrCat("fd:", fd);
+  grpc_resource_quota* resource_quota =
+      grpc_resource_quota_create(name.c_str());
   grpc_endpoint* server_endpoint = grpc_tcp_create(
-      grpc_fd_create(fd, name.c_str(), true), server_args, name.c_str());
-
+      grpc_fd_create(fd, name.c_str(), true), server_args, name.c_str(),
+      grpc_slice_allocator_create(resource_quota, name, server_args));
   grpc_transport* transport = grpc_create_chttp2_transport(
-      server_args, server_endpoint, false /* is_client */);
-
-  grpc_error_handle error =
-      core_server->SetupTransport(transport, nullptr, server_args, nullptr);
+      server_args, server_endpoint, false /* is_client */,
+      grpc_resource_user_create(resource_quota,
+                                absl::StrCat(name, ":transport")));
+  grpc_error_handle error = core_server->SetupTransport(
+      transport, nullptr, server_args, nullptr,
+      grpc_resource_user_create(resource_quota,
+                                absl::StrCat(name, ":channel")));
+  grpc_resource_quota_unref_internal(resource_quota);
   if (error == GRPC_ERROR_NONE) {
     for (grpc_pollset* pollset : core_server->pollsets()) {
       grpc_endpoint_add_to_pollset(server_endpoint, pollset);

data/src/core/ext/transport/chttp2/server/secure/server_secure_chttp2.cc

@@ -27,7 +27,6 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/transport/chttp2/server/chttp2_server.h"
-
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/handshaker.h"
@@ -50,10 +49,9 @@ grpc_channel_args* ModifyArgsForConnection(grpc_channel_args* args,
   }
   auto security_connector = server_credentials->create_security_connector(args);
   if (security_connector == nullptr) {
-    *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+    *error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
         absl::StrCat("Unable to create secure server with credentials of type ",
-                     server_credentials->type())
-            .c_str());
+                     server_credentials->type()));
     return args;
   }
   grpc_arg arg_to_add =
@@ -101,11 +99,9 @@ int grpc_server_add_secure_http2_port(grpc_server* server, const char* addr,
   } else {
     sc = creds->create_security_connector(nullptr);
     if (sc == nullptr) {
-      err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          absl::StrCat(
-              "Unable to create secure server with credentials of type ",
-              creds->type())
-              .c_str());
+      err = GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+          "Unable to create secure server with credentials of type ",
+          creds->type()));
       goto done;
     }
     grpc_arg args_to_add[2];

data/src/core/ext/transport/chttp2/transport/bin_decoder.cc

@@ -18,9 +18,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/ext/transport/chttp2/transport/bin_decoder.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include "src/core/ext/transport/chttp2/transport/bin_decoder.h"
+
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
@@ -146,7 +148,7 @@ bool grpc_base64_decode_partial(struct grpc_base64_decode_context* ctx) {
       switch (input_tail) {
         case 3:
           ctx->output_cur[1] = COMPOSE_OUTPUT_BYTE_1(ctx->input_cur);
-        /* fallthrough */
+          ABSL_FALLTHROUGH_INTENDED;
         case 2:
           ctx->output_cur[0] = COMPOSE_OUTPUT_BYTE_0(ctx->input_cur);
       }

data/src/core/ext/transport/chttp2/transport/bin_decoder.h

@@ -21,9 +21,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/slice.h>
 #include <stdbool.h>
 
+#include <grpc/slice.h>
+
 struct grpc_base64_decode_context {
   /* input/output: */
   const uint8_t* input_cur;

data/src/core/ext/transport/chttp2/transport/bin_encoder.cc

@@ -23,6 +23,7 @@
 #include <string.h>
 
 #include <grpc/support/log.h>
+
 #include "src/core/ext/transport/chttp2/transport/huffsyms.h"
 
 static const char alphabet[] =

data/src/core/ext/transport/chttp2/transport/chttp2_slice_allocator.cc

@@ -0,0 +1,67 @@
+// Copyright 2021 The 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/ext/transport/chttp2/transport/chttp2_slice_allocator.h"
+
+#include <functional>
+
+#include "absl/memory/memory.h"
+#include "absl/status/status.h"
+
+#include <grpc/event_engine/slice_allocator.h>
+
+#include "src/core/lib/iomgr/resource_quota.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+Chttp2SliceAllocator::Chttp2SliceAllocator(grpc_resource_user* user)
+    : resource_user_(user) {}
+
+Chttp2SliceAllocator::~Chttp2SliceAllocator() {
+  if (resource_user_ != nullptr) {
+    grpc_resource_user_unref(resource_user_);
+  }
+}
+
+absl::Status Chttp2SliceAllocator::Allocate(
+    size_t size, SliceBuffer* dest, SliceAllocator::AllocateCallback cb) {
+  // TODO(hork): merge the implementation from the uv-ee branch.
+  (void)size;
+  (void)dest;
+  (void)cb;
+  return absl::OkStatus();
+}
+
+Chttp2SliceAllocatorFactory::Chttp2SliceAllocatorFactory(
+    grpc_resource_quota* quota)
+    : resource_quota_(quota) {
+  grpc_resource_quota_ref_internal(resource_quota_);
+}
+
+Chttp2SliceAllocatorFactory::~Chttp2SliceAllocatorFactory() {
+  if (resource_quota_ != nullptr) {
+    grpc_resource_quota_unref_internal(resource_quota_);
+  }
+}
+
+std::unique_ptr<SliceAllocator>
+Chttp2SliceAllocatorFactory::CreateSliceAllocator(absl::string_view peer_name) {
+  return absl::make_unique<Chttp2SliceAllocator>(
+      grpc_resource_user_create(resource_quota_, peer_name));
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine