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

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

@@ -21,7 +21,6 @@
 #include "src/core/ext/transport/chttp2/server/chttp2_server.h"
 
 #include <inttypes.h>
-#include <limits.h>
 #include <string.h>
 
 #include <algorithm>
@@ -39,24 +38,22 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
+#include "absl/types/optional.h"
 
 #include <grpc/grpc.h>
 #include <grpc/grpc_posix.h>
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/time.h>
 
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -73,7 +70,6 @@
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
-#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/security/credentials/credentials.h"
@@ -86,6 +82,7 @@
 #include "src/core/lib/transport/handshaker.h"
 #include "src/core/lib/transport/handshaker_registry.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/lib/transport/transport_fwd.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 #ifdef GPR_SUPPORT_CHANNELS_FROM_FD
@@ -103,16 +100,16 @@ const char kUnixAbstractUriPrefix[] = "unix-abstract:";
 class Chttp2ServerListener : public Server::ListenerInterface {
  public:
   static grpc_error_handle Create(Server* server, grpc_resolved_address* addr,
-                                  grpc_channel_args* args,
+                                  const ChannelArgs& args,
                                   Chttp2ServerArgsModifier args_modifier,
                                   int* port_num);
 
   static grpc_error_handle CreateWithAcceptor(
-      Server* server, const char* name, grpc_channel_args* args,
+      Server* server, const char* name, const ChannelArgs& args,
       Chttp2ServerArgsModifier args_modifier);
 
   // Do not instantiate directly.  Use one of the factory methods above.
-  Chttp2ServerListener(Server* server, grpc_channel_args* args,
+  Chttp2ServerListener(Server* server, const ChannelArgs& args,
                        Chttp2ServerArgsModifier args_modifier);
   ~Chttp2ServerListener() override;
 
@@ -151,13 +148,13 @@ class Chttp2ServerListener : public Server::ListenerInterface {
       HandshakingState(RefCountedPtr<ActiveConnection> connection_ref,
                        grpc_pollset* accepting_pollset,
                        grpc_tcp_server_acceptor* acceptor,
-                       grpc_channel_args* args);
+                       const ChannelArgs& args);
 
       ~HandshakingState() override;
 
       void Orphan() override;
 
-      void Start(grpc_endpoint* endpoint, grpc_channel_args* args);
+      void Start(grpc_endpoint* endpoint, const ChannelArgs& args);
 
       // Needed to be able to grab an external ref in ActiveConnection::Start()
       using InternallyRefCounted<HandshakingState>::Ref;
@@ -181,7 +178,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
 
     ActiveConnection(grpc_pollset* accepting_pollset,
                      grpc_tcp_server_acceptor* acceptor,
-                     grpc_channel_args* args, MemoryOwner memory_owner);
+                     const ChannelArgs& args, MemoryOwner memory_owner);
     ~ActiveConnection() override;
 
     void Orphan() override;
@@ -189,7 +186,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
     void SendGoAway();
 
     void Start(RefCountedPtr<Chttp2ServerListener> listener,
-               grpc_endpoint* endpoint, grpc_channel_args* args);
+               grpc_endpoint* endpoint, const ChannelArgs& args);
 
     // Needed to be able to grab an external ref in
     // Chttp2ServerListener::OnAccept()
@@ -262,7 +259,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
   grpc_resolved_address resolved_address_;
   Chttp2ServerArgsModifier const args_modifier_;
   ConfigFetcherWatcher* config_fetcher_watcher_ = nullptr;
-  grpc_channel_args* args_;
+  ChannelArgs args_;
   Mutex mu_;
   RefCountedPtr<grpc_server_config_fetcher::ConnectionManager>
       connection_manager_ ABSL_GUARDED_BY(mu_);
