grpc 1.44.0.pre2 → 1.46.3

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

@@ -49,7 +49,7 @@ typedef struct grpc_call_create_args {
   absl::optional<grpc_core::Slice> path;
   absl::optional<grpc_core::Slice> authority;
 
-  grpc_millis send_deadline;
+  grpc_core::Timestamp send_deadline;
 } grpc_call_create_args;
 
 /* Create a new call based on \a args.
@@ -60,20 +60,6 @@ grpc_error_handle grpc_call_create(grpc_call_create_args* args,
 
 void grpc_call_set_completion_queue(grpc_call* call, grpc_completion_queue* cq);
 
-#ifndef NDEBUG
-void grpc_call_internal_ref(grpc_call* call, const char* reason);
-void grpc_call_internal_unref(grpc_call* call, const char* reason);
-#define GRPC_CALL_INTERNAL_REF(call, reason) \
-  grpc_call_internal_ref(call, reason)
-#define GRPC_CALL_INTERNAL_UNREF(call, reason) \
-  grpc_call_internal_unref(call, reason)
-#else
-void grpc_call_internal_ref(grpc_call* call);
-void grpc_call_internal_unref(grpc_call* call);
-#define GRPC_CALL_INTERNAL_REF(call, reason) grpc_call_internal_ref(call)
-#define GRPC_CALL_INTERNAL_UNREF(call, reason) grpc_call_internal_unref(call)
-#endif
-
 grpc_core::Arena* grpc_call_get_arena(grpc_call* call);
 
 grpc_call_stack* grpc_call_get_call_stack(grpc_call* call);

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

@@ -31,6 +31,7 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack_builder_impl.h"
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/channel/channelz_registry.h"
@@ -58,21 +59,20 @@
 static void destroy_channel(void* arg, grpc_error_handle error);
 
 grpc_channel* grpc_channel_create_with_builder(
-    grpc_channel_stack_builder* builder,
+    grpc_core::ChannelStackBuilder* builder,
     grpc_channel_stack_type channel_stack_type, grpc_error_handle* error) {
-  std::string target = grpc_channel_stack_builder_get_target(builder);
-  grpc_channel_args* args = grpc_channel_args_copy(
-      grpc_channel_stack_builder_get_channel_arguments(builder));
+  std::string target(builder->target());
+  grpc_channel_args* args = grpc_channel_args_copy(builder->channel_args());
   grpc_channel* channel;
   if (channel_stack_type == GRPC_SERVER_CHANNEL) {
     GRPC_STATS_INC_SERVER_CHANNELS_CREATED();
   } else {
     GRPC_STATS_INC_CLIENT_CHANNELS_CREATED();
   }
-  std::string name = grpc_channel_stack_builder_get_target(builder);
-  grpc_error_handle builder_error = grpc_channel_stack_builder_finish(
-      builder, sizeof(grpc_channel), 1, destroy_channel, nullptr,
-      reinterpret_cast<void**>(&channel));
+  std::string name(builder->target());
+  grpc_error_handle builder_error =
+      builder->Build(sizeof(grpc_channel), 1, destroy_channel, nullptr,
+                     reinterpret_cast<void**>(&channel));
   if (builder_error != GRPC_ERROR_NONE) {
     gpr_log(GPR_ERROR, "channel stack builder failed: %s",
             grpc_error_std_string(builder_error).c_str());
@@ -187,9 +187,8 @@ int channelz_node_cmp(void* p1, void* p2) {
 const grpc_arg_pointer_vtable channelz_node_arg_vtable = {
     channelz_node_copy, channelz_node_destroy, channelz_node_cmp};
 
-void CreateChannelzNode(grpc_channel_stack_builder* builder) {
-  const grpc_channel_args* args =
-      grpc_channel_stack_builder_get_channel_arguments(builder);
+void CreateChannelzNode(grpc_core::ChannelStackBuilder* builder) {
+  const grpc_channel_args* args = builder->channel_args();
   // Check whether channelz is enabled.
   const bool channelz_enabled = grpc_channel_args_find_bool(
       args, GRPC_ARG_ENABLE_CHANNELZ, GRPC_ENABLE_CHANNELZ_DEFAULT);
@@ -201,7 +200,7 @@ void CreateChannelzNode(grpc_channel_stack_builder* builder) {
   const bool is_internal_channel = grpc_channel_args_find_bool(
       args, GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL, false);
   // Create the channelz node.
-  std::string target = grpc_channel_stack_builder_get_target(builder);
+  std::string target(builder->target());
   grpc_core::RefCountedPtr<grpc_core::channelz::ChannelNode> channelz_node =
       grpc_core::MakeRefCounted<grpc_core::channelz::ChannelNode>(
           target.c_str(), channel_tracer_max_memory, is_internal_channel);
@@ -216,17 +215,16 @@ void CreateChannelzNode(grpc_channel_stack_builder* builder) {
   const char* args_to_remove[] = {GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL};
   grpc_channel_args* new_args = grpc_channel_args_copy_and_add_and_remove(
       args, args_to_remove, GPR_ARRAY_SIZE(args_to_remove), &new_arg, 1);
-  grpc_channel_stack_builder_set_channel_arguments(builder, new_args);
+  builder->SetChannelArgs(new_args);
   grpc_channel_args_destroy(new_args);
 }
 
 }  // namespace
 
-grpc_channel* grpc_channel_create(const char* target,
-                                  const grpc_channel_args* input_args,
-                                  grpc_channel_stack_type channel_stack_type,
-                                  grpc_transport* optional_transport,
-                                  grpc_error_handle* error) {
+grpc_channel* grpc_channel_create_internal(
+    const char* target, const grpc_channel_args* input_args,
+    grpc_channel_stack_type channel_stack_type,
+    grpc_transport* optional_transport, grpc_error_handle* error) {
   // We need to make sure that grpc_shutdown() does not shut things down
   // until after the channel is destroyed.  However, the channel may not
   // actually be destroyed by the time grpc_channel_destroy() returns,
@@ -244,8 +242,8 @@ grpc_channel* grpc_channel_create(const char* target,
   // grpc_shutdown() when the channel is actually destroyed, thus
   // ensuring that shutdown is deferred until that point.
   grpc_init();
-  grpc_channel_stack_builder* builder = grpc_channel_stack_builder_create(
-      grpc_channel_stack_type_string(channel_stack_type));
+  grpc_core::ChannelStackBuilderImpl builder(
+      grpc_channel_stack_type_string(channel_stack_type), channel_stack_type);
   const grpc_core::UniquePtr<char> default_authority =
       get_default_authority(input_args);
   grpc_channel_args* args =
@@ -257,23 +255,21 @@ grpc_channel* grpc_channel_create(const char* target,
       args = channel_args_mutator(target, args, channel_stack_type);
     }
   }
-  grpc_channel_stack_builder_set_channel_arguments(builder, args);
+  builder.SetChannelArgs(args).SetTarget(target).SetTransport(
+      optional_transport);
   grpc_channel_args_destroy(args);
-  grpc_channel_stack_builder_set_target(builder, target);
-  grpc_channel_stack_builder_set_transport(builder, optional_transport);
   if (!grpc_core::CoreConfiguration::Get().channel_init().CreateStack(
-          builder, channel_stack_type)) {
-    grpc_channel_stack_builder_destroy(builder);
+          &builder)) {
     grpc_shutdown();  // Since we won't call destroy_channel().
     return nullptr;
   }
   // We only need to do this for clients here. For servers, this will be
   // done in src/core/lib/surface/server.cc.
   if (grpc_channel_stack_type_is_client(channel_stack_type)) {
-    CreateChannelzNode(builder);
+    CreateChannelzNode(&builder);
   }
   grpc_channel* channel =
-      grpc_channel_create_with_builder(builder, channel_stack_type, error);
+      grpc_channel_create_with_builder(&builder, channel_stack_type, error);
   if (channel == nullptr) {
     grpc_shutdown();  // Since we won't call destroy_channel().
   }
@@ -345,7 +341,7 @@ static grpc_call* grpc_channel_create_call_internal(
     grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
     grpc_completion_queue* cq, grpc_pollset_set* pollset_set_alternative,
     grpc_core::Slice path, absl::optional<grpc_core::Slice> authority,
-    grpc_millis deadline) {
+    grpc_core::Timestamp deadline) {
   GPR_ASSERT(channel->is_client);
   GPR_ASSERT(!(cq != nullptr && pollset_set_alternative != nullptr));
 
@@ -381,7 +377,7 @@ grpc_call* grpc_channel_create_call(grpc_channel* channel,
       host != nullptr
           ? absl::optional<grpc_core::Slice>(grpc_slice_ref_internal(*host))
           : absl::nullopt,
-      grpc_timespec_to_millis_round_up(deadline));
+      grpc_core::Timestamp::FromTimespecRoundUp(deadline));
 
   return call;
 }
@@ -389,7 +385,7 @@ grpc_call* grpc_channel_create_call(grpc_channel* channel,
 grpc_call* grpc_channel_create_pollset_set_call(
     grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
     grpc_pollset_set* pollset_set, const grpc_slice& method,
-    const grpc_slice* host, grpc_millis deadline, void* reserved) {
+    const grpc_slice* host, grpc_core::Timestamp deadline, void* reserved) {
   GPR_ASSERT(!reserved);
   return grpc_channel_create_call_internal(
       channel, parent_call, propagation_mask, nullptr, pollset_set,
@@ -468,7 +464,7 @@ grpc_call* grpc_channel_create_registered_call(
       rc->authority.has_value()
           ? absl::optional<grpc_core::Slice>(rc->authority->Ref())
           : absl::nullopt,
-      grpc_timespec_to_millis_round_up(deadline));
+      grpc_core::Timestamp::FromTimespecRoundUp(deadline));
 
   return call;
 }
@@ -486,7 +482,7 @@ static void destroy_channel(void* arg, grpc_error_handle /*error*/) {
   channel->allocator.Destroy();
   channel->target.Destroy();
   gpr_free(channel);
-  // See comment in grpc_channel_create() for why we do this.
+  // See comment in grpc_channel_create_internal() for why we do this.
   grpc_shutdown();
 }
 

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

