grpc 1.41.0 → 1.42.0

data/src/core/lib/surface/channel.h

@@ -82,21 +82,12 @@ void grpc_channel_update_call_size_estimate(grpc_channel* channel, size_t size);
 namespace grpc_core {
 
 struct RegisteredCall {
-  // The method and host are kept as part of this struct just to manage their
-  // lifetime since they must outlive the mdelem contents.
-  std::string method;
-  std::string host;
-
   grpc_mdelem path;
   grpc_mdelem authority;
 
   explicit RegisteredCall(const char* method_arg, const char* host_arg);
-  // TODO(vjpai): delete copy constructor once all supported compilers allow
-  //              std::map value_type to be MoveConstructible.
   RegisteredCall(const RegisteredCall& other);
-  RegisteredCall(RegisteredCall&& other) noexcept;
   RegisteredCall& operator=(const RegisteredCall&) = delete;
-  RegisteredCall& operator=(RegisteredCall&&) = delete;
 
   ~RegisteredCall();
 };

data/src/core/lib/surface/channel_init.cc

@@ -20,90 +20,37 @@
 
 #include "src/core/lib/surface/channel_init.h"
 
-#include <grpc/support/alloc.h>
+#include <algorithm>
 
-typedef struct stage_slot {
-  grpc_channel_init_stage fn;
-  void* arg;
-  int priority;
-  size_t insertion_order;
-} stage_slot;
+namespace grpc_core {
 
-typedef struct stage_slots {
-  stage_slot* slots;
-  size_t num_slots;
-  size_t cap_slots;
-} stage_slots;
-
-static stage_slots g_slots[GRPC_NUM_CHANNEL_STACK_TYPES];
-static bool g_finalized;
-
-void grpc_channel_init_init(void) {
-  for (int i = 0; i < GRPC_NUM_CHANNEL_STACK_TYPES; i++) {
-    g_slots[i].slots = nullptr;
-    g_slots[i].num_slots = 0;
-    g_slots[i].cap_slots = 0;
-  }
-  g_finalized = false;
-}
-
-void grpc_channel_init_register_stage(grpc_channel_stack_type type,
-                                      int priority,
-                                      grpc_channel_init_stage stage,
-                                      void* stage_arg) {
-  GPR_ASSERT(!g_finalized);
-  if (g_slots[type].cap_slots == g_slots[type].num_slots) {
-    g_slots[type].cap_slots = GPR_MAX(8, 3 * g_slots[type].cap_slots / 2);
-    g_slots[type].slots = static_cast<stage_slot*>(
-        gpr_realloc(g_slots[type].slots,
-                    g_slots[type].cap_slots * sizeof(*g_slots[type].slots)));
-  }
-  stage_slot* s = &g_slots[type].slots[g_slots[type].num_slots++];
-  s->insertion_order = g_slots[type].num_slots;
-  s->priority = priority;
-  s->fn = stage;
-  s->arg = stage_arg;
-}
-
-static int compare_slots(const void* a, const void* b) {
-  const stage_slot* sa = static_cast<const stage_slot*>(a);
-  const stage_slot* sb = static_cast<const stage_slot*>(b);
-
-  int c = GPR_ICMP(sa->priority, sb->priority);
-  if (c != 0) return c;
-  return GPR_ICMP(sa->insertion_order, sb->insertion_order);
+void ChannelInit::Builder::RegisterStage(grpc_channel_stack_type type,
+                                         int priority, Stage stage) {
+  slots_[type].emplace_back(std::move(stage), priority);
 }
 
-void grpc_channel_init_finalize(void) {
-  GPR_ASSERT(!g_finalized);
+ChannelInit ChannelInit::Builder::Build() {
+  ChannelInit result;
   for (int i = 0; i < GRPC_NUM_CHANNEL_STACK_TYPES; i++) {
-    qsort(g_slots[i].slots, g_slots[i].num_slots, sizeof(*g_slots[i].slots),
-          compare_slots);
-  }
-  g_finalized = true;
-}
-
-void grpc_channel_init_shutdown(void) {
-  for (int i = 0; i < GRPC_NUM_CHANNEL_STACK_TYPES; i++) {
-    gpr_free(g_slots[i].slots);
-    g_slots[i].slots =
-        static_cast<stage_slot*>(reinterpret_cast<void*>(0xdeadbeef));
+    auto& slots = slots_[i];
+    std::stable_sort(
+        slots.begin(), slots.end(),
+        [](const Slot& a, const Slot& b) { return a.priority < b.priority; });
+    auto& result_slots = result.slots_[i];
+    result_slots.reserve(slots.size());
+    for (auto& slot : slots) {
+      result_slots.emplace_back(std::move(slot.stage));
+    }
   }
+  return result;
 }
 
-bool grpc_channel_init_create_stack(grpc_channel_stack_builder* builder,
-                                    grpc_channel_stack_type type) {
-  GPR_ASSERT(g_finalized);
-
-  grpc_channel_stack_builder_set_name(builder,
-                                      grpc_channel_stack_type_string(type));
-
-  for (size_t i = 0; i < g_slots[type].num_slots; i++) {
-    const stage_slot* slot = &g_slots[type].slots[i];
-    if (!slot->fn(builder, slot->arg)) {
-      return false;
-    }
+bool ChannelInit::CreateStack(grpc_channel_stack_builder* builder,
+                              grpc_channel_stack_type type) const {
+  for (const auto& stage : slots_[type]) {
+    if (!stage(builder)) return false;
   }
-
   return true;
 }
+
+}  // namespace grpc_core

data/src/core/lib/surface/channel_init.h

@@ -21,9 +21,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/channel/channel_stack_builder.h"
+#include <functional>
+#include <vector>
+
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/transport.h"
 
 #define GRPC_CHANNEL_INIT_BUILTIN_PRIORITY 10000
 
@@ -32,47 +33,54 @@
 /// It also provides a universal entry path to run those mutators to build
 /// a channel stack for various subsystems.
 
-/// One stage of mutation: call functions against \a builder to influence the
-/// finally constructed channel stack
-typedef bool (*grpc_channel_init_stage)(grpc_channel_stack_builder* builder,
-                                        void* arg);
-
-/// Global initialization of the system
-void grpc_channel_init_init(void);
-
-/// Register one stage of mutators.
-/// Stages are run in priority order (lowest to highest), and then in
-/// registration order (in the case of a tie).
-/// Stages are registered against one of the pre-determined channel stack
-/// types.
-/// If the channel stack type is GRPC_CLIENT_SUBCHANNEL, the caller should
-/// ensure that subchannels with different filter lists will always have
-/// different channel args. This requires setting a channel arg in case the
-/// registration function relies on some condition other than channel args to
-/// decide whether to add a filter or not.
-void grpc_channel_init_register_stage(grpc_channel_stack_type type,
-                                      int priority,
-                                      grpc_channel_init_stage stage_fn,
-                                      void* stage_arg);
-
-/// Finalize registration. No more calls to grpc_channel_init_register_stage are
-/// allowed.
-void grpc_channel_init_finalize(void);
-/// Shutdown the channel init system
-void grpc_channel_init_shutdown(void);
-
-/// Construct a channel stack of some sort: see channel_stack.h for details
-/// \a type is the type of channel stack to create
-/// \a prefix_bytes is the number of bytes before the channel stack to allocate
-/// \a args are configuration arguments for the channel stack
-/// \a initial_refs is the initial refcount to give the channel stack
-/// \a destroy and \a destroy_arg specify how to destroy the channel stack
-///    if destroy_arg is NULL, the returned value from this function will be
-///    substituted
-/// \a optional_transport is either NULL or a constructed transport object
-/// Returns a pointer to the base of the memory allocated (the actual channel
-/// stack object will be prefix_bytes past that pointer)
-bool grpc_channel_init_create_stack(grpc_channel_stack_builder* builder,
-                                    grpc_channel_stack_type type);
+typedef struct grpc_channel_stack_builder grpc_channel_stack_builder;
+
+namespace grpc_core {
+
+class ChannelInit {
+ public:
+  /// One stage of mutation: call functions against \a builder to influence the
+  /// finally constructed channel stack
+  using Stage = std::function<bool(grpc_channel_stack_builder* builder)>;
+
+  class Builder {
+   public:
+    /// Register one stage of mutators.
+    /// Stages are run in priority order (lowest to highest), and then in
+    /// registration order (in the case of a tie).
+    /// Stages are registered against one of the pre-determined channel stack
+    /// types.
+    /// If the channel stack type is GRPC_CLIENT_SUBCHANNEL, the caller should
+    /// ensure that subchannels with different filter lists will always have
+    /// different channel args. This requires setting a channel arg in case the
+    /// registration function relies on some condition other than channel args
+    /// to decide whether to add a filter or not.
+    void RegisterStage(grpc_channel_stack_type type, int priority, Stage stage);
+
+    /// Finalize registration. No more calls to grpc_channel_init_register_stage
+    /// are allowed.
+    ChannelInit Build();
+
+   private:
+    struct Slot {
+      Slot(Stage stage, int priority)
+          : stage(std::move(stage)), priority(priority) {}
+      Stage stage;
+      int priority;
+    };
+    std::vector<Slot> slots_[GRPC_NUM_CHANNEL_STACK_TYPES];
+  };
+
+  /// Construct a channel stack of some sort: see channel_stack.h for details
+  /// \a type is the type of channel stack to create
+  /// \a builder is the channel stack builder to build into.
+  bool CreateStack(grpc_channel_stack_builder* builder,
+                   grpc_channel_stack_type type) const;
+
+ private:
+  std::vector<Stage> slots_[GRPC_NUM_CHANNEL_STACK_TYPES];
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_SURFACE_CHANNEL_INIT_H */

data/src/core/lib/surface/completion_queue.cc

@@ -628,8 +628,8 @@ static void cq_check_tag(grpc_completion_queue* cq, void* tag, bool lock_cq) {
   for (int i = 0; i < static_cast<int>(cq->outstanding_tag_count); i++) {
     if (cq->outstanding_tags[i] == tag) {
       cq->outstanding_tag_count--;
-      GPR_SWAP(void*, cq->outstanding_tags[i],
-               cq->outstanding_tags[cq->outstanding_tag_count]);
+      std::swap(cq->outstanding_tags[i],
+                cq->outstanding_tags[cq->outstanding_tag_count]);
       found = 1;
       break;
     }
@@ -665,7 +665,8 @@ bool grpc_cq_begin_op(grpc_completion_queue* cq, void* tag) {
 #ifndef NDEBUG
   gpr_mu_lock(cq->mu);
   if (cq->outstanding_tag_count == cq->outstanding_tag_capacity) {
-    cq->outstanding_tag_capacity = GPR_MAX(4, 2 * cq->outstanding_tag_capacity);
+    cq->outstanding_tag_capacity =
+        std::max(size_t(4), 2 * cq->outstanding_tag_capacity);
     cq->outstanding_tags = static_cast<void**>(gpr_realloc(
         cq->outstanding_tags,
         sizeof(*cq->outstanding_tags) * cq->outstanding_tag_capacity));
@@ -1066,7 +1067,7 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
   if (cqd->queue.num_items() > 0 &&
       cqd->pending_events.load(std::memory_order_acquire) > 0) {
     gpr_mu_lock(cq->mu);
-    cq->poller_vtable->kick(POLLSET_FROM_CQ(cq), nullptr);
+    (void)cq->poller_vtable->kick(POLLSET_FROM_CQ(cq), nullptr);
     gpr_mu_unlock(cq->mu);
   }
 
@@ -1143,7 +1144,7 @@ static void del_plucker(grpc_completion_queue* cq, void* tag,
   for (int i = 0; i < cqd->num_pluckers; i++) {
     if (cqd->pluckers[i].tag == tag && cqd->pluckers[i].worker == worker) {
       cqd->num_pluckers--;
-      GPR_SWAP(plucker, cqd->pluckers[i], cqd->pluckers[cqd->num_pluckers]);
+      std::swap(cqd->pluckers[i], cqd->pluckers[cqd->num_pluckers]);
       return;
     }
   }

data/src/core/lib/surface/init.cc

@@ -48,7 +48,6 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/call.h"
-#include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/surface/lame_client.h"
 #include "src/core/lib/surface/server.h"
@@ -77,34 +76,6 @@ static void do_basic_init(void) {
   gpr_time_init();
 }
 
-static bool append_filter(grpc_channel_stack_builder* builder, void* arg) {
-  return grpc_channel_stack_builder_append_filter(
-      builder, static_cast<const grpc_channel_filter*>(arg), nullptr, nullptr);
-}
-
-static bool prepend_filter(grpc_channel_stack_builder* builder, void* arg) {
-  return grpc_channel_stack_builder_prepend_filter(
-      builder, static_cast<const grpc_channel_filter*>(arg), nullptr, nullptr);
-}
-
-static void register_builtin_channel_init() {
-  grpc_channel_init_register_stage(GRPC_CLIENT_SUBCHANNEL,
-                                   GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-                                   grpc_add_connected_filter, nullptr);
-  grpc_channel_init_register_stage(GRPC_CLIENT_DIRECT_CHANNEL,
-                                   GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-                                   grpc_add_connected_filter, nullptr);
-  grpc_channel_init_register_stage(GRPC_SERVER_CHANNEL,
-                                   GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-                                   grpc_add_connected_filter, nullptr);
-  grpc_channel_init_register_stage(
-      GRPC_CLIENT_LAME_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      append_filter, const_cast<grpc_channel_filter*>(&grpc_lame_filter));
-  grpc_channel_init_register_stage(
-      GRPC_SERVER_CHANNEL, INT_MAX, prepend_filter,
-      const_cast<grpc_channel_filter*>(&grpc_core::Server::kServerTopFilter));
-}
-
 typedef struct grpc_plugin {
   void (*init)();
   void (*destroy)();
@@ -134,10 +105,8 @@ void grpc_init(void) {
     grpc_core::Fork::GlobalInit();
     grpc_fork_handlers_auto_register();
     grpc_stats_init();
-    grpc_init_static_metadata_ctx();
     grpc_slice_intern_init();
     grpc_mdctx_global_init();
-    grpc_channel_init_init();
     grpc_core::channelz::ChannelzRegistry::Init();
     grpc_security_pre_init();
     grpc_core::ApplicationCallbackExecCtx::GlobalInit();
@@ -149,13 +118,7 @@ void grpc_init(void) {
         g_all_of_the_plugins[i].init();
       }
     }
-    /* register channel finalization AFTER all plugins, to ensure that it's run
-     * at the appropriate time */
-    grpc_register_security_filters();
-    register_builtin_channel_init();
     grpc_tracer_init();
-    /* no more changes to channel init pipelines */
-    grpc_channel_init_finalize();
     grpc_iomgr_start();
   }
 
@@ -189,8 +152,6 @@ void grpc_shutdown_internal_locked(void)
   grpc_core::ApplicationCallbackExecCtx::GlobalShutdown();
   g_shutting_down = false;
   g_shutting_down_cv->SignalAll();
-  // Absolute last action will be to delete static metadata context.
-  grpc_destroy_static_metadata_ctx();
 }
 
 void grpc_shutdown_internal(void* /*ignored*/) {

data/src/core/lib/surface/init_secure.cc

@@ -21,6 +21,8 @@
 #include <limits.h>
 #include <string.h>
 
+#include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/security/authorization/sdk_server_authz_filter.h"
 #include "src/core/lib/security/context/security_context.h"
@@ -30,14 +32,13 @@
 #include "src/core/lib/security/transport/auth_filters.h"
 #include "src/core/lib/security/transport/secure_endpoint.h"
 #include "src/core/lib/security/transport/security_handshaker.h"
-#include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/init.h"
 #include "src/core/tsi/transport_security_interface.h"
 
 void grpc_security_pre_init(void) {}
 
 static bool maybe_prepend_client_auth_filter(
-    grpc_channel_stack_builder* builder, void* /*arg*/) {
+    grpc_channel_stack_builder* builder) {
   const grpc_channel_args* args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
   if (args) {
@@ -52,7 +53,7 @@ static bool maybe_prepend_client_auth_filter(
 }
 
 static bool maybe_prepend_server_auth_filter(
-    grpc_channel_stack_builder* builder, void* /*arg*/) {
+    grpc_channel_stack_builder* builder) {
   const grpc_channel_args* args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
   if (args) {
@@ -67,7 +68,7 @@ static bool maybe_prepend_server_auth_filter(
 }
 
 static bool maybe_prepend_sdk_server_authz_filter(
-    grpc_channel_stack_builder* builder, void* /*arg*/) {
+    grpc_channel_stack_builder* builder) {
   const grpc_channel_args* args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
   const auto* provider =
@@ -81,20 +82,22 @@ static bool maybe_prepend_sdk_server_authz_filter(
   return true;
 }
 
-void grpc_register_security_filters(void) {
+namespace grpc_core {
+void RegisterSecurityFilters(CoreConfiguration::Builder* builder) {
   // Register the auth client with a priority < INT_MAX to allow the authority
   // filter -on which the auth filter depends- to be higher on the channel
   // stack.
-  grpc_channel_init_register_stage(GRPC_CLIENT_SUBCHANNEL, INT_MAX - 1,
-                                   maybe_prepend_client_auth_filter, nullptr);
-  grpc_channel_init_register_stage(GRPC_CLIENT_DIRECT_CHANNEL, INT_MAX - 1,
-                                   maybe_prepend_client_auth_filter, nullptr);
-  grpc_channel_init_register_stage(GRPC_SERVER_CHANNEL, INT_MAX - 1,
-                                   maybe_prepend_server_auth_filter, nullptr);
+  builder->channel_init()->RegisterStage(GRPC_CLIENT_SUBCHANNEL, INT_MAX - 1,
+                                         maybe_prepend_client_auth_filter);
+  builder->channel_init()->RegisterStage(GRPC_CLIENT_DIRECT_CHANNEL,
+                                         INT_MAX - 1,
+                                         maybe_prepend_client_auth_filter);
+  builder->channel_init()->RegisterStage(GRPC_SERVER_CHANNEL, INT_MAX - 1,
+                                         maybe_prepend_server_auth_filter);
   // Register the SdkServerAuthzFilter with a priority less than
   // server_auth_filter to allow server_auth_filter on which the sdk filter
   // depends on to be higher on the channel stack.
-  grpc_channel_init_register_stage(GRPC_SERVER_CHANNEL, INT_MAX - 2,
-                                   maybe_prepend_sdk_server_authz_filter,
-                                   nullptr);
+  builder->channel_init()->RegisterStage(GRPC_SERVER_CHANNEL, INT_MAX - 2,
+                                         maybe_prepend_sdk_server_authz_filter);
 }
+}  // namespace grpc_core

data/src/core/lib/surface/lame_client.cc

@@ -45,9 +45,9 @@ namespace {
 struct ChannelData {
   explicit ChannelData(grpc_channel_element_args* args)
       : state_tracker("lame_channel", GRPC_CHANNEL_SHUTDOWN) {
-    grpc_error_handle err = grpc_channel_args_find_pointer<grpc_error>(
+    grpc_error_handle* err = grpc_channel_args_find_pointer<grpc_error_handle>(
         args->channel_args, GRPC_ARG_LAME_FILTER_ERROR);
-    if (err != nullptr) error = GRPC_ERROR_REF(err);
+    if (err != nullptr) error = GRPC_ERROR_REF(*err);
   }
 
   ~ChannelData() { GRPC_ERROR_UNREF(error); }
@@ -125,20 +125,28 @@ static void lame_destroy_channel_elem(grpc_channel_element* elem) {
 
 // Channel arg vtable for a grpc_error_handle.
 void* ErrorCopy(void* p) {
-  grpc_error_handle error = static_cast<grpc_error_handle>(p);
-  return GRPC_ERROR_REF(error);
+  grpc_error_handle* new_error = nullptr;
+  if (p != nullptr) {
+    grpc_error_handle* error = static_cast<grpc_error_handle*>(p);
+    new_error = new grpc_error_handle();
+    *new_error = GRPC_ERROR_REF(*error);
+  }
+  return new_error;
 }
 void ErrorDestroy(void* p) {
-  grpc_error_handle error = static_cast<grpc_error_handle>(p);
-  GRPC_ERROR_UNREF(error);
+  if (p != nullptr) {
+    grpc_error_handle* error = static_cast<grpc_error_handle*>(p);
+    GRPC_ERROR_UNREF(*error);
+    delete error;
+  }
 }
-int ErrorCompare(void* p, void* q) { return GPR_ICMP(p, q); }
+int ErrorCompare(void* p, void* q) { return grpc_core::QsortCompare(p, q); }
 const grpc_arg_pointer_vtable kLameFilterErrorArgVtable = {
     ErrorCopy, ErrorDestroy, ErrorCompare};
 
 }  // namespace
 
-grpc_arg MakeLameClientErrorArg(grpc_error_handle error) {
+grpc_arg MakeLameClientErrorArg(grpc_error_handle* error) {
   return grpc_channel_arg_pointer_create(
       const_cast<char*>(GRPC_ARG_LAME_FILTER_ERROR), error,
       &kLameFilterErrorArgVtable);
@@ -174,9 +182,8 @@ grpc_channel* grpc_lame_client_channel_create(const char* target,
       grpc_error_set_int(
           GRPC_ERROR_CREATE_FROM_STATIC_STRING("lame client channel"),
           GRPC_ERROR_INT_GRPC_STATUS, error_code),
-      GRPC_ERROR_STR_GRPC_MESSAGE,
-      grpc_slice_from_static_string(error_message));
-  grpc_arg error_arg = grpc_core::MakeLameClientErrorArg(error);
+      GRPC_ERROR_STR_GRPC_MESSAGE, error_message);
+  grpc_arg error_arg = grpc_core::MakeLameClientErrorArg(&error);
   grpc_channel_args args = {1, &error_arg};
   grpc_channel* channel = grpc_channel_create(
       target, &args, GRPC_CLIENT_LAME_CHANNEL, nullptr, nullptr, 0, nullptr);

data/src/core/lib/surface/lame_client.h

@@ -25,7 +25,7 @@
 
 namespace grpc_core {
 // Does NOT take ownership of error.
-grpc_arg MakeLameClientErrorArg(grpc_error_handle error);
+grpc_arg MakeLameClientErrorArg(grpc_error_handle* error);
 }  // namespace grpc_core
 
 extern const grpc_channel_filter grpc_lame_filter;

data/src/core/lib/surface/server.cc

@@ -794,6 +794,7 @@ void DonePublishedShutdown(void* /*done_arg*/, grpc_cq_completion* storage) {
 //       connection is NOT closed until the server is done with all those calls.
 //    -- Once there are no more calls in progress, the channel is closed.
 void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
+  absl::Notification* await_requests = nullptr;
   ChannelBroadcaster broadcaster;
   {
     // Wait for startup to be finished.  Locks mu_global.
@@ -820,7 +821,12 @@ void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
       KillPendingWorkLocked(
           GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
     }
-    ShutdownUnrefOnShutdownCall();
+    await_requests = ShutdownUnrefOnShutdownCall();
+  }
+  // We expect no new requests but there can still be requests in-flight.
+  // Wait for them to complete before proceeding.
+  if (await_requests != nullptr) {
+    await_requests->WaitForNotification();
   }
   // Shutdown listeners.
   for (auto& listener : listeners_) {
@@ -1248,7 +1254,7 @@ void Server::CallData::Publish(size_t cq_idx, RequestedCall* rc) {
   grpc_call_set_completion_queue(call_, rc->cq_bound_to_call);
   *rc->call = call_;
   cq_new_ = server_->cqs_[cq_idx];
-  GPR_SWAP(grpc_metadata_array, *rc->initial_metadata, initial_metadata_);
+  std::swap(*rc->initial_metadata, initial_metadata_);
   switch (rc->type) {
     case RequestedCall::Type::BATCH_CALL:
       GPR_ASSERT(host_.has_value());
@@ -1379,24 +1385,24 @@ void Server::CallData::RecvInitialMetadataReady(void* arg,
                                                 grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   CallData* calld = static_cast<CallData*>(elem->call_data);
-  grpc_millis op_deadline;
   if (error == GRPC_ERROR_NONE) {
-    GPR_DEBUG_ASSERT(calld->recv_initial_metadata_->idx.named.path != nullptr);
-    GPR_DEBUG_ASSERT(calld->recv_initial_metadata_->idx.named.authority !=
-                     nullptr);
-    calld->path_.emplace(grpc_slice_ref_internal(
-        GRPC_MDVALUE(calld->recv_initial_metadata_->idx.named.path->md)));
-    calld->host_.emplace(grpc_slice_ref_internal(
-        GRPC_MDVALUE(calld->recv_initial_metadata_->idx.named.authority->md)));
-    grpc_metadata_batch_remove(calld->recv_initial_metadata_, GRPC_BATCH_PATH);
-    grpc_metadata_batch_remove(calld->recv_initial_metadata_,
-                               GRPC_BATCH_AUTHORITY);
+    GPR_DEBUG_ASSERT(
+        calld->recv_initial_metadata_->legacy_index()->named.path != nullptr);
+    GPR_DEBUG_ASSERT(
+        calld->recv_initial_metadata_->legacy_index()->named.authority !=
+        nullptr);
+    calld->path_.emplace(grpc_slice_ref_internal(GRPC_MDVALUE(
+        calld->recv_initial_metadata_->legacy_index()->named.path->md)));
+    calld->host_.emplace(grpc_slice_ref_internal(GRPC_MDVALUE(
+        calld->recv_initial_metadata_->legacy_index()->named.authority->md)));
+    calld->recv_initial_metadata_->Remove(GRPC_BATCH_PATH);
+    calld->recv_initial_metadata_->Remove(GRPC_BATCH_AUTHORITY);
   } else {
-    GRPC_ERROR_REF(error);
+    (void)GRPC_ERROR_REF(error);
   }
-  op_deadline = calld->recv_initial_metadata_->deadline;
-  if (op_deadline != GRPC_MILLIS_INF_FUTURE) {
-    calld->deadline_ = op_deadline;
+  auto op_deadline = calld->recv_initial_metadata_->get(GrpcTimeoutMetadata());
+  if (op_deadline.has_value()) {
+    calld->deadline_ = *op_deadline;
   }
   if (calld->host_.has_value() && calld->path_.has_value()) {
     /* do nothing */
@@ -1469,9 +1475,11 @@ void Server::CallData::StartTransportStreamOpBatch(
 
 grpc_server* grpc_server_create(const grpc_channel_args* args, void* reserved) {
   grpc_core::ExecCtx exec_ctx;
+  args = grpc_channel_args_remove_grpc_internal(args);
   GRPC_API_TRACE("grpc_server_create(%p, %p)", 2, (args, reserved));
   grpc_server* c_server = new grpc_server;
   c_server->core_server = grpc_core::MakeOrphanable<grpc_core::Server>(args);
+  grpc_channel_args_destroy(args);
   return c_server;
 }