@@ -325,7 +322,7 @@ void Chttp2ServerListener::ConfigFetcherWatcher::UpdateConnectionManager(
   int port_temp;
   grpc_error_handle error = grpc_tcp_server_add_port(
       listener_->tcp_server_, &listener_->resolved_address_, &port_temp);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     GRPC_ERROR_UNREF(error);
     gpr_log(GPR_ERROR, "Error adding port to server: %s",
             grpc_error_std_string(error).c_str());
@@ -359,17 +356,18 @@ void Chttp2ServerListener::ConfigFetcherWatcher::StopServing() {
 // Chttp2ServerListener::ActiveConnection::HandshakingState
 //
 
-Timestamp GetConnectionDeadline(const grpc_channel_args* args) {
-  auto timeout_ms = Duration::Milliseconds(
-      grpc_channel_args_find_integer(args, GRPC_ARG_SERVER_HANDSHAKE_TIMEOUT_MS,
-                                     {120 * GPR_MS_PER_SEC, 1, INT_MAX}));
-  return ExecCtx::Get()->Now() + timeout_ms;
+Timestamp GetConnectionDeadline(const ChannelArgs& args) {
+  return ExecCtx::Get()->Now() +
+         std::max(
+             Duration::Milliseconds(1),
+             args.GetDurationFromIntMillis(GRPC_ARG_SERVER_HANDSHAKE_TIMEOUT_MS)
+                 .value_or(Duration::Seconds(120)));
 }
 
 Chttp2ServerListener::ActiveConnection::HandshakingState::HandshakingState(
     RefCountedPtr<ActiveConnection> connection_ref,
     grpc_pollset* accepting_pollset, grpc_tcp_server_acceptor* acceptor,
-    grpc_channel_args* args)
+    const ChannelArgs& args)
     : connection_(std::move(connection_ref)),
       accepting_pollset_(accepting_pollset),
       acceptor_(acceptor),
@@ -399,7 +397,7 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::Orphan() {
 }
 
 void Chttp2ServerListener::ActiveConnection::HandshakingState::Start(
-    grpc_endpoint* endpoint, grpc_channel_args* args) {
+    grpc_endpoint* endpoint, const ChannelArgs& channel_args) {
   Ref().release();  // Held by OnHandshakeDone
   RefCountedPtr<HandshakeManager> handshake_mgr;
   {
@@ -407,7 +405,7 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::Start(
     if (handshake_mgr_ == nullptr) return;
     handshake_mgr = handshake_mgr_;
   }
-  handshake_mgr->DoHandshake(endpoint, args, deadline_, acceptor_,
+  handshake_mgr->DoHandshake(endpoint, channel_args, deadline_, acceptor_,
                              OnHandshakeDone, this);
 }
 
@@ -446,11 +444,11 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
   bool cleanup_connection = false;
   {
     MutexLock connection_lock(&self->connection_->mu_);
-    if (error != GRPC_ERROR_NONE || self->connection_->shutdown_) {
+    if (!GRPC_ERROR_IS_NONE(error) || 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;
-      if (error == GRPC_ERROR_NONE && args->endpoint != nullptr) {
+      if (GRPC_ERROR_IS_NONE(error) && args->endpoint != nullptr) {
         // We were shut down or stopped serving after handshaking completed
         // successfully, so destroy the endpoint here.
         // TODO(ctiller): It is currently necessary to shutdown endpoints
@@ -459,7 +457,6 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
         // point this can be removed.
         grpc_endpoint_shutdown(args->endpoint, GRPC_ERROR_NONE);
         grpc_endpoint_destroy(args->endpoint);
-        grpc_channel_args_destroy(args->args);
         grpc_slice_buffer_destroy_internal(args->read_buffer);
         gpr_free(args->read_buffer);
       }
@@ -474,7 +471,7 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
             self->connection_->listener_->server_->SetupTransport(
                 transport, self->accepting_pollset_, args->args,
                 grpc_chttp2_transport_get_socket_node(transport));
-        if (channel_init_err == GRPC_ERROR_NONE) {
+        if (GRPC_ERROR_IS_NONE(channel_init_err)) {
           // Use notify_on_receive_settings callback to enforce the
           // handshake deadline.
           // Note: The reinterpret_cast<>s here are safe, because
@@ -507,7 +504,6 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
           grpc_chttp2_transport_start_reading(transport, args->read_buffer,
                                               &self->on_receive_settings_,
                                               on_close);
-          grpc_channel_args_destroy(args->args);
           self->Ref().release();  // Held by OnTimeout().
           GRPC_CLOSURE_INIT(&self->on_timeout_, OnTimeout, self,
                             grpc_schedule_on_exec_ctx);
@@ -521,7 +517,6 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
           grpc_slice_buffer_destroy_internal(args->read_buffer);
           gpr_free(args->read_buffer);
           cleanup_connection = true;
-          grpc_channel_args_destroy(args->args);
         }
       } else {
         cleanup_connection = true;
@@ -555,7 +550,7 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
 
 Chttp2ServerListener::ActiveConnection::ActiveConnection(
     grpc_pollset* accepting_pollset, grpc_tcp_server_acceptor* acceptor,
-    grpc_channel_args* args, MemoryOwner memory_owner)
+    const ChannelArgs& args, MemoryOwner memory_owner)
     : handshaking_state_(memory_owner.MakeOrphanable<HandshakingState>(
           Ref(), accepting_pollset, acceptor, args)) {
   GRPC_CLOSURE_INIT(&on_close_, ActiveConnection::OnClose, this,
@@ -589,13 +584,16 @@ void Chttp2ServerListener::ActiveConnection::SendGoAway() {
       Ref().release();  // Ref held by OnDrainGraceTimeExpiry
       GRPC_CLOSURE_INIT(&on_drain_grace_time_expiry_, OnDrainGraceTimeExpiry,
                         this, nullptr);
-      grpc_timer_init(&drain_grace_timer_,
-                      ExecCtx::Get()->Now() +
-                          Duration::Milliseconds(grpc_channel_args_find_integer(
-                              listener_->args_,
-                              GRPC_ARG_SERVER_CONFIG_CHANGE_DRAIN_GRACE_TIME_MS,
-                              {10 * 60 * GPR_MS_PER_SEC, 0, INT_MAX})),
-                      &on_drain_grace_time_expiry_);
+      grpc_timer_init(
+          &drain_grace_timer_,
+          ExecCtx::Get()->Now() +
+              std::max(
+                  Duration::Zero(),
+                  listener_->args_
+                      .GetDurationFromIntMillis(
+                          GRPC_ARG_SERVER_CONFIG_CHANGE_DRAIN_GRACE_TIME_MS)
+                      .value_or(Duration::Minutes(10))),
+          &on_drain_grace_time_expiry_);
       drain_grace_timer_expiry_callback_pending_ = true;
       shutdown_ = true;
     }
@@ -610,7 +608,7 @@ void Chttp2ServerListener::ActiveConnection::SendGoAway() {
 
 void Chttp2ServerListener::ActiveConnection::Start(
     RefCountedPtr<Chttp2ServerListener> listener, grpc_endpoint* endpoint,
-    grpc_channel_args* args) {
+    const ChannelArgs& args) {
   RefCountedPtr<HandshakingState> handshaking_state_ref;
   listener_ = std::move(listener);
   {
@@ -653,7 +651,7 @@ void Chttp2ServerListener::ActiveConnection::OnDrainGraceTimeExpiry(
   ActiveConnection* self = static_cast<ActiveConnection*>(arg);
   // If the drain_grace_timer_ was not cancelled, disconnect the transport
   // immediately.
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     grpc_chttp2_transport* transport = nullptr;
     {
       MutexLock lock(&self->mu_);
@@ -672,7 +670,7 @@ void Chttp2ServerListener::ActiveConnection::OnDrainGraceTimeExpiry(
 //
 
 grpc_error_handle Chttp2ServerListener::Create(
-    Server* server, grpc_resolved_address* addr, grpc_channel_args* args,
+    Server* server, grpc_resolved_address* addr, const ChannelArgs& args,
     Chttp2ServerArgsModifier args_modifier, int* port_num) {
   Chttp2ServerListener* listener = nullptr;
   // The bulk of this method is inside of a lambda to make cleanup
@@ -682,19 +680,19 @@ grpc_error_handle Chttp2ServerListener::Create(
     // Create Chttp2ServerListener.
     listener = new Chttp2ServerListener(server, args, args_modifier);
     error = grpc_tcp_server_create(&listener->tcp_server_shutdown_complete_,
-                                   args, &listener->tcp_server_);
-    if (error != GRPC_ERROR_NONE) return error;
+                                   args.ToC().get(), &listener->tcp_server_);
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
     if (server->config_fetcher() != nullptr) {
       listener->resolved_address_ = *addr;
       // TODO(yashykt): Consider binding so as to be able to return the port
       // number.
     } else {
       error = grpc_tcp_server_add_port(listener->tcp_server_, addr, port_num);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!GRPC_ERROR_IS_NONE(error)) return error;
     }
     // Create channelz node.
-    if (grpc_channel_args_find_bool(args, GRPC_ARG_ENABLE_CHANNELZ,
-                                    GRPC_ENABLE_CHANNELZ_DEFAULT)) {
+    if (args.GetBool(GRPC_ARG_ENABLE_CHANNELZ)
+            .value_or(GRPC_ENABLE_CHANNELZ_DEFAULT)) {
       auto string_address = grpc_sockaddr_to_uri(addr);
       if (!string_address.ok()) {
         return GRPC_ERROR_CREATE_FROM_CPP_STRING(
@@ -709,7 +707,7 @@ grpc_error_handle Chttp2ServerListener::Create(
     server->AddListener(OrphanablePtr<Server::ListenerInterface>(listener));
     return GRPC_ERROR_NONE;
   }();
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     if (listener != nullptr) {
       if (listener->tcp_server_ != nullptr) {
         // listener is deleted when tcp_server_ is shutdown.
@@ -717,39 +715,37 @@ grpc_error_handle Chttp2ServerListener::Create(
       } else {
         delete listener;
       }
-    } else {
-      grpc_channel_args_destroy(args);
     }
   }
   return error;
 }
 
 grpc_error_handle Chttp2ServerListener::CreateWithAcceptor(
-    Server* server, const char* name, grpc_channel_args* args,
+    Server* server, const char* name, const ChannelArgs& args,
     Chttp2ServerArgsModifier args_modifier) {
   Chttp2ServerListener* listener =
       new Chttp2ServerListener(server, args, args_modifier);
-  grpc_error_handle error = grpc_tcp_server_create(
-      &listener->tcp_server_shutdown_complete_, args, &listener->tcp_server_);
-  if (error != GRPC_ERROR_NONE) {
+  grpc_error_handle error =
+      grpc_tcp_server_create(&listener->tcp_server_shutdown_complete_,
+                             args.ToC().get(), &listener->tcp_server_);
+  if (!GRPC_ERROR_IS_NONE(error)) {
     delete listener;
     return error;
   }
   // TODO(yangg) channelz
-  TcpServerFdHandler** arg_val =
-      grpc_channel_args_find_pointer<TcpServerFdHandler*>(args, name);
+  TcpServerFdHandler** arg_val = args.GetPointer<TcpServerFdHandler*>(name);
   *arg_val = grpc_tcp_server_create_fd_handler(listener->tcp_server_);
   server->AddListener(OrphanablePtr<Server::ListenerInterface>(listener));
   return GRPC_ERROR_NONE;
 }
 
 Chttp2ServerListener::Chttp2ServerListener(
-    Server* server, grpc_channel_args* args,
+    Server* server, const ChannelArgs& args,
     Chttp2ServerArgsModifier args_modifier)
     : server_(server),
       args_modifier_(args_modifier),
       args_(args),
-      memory_quota_(ResourceQuotaFromChannelArgs(args)->memory_quota()) {
+      memory_quota_(args.GetObject<ResourceQuota>()->memory_quota()) {
   GRPC_CLOSURE_INIT(&tcp_server_shutdown_complete_, TcpServerShutdownComplete,
                     this, grpc_schedule_on_exec_ctx);
 }
@@ -762,7 +758,6 @@ Chttp2ServerListener::~Chttp2ServerListener() {
     ExecCtx::Run(DEBUG_LOCATION, on_destroy_done_, GRPC_ERROR_NONE);
     ExecCtx::Get()->Flush();
   }
-  grpc_channel_args_destroy(args_);
 }
 
 /* Server callback: start listening on our ports */
@@ -797,8 +792,7 @@ void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
                                     grpc_pollset* accepting_pollset,
                                     grpc_tcp_server_acceptor* acceptor) {
   Chttp2ServerListener* self = static_cast<Chttp2ServerListener*>(arg);
-  grpc_channel_args* args = self->args_;
-  grpc_channel_args* args_to_destroy = nullptr;
+  ChannelArgs args = self->args_;
   RefCountedPtr<grpc_server_config_fetcher::ConnectionManager>
       connection_manager;
   {
@@ -817,11 +811,7 @@ void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
       endpoint_cleanup(error);
       return;
     }
-    // TODO(yashykt): Maybe combine the following two arg modifiers into a
-    // single one.
-    // Make a copy of the args so as to avoid destroying the original.
-    args = grpc_channel_args_copy(args);
-    absl::StatusOr<grpc_channel_args*> args_result =
+    absl::StatusOr<ChannelArgs> args_result =
         connection_manager->UpdateChannelArgsForConnection(args, tcp);
     if (!args_result.ok()) {
       gpr_log(GPR_DEBUG, "Closing connection: %s",
@@ -832,14 +822,12 @@ void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
     }
     grpc_error_handle error = GRPC_ERROR_NONE;
     args = self->args_modifier_(*args_result, &error);
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       gpr_log(GPR_DEBUG, "Closing connection: %s",
               grpc_error_std_string(error).c_str());
       endpoint_cleanup(error);
-      grpc_channel_args_destroy(args);
       return;
     }
-    args_to_destroy = args;
   }
   auto memory_owner = self->memory_quota_->CreateMemoryOwner(
       absl::StrCat(grpc_endpoint_get_peer(tcp), ":server_channel"));
@@ -871,7 +859,6 @@ void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
   } else {
     connection_ref->Start(std::move(listener_ref), tcp, args);
   }
-  grpc_channel_args_destroy(args_to_destroy);
 }
 
 void Chttp2ServerListener::TcpServerShutdownComplete(void* arg,
@@ -917,7 +904,7 @@ void Chttp2ServerListener::Orphan() {
 //
 
 grpc_error_handle Chttp2ServerAddPort(Server* server, const char* addr,
-                                      grpc_channel_args* args,
+                                      const ChannelArgs& args,
                                       Chttp2ServerArgsModifier args_modifier,
                                       int* port_num) {
   if (addr == nullptr) {
@@ -943,7 +930,8 @@ grpc_error_handle Chttp2ServerAddPort(Server* server, const char* addr,
       resolved_or =
           grpc_resolve_unix_abstract_domain_address(parsed_addr_unprefixed);
     } else {
-      resolved_or = GetDNSResolver()->ResolveNameBlocking(parsed_addr, "https");
+      resolved_or =
+          GetDNSResolver()->LookupHostnameBlocking(parsed_addr, "https");
     }
     if (!resolved_or.ok()) {
       return absl_status_to_grpc_error(resolved_or.status());
@@ -956,10 +944,9 @@ grpc_error_handle Chttp2ServerAddPort(Server* server, const char* addr,
         grpc_sockaddr_set_port(&addr, *port_num);
       }
       int port_temp = -1;
-      error = Chttp2ServerListener::Create(server, &addr,
-                                           grpc_channel_args_copy(args),
-                                           args_modifier, &port_temp);
-      if (error != GRPC_ERROR_NONE) {
+      error = Chttp2ServerListener::Create(server, &addr, args, args_modifier,
+                                           &port_temp);
+      if (!GRPC_ERROR_IS_NONE(error)) {
         error_list.push_back(error);
       } else {
         if (*port_num == -1) {
@@ -991,19 +978,15 @@ grpc_error_handle Chttp2ServerAddPort(Server* server, const char* addr,
   for (const grpc_error_handle& error : error_list) {
     GRPC_ERROR_UNREF(error);
   }
-  grpc_channel_args_destroy(args);
-  if (error != GRPC_ERROR_NONE) *port_num = 0;
+  if (!GRPC_ERROR_IS_NONE(error)) *port_num = 0;
   return error;
 }
 
-}  // namespace grpc_core
-
 namespace {
 
-grpc_channel_args* ModifyArgsForConnection(grpc_channel_args* args,
-                                           grpc_error_handle* error) {
-  grpc_server_credentials* server_credentials =
-      grpc_find_server_credentials_in_args(args);
+ChannelArgs ModifyArgsForConnection(const ChannelArgs& args,
+                                    grpc_error_handle* error) {
+  auto* server_credentials = args.GetObject<grpc_server_credentials>();
   if (server_credentials == nullptr) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Could not find server credentials");
@@ -1016,15 +999,11 @@ grpc_channel_args* ModifyArgsForConnection(grpc_channel_args* args,
                      server_credentials->type().name()));
     return args;
   }
-  grpc_arg arg_to_add =
-      grpc_security_connector_to_arg(security_connector.get());
-  grpc_channel_args* new_args =
-      grpc_channel_args_copy_and_add(args, &arg_to_add, 1);
-  grpc_channel_args_destroy(args);
-  return new_args;
+  return args.SetObject(security_connector);
 }
 
 }  // namespace
+}  // namespace grpc_core
 
 int grpc_server_add_http2_port(grpc_server* server, const char* addr,
                                grpc_server_credentials* creds) {
@@ -1032,8 +1011,8 @@ int grpc_server_add_http2_port(grpc_server* server, const char* addr,
   grpc_error_handle err = GRPC_ERROR_NONE;
   grpc_core::RefCountedPtr<grpc_server_security_connector> sc;
   int port_num = 0;
-  grpc_channel_args* args = nullptr;
   grpc_core::Server* core_server = grpc_core::Server::FromC(server);
+  grpc_core::ChannelArgs args = core_server->channel_args();
   GRPC_API_TRACE("grpc_server_add_http2_port(server=%p, addr=%s, creds=%p)", 3,
                  (server, addr, creds));
   // Create security context.
@@ -1054,29 +1033,23 @@ int grpc_server_add_http2_port(grpc_server* server, const char* addr,
   // fetchers need to be registered before adding ports to the server.
   if (core_server->config_fetcher() != nullptr) {
     // Create channel args.
-    grpc_arg arg_to_add = grpc_server_credentials_to_arg(creds);
-    args = grpc_channel_args_copy_and_add(core_server->channel_args(),
-                                          &arg_to_add, 1);
+    args = args.SetObject(creds->Ref());
   } else {
-    sc = creds->create_security_connector(nullptr);
+    sc = creds->create_security_connector(grpc_core::ChannelArgs());
     if (sc == nullptr) {
       err = GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
           "Unable to create secure server with credentials of type ",
           creds->type().name()));
       goto done;
     }
-    grpc_arg args_to_add[2];
-    args_to_add[0] = grpc_server_credentials_to_arg(creds);
-    args_to_add[1] = grpc_security_connector_to_arg(sc.get());
-    args = grpc_channel_args_copy_and_add(
-        core_server->channel_args(), args_to_add, GPR_ARRAY_SIZE(args_to_add));
+    args = args.SetObject(creds->Ref()).SetObject(sc);
   }
   // Add server port.
-  err = grpc_core::Chttp2ServerAddPort(core_server, addr, args,
-                                       ModifyArgsForConnection, &port_num);
+  err = grpc_core::Chttp2ServerAddPort(
+      core_server, addr, args, grpc_core::ModifyArgsForConnection, &port_num);
 done:
   sc.reset(DEBUG_LOCATION, "server");
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     gpr_log(GPR_ERROR, "%s", grpc_error_std_string(err).c_str());
 
     GRPC_ERROR_UNREF(err);
@@ -1096,18 +1069,18 @@ void grpc_server_add_channel_from_fd(grpc_server* server, int fd,
   grpc_core::ExecCtx exec_ctx;
   grpc_core::Server* core_server = grpc_core::Server::FromC(server);
 
-  const grpc_channel_args* server_args = core_server->channel_args();
+  grpc_core::ChannelArgs server_args = core_server->channel_args();
   std::string name = absl::StrCat("fd:", fd);
   auto memory_quota =
-      grpc_core::ResourceQuotaFromChannelArgs(server_args)->memory_quota();
+      server_args.GetObject<grpc_core::ResourceQuota>()->memory_quota();
   grpc_endpoint* server_endpoint = grpc_tcp_create(
-      grpc_fd_create(fd, name.c_str(), true), server_args, name);
+      grpc_fd_create(fd, name.c_str(), true), server_args.ToC().get(), name);
   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);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     for (grpc_pollset* pollset : core_server->pollsets()) {
       grpc_endpoint_add_to_pollset(server_endpoint, pollset);
     }

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

@@ -23,8 +23,7 @@
 
 #include <functional>
 
-#include <grpc/impl/codegen/grpc_types.h>
-
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/surface/server.h"
 
@@ -33,15 +32,14 @@ namespace grpc_core {
 // A function to modify channel args for a listening addr:port. Note that this
 // is used to create a security connector for listeners when the servers are
 // configured with a config fetcher. Not invoked if there is no config fetcher
-// added to the server. Takes ownership of the args.  Caller takes ownership of
-// returned args. On failure, the error parameter will be set.
+// added to the server. On failure, the error parameter will be set.
 using Chttp2ServerArgsModifier =
-    std::function<grpc_channel_args*(grpc_channel_args*, grpc_error_handle*)>;
+    std::function<ChannelArgs(const ChannelArgs&, grpc_error_handle*)>;
 
 /// Adds a port to \a server.  Sets \a port_num to the port number.
 /// Takes ownership of \a args.
 grpc_error_handle Chttp2ServerAddPort(
-    Server* server, const char* addr, grpc_channel_args* args,
+    Server* server, const char* addr, const ChannelArgs& args,
     Chttp2ServerArgsModifier connection_args_modifier, int* port_num);
 
 }  // namespace grpc_core