@@ -31,11 +31,10 @@
 #include "src/core/lib/surface/channel_stack_type.h"
 
 /// Creates a grpc_channel.
-grpc_channel* grpc_channel_create(const char* target,
-                                  const grpc_channel_args* args,
-                                  grpc_channel_stack_type channel_stack_type,
-                                  grpc_transport* optional_transport,
-                                  grpc_error_handle* error);
+grpc_channel* grpc_channel_create_internal(
+    const char* target, const grpc_channel_args* args,
+    grpc_channel_stack_type channel_stack_type,
+    grpc_transport* optional_transport, grpc_error_handle* error);
 
 /** The same as grpc_channel_destroy, but doesn't create an ExecCtx, and so
  * is safe to use from within core. */
@@ -44,7 +43,7 @@ void grpc_channel_destroy_internal(grpc_channel* channel);
 /// Creates a grpc_channel with a builder. See the description of
 /// \a grpc_channel_create for variable definitions.
 grpc_channel* grpc_channel_create_with_builder(
-    grpc_channel_stack_builder* builder,
+    grpc_core::ChannelStackBuilder* builder,
     grpc_channel_stack_type channel_stack_type,
     grpc_error_handle* error = nullptr);
 
@@ -59,7 +58,7 @@ grpc_channel* grpc_channel_create_with_builder(
 grpc_call* grpc_channel_create_pollset_set_call(
     grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
     grpc_pollset_set* pollset_set, const grpc_slice& method,
-    const grpc_slice* host, grpc_millis deadline, void* reserved);
+    const grpc_slice* host, grpc_core::Timestamp deadline, void* reserved);
 
 /** Get a (borrowed) pointer to this channels underlying channel stack */
 grpc_channel_stack* grpc_channel_get_channel_stack(grpc_channel* channel);

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

@@ -45,9 +45,8 @@ ChannelInit ChannelInit::Builder::Build() {
   return result;
 }
 
-bool ChannelInit::CreateStack(grpc_channel_stack_builder* builder,
-                              grpc_channel_stack_type type) const {
-  for (const auto& stage : slots_[type]) {
+bool ChannelInit::CreateStack(ChannelStackBuilder* builder) const {
+  for (const auto& stage : slots_[builder->channel_stack_type()]) {
     if (!stage(builder)) return false;
   }
   return true;

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

@@ -24,7 +24,7 @@
 #include <functional>
 #include <vector>
 
-#include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/channel/channel_stack_builder.h"
 
 #define GRPC_CHANNEL_INIT_BUILTIN_PRIORITY 10000
 
@@ -33,15 +33,13 @@
 /// It also provides a universal entry path to run those mutators to build
 /// a channel stack for various subsystems.
 
-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)>;
+  using Stage = std::function<bool(ChannelStackBuilder* builder)>;
 
   class Builder {
    public:
@@ -72,10 +70,8 @@ class ChannelInit {
   };
 
   /// 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;
+  bool CreateStack(ChannelStackBuilder* builder) const;
 
  private:
   std::vector<Stage> slots_[GRPC_NUM_CHANNEL_STACK_TYPES];

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

@@ -73,7 +73,7 @@ struct cq_poller_vtable {
   grpc_error_handle (*kick)(grpc_pollset* pollset,
                             grpc_pollset_worker* specific_worker);
   grpc_error_handle (*work)(grpc_pollset* pollset, grpc_pollset_worker** worker,
-                            grpc_millis deadline);
+                            grpc_core::Timestamp deadline);
   void (*shutdown)(grpc_pollset* pollset, grpc_closure* closure);
   void (*destroy)(grpc_pollset* pollset);
 };
@@ -105,7 +105,7 @@ void non_polling_poller_destroy(grpc_pollset* pollset) {
 
 grpc_error_handle non_polling_poller_work(grpc_pollset* pollset,
                                           grpc_pollset_worker** worker,
-                                          grpc_millis deadline) {
+                                          grpc_core::Timestamp deadline) {
   non_polling_poller* npp = reinterpret_cast<non_polling_poller*>(pollset);
   if (npp->shutdown) return GRPC_ERROR_NONE;
   if (npp->kicked_without_poller) {
@@ -123,8 +123,7 @@ grpc_error_handle non_polling_poller_work(grpc_pollset* pollset,
     w.next->prev = w.prev->next = &w;
   }
   w.kicked = false;
-  gpr_timespec deadline_ts =
-      grpc_millis_to_timespec(deadline, GPR_CLOCK_MONOTONIC);
+  gpr_timespec deadline_ts = deadline.as_timespec(GPR_CLOCK_MONOTONIC);
   while (!npp->shutdown && !w.kicked &&
          !gpr_cv_wait(&w.cv, &npp->mu, deadline_ts)) {
   }
@@ -894,7 +893,7 @@ void grpc_cq_end_op(grpc_completion_queue* cq, void* tag,
 struct cq_is_finished_arg {
   gpr_atm last_seen_things_queued_ever;
   grpc_completion_queue* cq;
-  grpc_millis deadline;
+  grpc_core::Timestamp deadline;
   grpc_cq_completion* stolen_completion;
   void* tag; /* for pluck */
   bool first_loop;
@@ -974,7 +973,8 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
 
   GRPC_CQ_INTERNAL_REF(cq, "next");
 
-  grpc_millis deadline_millis = grpc_timespec_to_millis_round_up(deadline);
+  grpc_core::Timestamp deadline_millis =
+      grpc_core::Timestamp::FromTimespecRoundUp(deadline);
   cq_is_finished_arg is_finished_arg = {
       cqd->things_queued_ever.load(std::memory_order_relaxed),
       cq,
@@ -984,7 +984,7 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
       true};
   ExecCtxNext exec_ctx(&is_finished_arg);
   for (;;) {
-    grpc_millis iteration_deadline = deadline_millis;
+    grpc_core::Timestamp iteration_deadline = deadline_millis;
 
     if (is_finished_arg.stolen_completion != nullptr) {
       grpc_cq_completion* c = is_finished_arg.stolen_completion;
@@ -1011,7 +1011,7 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
          attempt at popping. Not doing this can potentially deadlock this
          thread forever (if the deadline is infinity) */
       if (cqd->queue.num_items() > 0) {
-        iteration_deadline = 0;
+        iteration_deadline = grpc_core::Timestamp::ProcessEpoch();
       }
     }
 
@@ -1223,7 +1223,8 @@ static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag,
 
   GRPC_CQ_INTERNAL_REF(cq, "pluck");
   gpr_mu_lock(cq->mu);
-  grpc_millis deadline_millis = grpc_timespec_to_millis_round_up(deadline);
+  grpc_core::Timestamp deadline_millis =
+      grpc_core::Timestamp::FromTimespecRoundUp(deadline);
   cq_is_finished_arg is_finished_arg = {
       cqd->things_queued_ever.load(std::memory_order_relaxed),
       cq,

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

@@ -22,6 +22,7 @@
 
 #include <limits.h>
 #include <memory.h>
+#include <string.h>
 
 #include <grpc/fork.h>
 #include <grpc/grpc.h>
@@ -30,13 +31,14 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/channel/channelz_registry.h"
 #include "src/core/lib/channel/connected_channel.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/fork.h"
 #include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
@@ -44,8 +46,17 @@
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/timer_manager.h"
 #include "src/core/lib/profiling/timers.h"
+#include "src/core/lib/security/authorization/grpc_server_authz_filter.h"
+#include "src/core/lib/security/context/security_context.h"
+#include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/security/credentials/plugin/plugin_credentials.h"
+#include "src/core/lib/security/security_connector/security_connector.h"
+#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/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
+#include "src/core/lib/surface/builtins.h"
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/surface/lame_client.h"
@@ -61,10 +72,75 @@ extern void grpc_register_built_in_plugins(void);
 
 static gpr_once g_basic_init = GPR_ONCE_INIT;
 static grpc_core::Mutex* g_init_mu;
-static int g_initializations ABSL_GUARDED_BY(g_init_mu) = 0;
+static int g_initializations ABSL_GUARDED_BY(g_init_mu) = []() {
+  grpc_core::CoreConfiguration::SetDefaultBuilder(
+      grpc_core::BuildCoreConfiguration);
+  return 0;
+}();
 static grpc_core::CondVar* g_shutting_down_cv;
 static bool g_shutting_down ABSL_GUARDED_BY(g_init_mu) = false;
 
+static bool maybe_prepend_client_auth_filter(
+    grpc_core::ChannelStackBuilder* builder) {
+  const grpc_channel_args* args = builder->channel_args();
+  if (args) {
+    for (size_t i = 0; i < args->num_args; i++) {
+      if (0 == strcmp(GRPC_ARG_SECURITY_CONNECTOR, args->args[i].key)) {
+        builder->PrependFilter(&grpc_core::ClientAuthFilter::kFilter, nullptr);
+        break;
+      }
+    }
+  }
+  return true;
+}
+
+static bool maybe_prepend_server_auth_filter(
+    grpc_core::ChannelStackBuilder* builder) {
+  const grpc_channel_args* args = builder->channel_args();
+  if (args) {
+    for (size_t i = 0; i < args->num_args; i++) {
+      if (0 == strcmp(GRPC_SERVER_CREDENTIALS_ARG, args->args[i].key)) {
+        builder->PrependFilter(&grpc_server_auth_filter, nullptr);
+        break;
+      }
+    }
+  }
+  return true;
+}
+
+static bool maybe_prepend_grpc_server_authz_filter(
+    grpc_core::ChannelStackBuilder* builder) {
+  const grpc_channel_args* args = builder->channel_args();
+  const auto* provider =
+      grpc_channel_args_find_pointer<grpc_authorization_policy_provider>(
+          args, GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER);
+  if (provider != nullptr) {
+    builder->PrependFilter(&grpc_core::GrpcServerAuthzFilter::kFilterVtable,
+                           nullptr);
+  }
+  return true;
+}
+
+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.
+  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 GrpcServerAuthzFilter with a priority less than
+  // server_auth_filter to allow server_auth_filter on which the grpc filter
+  // depends on to be higher on the channel stack.
+  builder->channel_init()->RegisterStage(
+      GRPC_SERVER_CHANNEL, INT_MAX - 2, maybe_prepend_grpc_server_authz_filter);
+}
+}  // namespace grpc_core
+
 static void do_basic_init(void) {
   gpr_log_verbosity_init();
   g_init_mu = new grpc_core::Mutex();
@@ -104,11 +180,8 @@ void grpc_init(void) {
     grpc_core::Fork::GlobalInit();
     grpc_fork_handlers_auto_register();
     grpc_stats_init();
-    grpc_slice_intern_init();
     grpc_core::channelz::ChannelzRegistry::Init();
-    grpc_security_pre_init();
     grpc_core::ApplicationCallbackExecCtx::GlobalInit();
-    grpc_core::ExecCtx::GlobalInit();
     grpc_iomgr_init();
     gpr_timers_global_init();
     for (int i = 0; i < g_number_of_plugins; i++) {
@@ -140,12 +213,10 @@ void grpc_shutdown_internal_locked(void)
     grpc_iomgr_shutdown();
     gpr_timers_global_destroy();
     grpc_tracer_shutdown();
-    grpc_slice_intern_shutdown();
     grpc_core::channelz::ChannelzRegistry::Shutdown();
     grpc_stats_shutdown();
     grpc_core::Fork::GlobalShutdown();
   }
-  grpc_core::ExecCtx::GlobalShutdown();
   grpc_core::ApplicationCallbackExecCtx::GlobalShutdown();
   g_shutting_down = false;
   g_shutting_down_cv->SignalAll();

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

@@ -28,8 +28,6 @@ class EventEngine;
 }
 }  // namespace grpc_event_engine
 
-void grpc_register_security_filters(void);
-void grpc_security_pre_init(void);
 void grpc_maybe_wait_for_async_shutdown(void);
 
 #endif /* GRPC_CORE_LIB_SURFACE_INIT_H */

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

@@ -156,6 +156,7 @@ grpc_arg MakeLameClientErrorArg(grpc_error_handle* error) {
 
 const grpc_channel_filter grpc_lame_filter = {
     grpc_core::lame_start_transport_stream_op_batch,
+    nullptr,
     grpc_core::lame_start_transport_op,
     sizeof(grpc_core::CallData),
     grpc_core::lame_init_call_elem,
@@ -190,7 +191,7 @@ grpc_channel* grpc_lame_client_channel_create(const char* target,
                                       .channel_args_preconditioning()
                                       .PreconditionChannelArgs(args0);
   grpc_channel_args_destroy(args0);
-  grpc_channel* channel = grpc_channel_create(
+  grpc_channel* channel = grpc_channel_create_internal(
       target, args, GRPC_CLIENT_LAME_CHANNEL, nullptr, nullptr);
   grpc_channel_args_destroy(args);
   GRPC_ERROR_UNREF(error);

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

@@ -479,7 +479,6 @@ class ChannelBroadcaster {
                   GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server shutdown"),
                   GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_OK)
             : GRPC_ERROR_NONE;
-    op->set_accept_stream = true;
     sc->slice = grpc_slice_from_copied_string("Server shutdown");
     op->disconnect_with_error = send_disconnect;
     elem =
@@ -498,6 +497,7 @@ class ChannelBroadcaster {
 
 const grpc_channel_filter Server::kServerTopFilter = {
     Server::CallData::StartTransportStreamOpBatch,
+    nullptr,
     grpc_channel_next_op,
     sizeof(Server::CallData),
     Server::CallData::InitCallElement,
@@ -602,7 +602,7 @@ grpc_error_handle Server::SetupTransport(
     const RefCountedPtr<channelz::SocketNode>& socket_node) {
   // Create channel.
   grpc_error_handle error = GRPC_ERROR_NONE;
-  grpc_channel* channel = grpc_channel_create(
+  grpc_channel* channel = grpc_channel_create_internal(
       nullptr, args, GRPC_SERVER_CHANNEL, transport, &error);
   if (channel == nullptr) {
     return error;
@@ -684,7 +684,7 @@ Server::RegisteredMethod* Server::RegisterMethod(
       return nullptr;
     }
   }
-  if ((flags & ~GRPC_INITIAL_METADATA_USED_MASK) != 0) {
+  if (flags != 0) {
     gpr_log(GPR_ERROR, "grpc_server_register_method invalid flags 0x%08x",
             flags);
     return nullptr;
@@ -982,19 +982,7 @@ class Server::ChannelData::ConnectivityWatcher
 //
 
 Server::ChannelData::~ChannelData() {
-  if (registered_methods_ != nullptr) {
-    for (const ChannelRegisteredMethod& crm : *registered_methods_) {
-      grpc_slice_unref_internal(crm.method);
-      GPR_DEBUG_ASSERT(crm.method.refcount == &kNoopRefcount ||
-                       crm.method.refcount == nullptr);
-      if (crm.has_host) {
-        grpc_slice_unref_internal(crm.host);
-        GPR_DEBUG_ASSERT(crm.host.refcount == &kNoopRefcount ||
-                         crm.host.refcount == nullptr);
-      }
-    }
-    registered_methods_.reset();
-  }
+  registered_methods_.reset();
   if (server_ != nullptr) {
     if (server_->channelz_node_ != nullptr && channelz_socket_uuid_ != 0) {
       server_->channelz_node_->RemoveChildSocket(channelz_socket_uuid_);
@@ -1027,11 +1015,11 @@ void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
     registered_methods_ =
         absl::make_unique<std::vector<ChannelRegisteredMethod>>(slots);
     for (std::unique_ptr<RegisteredMethod>& rm : server_->registered_methods_) {
-      ExternallyManagedSlice host;
-      ExternallyManagedSlice method(rm->method.c_str());
+      Slice host;
+      Slice method = Slice::FromExternalString(rm->method);
       const bool has_host = !rm->host.empty();
       if (has_host) {
-        host = ExternallyManagedSlice(rm->host.c_str());
+        host = Slice::FromExternalString(rm->host.c_str());
       }
       uint32_t hash = MixHash32(has_host ? host.Hash() : 0, method.Hash());
       uint32_t probes = 0;
@@ -1046,9 +1034,9 @@ void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
       crm->flags = rm->flags;
       crm->has_host = has_host;
       if (has_host) {
-        crm->host = host;
+        crm->host = std::move(host);
       }
-      crm->method = method;
+      crm->method = std::move(method);
     }
     GPR_ASSERT(slots <= UINT32_MAX);
     registered_method_max_probes_ = max_probes;
@@ -1073,7 +1061,7 @@ void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
 }
 
 Server::ChannelRegisteredMethod* Server::ChannelData::GetRegisteredMethod(
-    const grpc_slice& host, const grpc_slice& path, bool is_idempotent) {
+    const grpc_slice& host, const grpc_slice& path) {
   if (registered_methods_ == nullptr) return nullptr;
   /* TODO(ctiller): unify these two searches */
   /* check for an exact match with host */
@@ -1086,10 +1074,6 @@ Server::ChannelRegisteredMethod* Server::ChannelData::GetRegisteredMethod(
     if (!rm->has_host) continue;
     if (rm->host != host) continue;
     if (rm->method != path) continue;
-    if ((rm->flags & GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) &&
-        !is_idempotent) {
-      continue;
-    }
     return rm;
   }
   /* check for a wildcard method definition (no host set) */
@@ -1100,10 +1084,6 @@ Server::ChannelRegisteredMethod* Server::ChannelData::GetRegisteredMethod(
     if (rm->server_registered_method == nullptr) break;
     if (rm->has_host) continue;
     if (rm->method != path) continue;
-    if ((rm->flags & GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) &&
-        !is_idempotent) {
-      continue;
-    }
     return rm;
   }
   return nullptr;
@@ -1121,7 +1101,7 @@ void Server::ChannelData::AcceptStream(void* arg, grpc_transport* /*transport*/,
   args.cq = nullptr;
   args.pollset_set_alternative = nullptr;
   args.server_transport_data = transport_server_data;
-  args.send_deadline = GRPC_MILLIS_INF_FUTURE;
+  args.send_deadline = Timestamp::InfFuture();
   grpc_call* call;
   grpc_error_handle error = grpc_call_create(&args, &call);
   grpc_call_element* elem =
@@ -1251,12 +1231,12 @@ void Server::CallData::Publish(size_t cq_idx, RequestedCall* rc) {
       rc->data.batch.details->method =
           grpc_slice_ref_internal(path_->c_slice());
       rc->data.batch.details->deadline =
-          grpc_millis_to_timespec(deadline_, GPR_CLOCK_MONOTONIC);
+          deadline_.as_timespec(GPR_CLOCK_MONOTONIC);
       rc->data.batch.details->flags = recv_initial_metadata_flags_;
       break;
     case RequestedCall::Type::REGISTERED_CALL:
       *rc->data.registered.deadline =
-          grpc_millis_to_timespec(deadline_, GPR_CLOCK_MONOTONIC);
+          deadline_.as_timespec(GPR_CLOCK_MONOTONIC);
       if (rc->data.registered.optional_payload != nullptr) {
         *rc->data.registered.optional_payload = payload_;
         payload_ = nullptr;
@@ -1310,9 +1290,7 @@ void Server::CallData::StartNewRpc(grpc_call_element* elem) {
       GRPC_SRM_PAYLOAD_NONE;
   if (path_.has_value() && host_.has_value()) {
     ChannelRegisteredMethod* rm =
-        chand->GetRegisteredMethod(host_->c_slice(), path_->c_slice(),
-                                   (recv_initial_metadata_flags_ &
-                                    GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST));
+        chand->GetRegisteredMethod(host_->c_slice(), path_->c_slice());
     if (rm != nullptr) {
       matcher_ = rm->server_registered_method->matcher.get();
       payload_handling = rm->server_registered_method->payload_handling;