grpc 1.46.3-x86_64-linux → 1.48.0-x86_64-linux

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

@@ -21,32 +21,45 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <map>
+#include <stddef.h>
+#include <stdint.h>
 
-#include "src/core/lib/channel/channel_stack.h"
+#include <atomic>
+#include <map>
+#include <string>
+#include <utility>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include <grpc/event_engine/memory_allocator.h>
+#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/slice.h>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/channel/channel_stack.h"  // IWYU pragma: keep
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/channel/channelz.h"
-#include "src/core/lib/gprpp/manual_constructor.h"
+#include "src/core/lib/gprpp/cpp_impl_of.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-
-/// Creates a grpc_channel.
-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);
+#include "src/core/lib/transport/transport_fwd.h"
 
 /** The same as grpc_channel_destroy, but doesn't create an ExecCtx, and so
  * is safe to use from within core. */
 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_core::ChannelStackBuilder* builder,
-    grpc_channel_stack_type channel_stack_type,
-    grpc_error_handle* error = nullptr);
-
 /** Create a call given a grpc_channel, in order to call \a method.
     Progress is tied to activity on \a pollset_set. The returned call object is
     meant to be used with \a grpc_call_start_batch_and_execute, which relies on
@@ -92,68 +105,94 @@ struct CallRegistrationTable {
   int method_registration_attempts ABSL_GUARDED_BY(mu) = 0;
 };
 
-}  // namespace grpc_core
-
-struct grpc_channel {
-  int is_client;
-  grpc_compression_options compression_options;
-
-  gpr_atm call_size_estimate;
-
-  // TODO(vjpai): Once the grpc_channel is allocated via new rather than malloc,
-  //              expand the members of the CallRegistrationTable directly into
-  //              the grpc_channel. For now it is kept separate so that all the
-  //              manual constructing can be done with a single call rather than
-  //              a separate manual construction for each field.
-  grpc_core::ManualConstructor<grpc_core::CallRegistrationTable>
-      registration_table;
-  grpc_core::RefCountedPtr<grpc_core::channelz::ChannelNode> channelz_node;
-  grpc_core::ManualConstructor<grpc_core::MemoryAllocator> allocator;
-
-  grpc_core::ManualConstructor<std::string> target;
+class Channel : public RefCounted<Channel>,
+                public CppImplOf<Channel, grpc_channel> {
+ public:
+  static absl::StatusOr<RefCountedPtr<Channel>> Create(
+      const char* target, ChannelArgs args,
+      grpc_channel_stack_type channel_stack_type,
+      grpc_transport* optional_transport);
+
+  static absl::StatusOr<RefCountedPtr<Channel>> CreateWithBuilder(
+      ChannelStackBuilder* builder);
+
+  grpc_channel_stack* channel_stack() const { return channel_stack_.get(); }
+
+  grpc_compression_options compression_options() const {
+    return compression_options_;
+  }
+
+  channelz::ChannelNode* channelz_node() const { return channelz_node_.get(); }
+
+  size_t CallSizeEstimate() {
+    // We round up our current estimate to the NEXT value of kRoundUpSize.
+    // This ensures:
+    //  1. a consistent size allocation when our estimate is drifting slowly
+    //     (which is common) - which tends to help most allocators reuse memory
+    //  2. a small amount of allowed growth over the estimate without hitting
+    //     the arena size doubling case, reducing overall memory usage
+    static constexpr size_t kRoundUpSize = 256;
+    return (call_size_estimate_.load(std::memory_order_relaxed) +
+            2 * kRoundUpSize) &
+           ~(kRoundUpSize - 1);
+  }
+
+  void UpdateCallSizeEstimate(size_t size);
+  absl::string_view target() const { return target_; }
+  MemoryAllocator* allocator() { return &allocator_; }
+  bool is_client() const { return is_client_; }
+  RegisteredCall* RegisterCall(const char* method, const char* host);
+
+  int TestOnlyRegisteredCalls() {
+    MutexLock lock(&registration_table_.mu);
+    return registration_table_.map.size();
+  }
+
+  int TestOnlyRegistrationAttempts() {
+    MutexLock lock(&registration_table_.mu);
+    return registration_table_.method_registration_attempts;
+  }
+
+ private:
+  Channel(bool is_client, std::string target, ChannelArgs channel_args,
+          grpc_compression_options compression_options,
+          RefCountedPtr<grpc_channel_stack> channel_stack);
+
+  const bool is_client_;
+  const grpc_compression_options compression_options_;
+  std::atomic<size_t> call_size_estimate_;
+  CallRegistrationTable registration_table_;
+  RefCountedPtr<channelz::ChannelNode> channelz_node_;
+  MemoryAllocator allocator_;
+  std::string target_;
+  const RefCountedPtr<grpc_channel_stack> channel_stack_;
 };
-#define CHANNEL_STACK_FROM_CHANNEL(c) ((grpc_channel_stack*)((c) + 1))
+
+}  // namespace grpc_core
 
 inline grpc_compression_options grpc_channel_compression_options(
     const grpc_channel* channel) {
-  return channel->compression_options;
+  return grpc_core::Channel::FromC(channel)->compression_options();
 }
 
 inline grpc_channel_stack* grpc_channel_get_channel_stack(
     grpc_channel* channel) {
-  return CHANNEL_STACK_FROM_CHANNEL(channel);
+  return grpc_core::Channel::FromC(channel)->channel_stack();
 }
 
 inline grpc_core::channelz::ChannelNode* grpc_channel_get_channelz_node(
     grpc_channel* channel) {
-  return channel->channelz_node.get();
+  return grpc_core::Channel::FromC(channel)->channelz_node();
 }
 
-#ifndef NDEBUG
 inline void grpc_channel_internal_ref(grpc_channel* channel,
                                       const char* reason) {
-  GRPC_CHANNEL_STACK_REF(CHANNEL_STACK_FROM_CHANNEL(channel), reason);
+  grpc_core::Channel::FromC(channel)->Ref(DEBUG_LOCATION, reason).release();
 }
 inline void grpc_channel_internal_unref(grpc_channel* channel,
                                         const char* reason) {
-  GRPC_CHANNEL_STACK_UNREF(CHANNEL_STACK_FROM_CHANNEL(channel), reason);
-}
-#define GRPC_CHANNEL_INTERNAL_REF(channel, reason) \
-  grpc_channel_internal_ref(channel, reason)
-#define GRPC_CHANNEL_INTERNAL_UNREF(channel, reason) \
-  grpc_channel_internal_unref(channel, reason)
-#else
-inline void grpc_channel_internal_ref(grpc_channel* channel) {
-  GRPC_CHANNEL_STACK_REF(CHANNEL_STACK_FROM_CHANNEL(channel), "unused");
-}
-inline void grpc_channel_internal_unref(grpc_channel* channel) {
-  GRPC_CHANNEL_STACK_UNREF(CHANNEL_STACK_FROM_CHANNEL(channel), "unused");
+  grpc_core::Channel::FromC(channel)->Unref(DEBUG_LOCATION, reason);
 }
-#define GRPC_CHANNEL_INTERNAL_REF(channel, reason) \
-  grpc_channel_internal_ref(channel)
-#define GRPC_CHANNEL_INTERNAL_UNREF(channel, reason) \
-  grpc_channel_internal_unref(channel)
-#endif
 
 // Return the channel's compression options.
 grpc_compression_options grpc_channel_compression_options(

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

@@ -22,9 +22,11 @@
 #include <grpc/support/port_platform.h>
 
 #include <functional>
+#include <utility>
 #include <vector>
 
 #include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/surface/channel_stack_type.h"
 
 #define GRPC_CHANNEL_INIT_BUILTIN_PRIORITY 10000
 

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

@@ -18,14 +18,20 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <string.h>
-
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
+#include "src/core/lib/transport/transport.h"
 
 struct ping_result {
   grpc_closure closure;

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

@@ -20,8 +20,6 @@
 
 #include "src/core/lib/surface/channel_stack_type.h"
 
-#include <grpc/support/log.h>
-
 bool grpc_channel_stack_type_is_client(grpc_channel_stack_type type) {
   switch (type) {
     case GRPC_CLIENT_CHANNEL:

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

@@ -21,8 +21,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
-
 typedef enum {
   // normal top-half client channel with load-balancing, connection management
   GRPC_CLIENT_CHANNEL,

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

@@ -21,30 +21,39 @@
 
 #include <inttypes.h>
 #include <stdio.h>
-#include <string.h>
 
+#include <algorithm>
 #include <atomic>
+#include <new>
+#include <string>
+#include <utility>
 #include <vector>
 
+#include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
+#include <grpc/grpc.h>
+#include <grpc/impl/codegen/gpr_types.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-#include <grpc/support/time.h>
+#include <grpc/support/sync.h>
 
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gpr/spinlock.h"
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/tls.h"
+#include "src/core/lib/gprpp/atomic_utils.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/executor.h"
+#include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/pollset.h"
-#include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/surface/api_trace.h"
-#include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/event_string.h"
 
 grpc_core::TraceFlag grpc_trace_operation_failures(false, "op_failure");
@@ -687,20 +696,20 @@ static void cq_end_op_for_next(
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_api_trace) ||
       (GRPC_TRACE_FLAG_ENABLED(grpc_trace_operation_failures) &&
-       error != GRPC_ERROR_NONE)) {
+       !GRPC_ERROR_IS_NONE(error))) {
     std::string errmsg = grpc_error_std_string(error);
     GRPC_API_TRACE(
         "cq_end_op_for_next(cq=%p, tag=%p, error=%s, "
         "done=%p, done_arg=%p, storage=%p)",
         6, (cq, tag, errmsg.c_str(), done, done_arg, storage));
     if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_operation_failures) &&
-        error != GRPC_ERROR_NONE) {
+        !GRPC_ERROR_IS_NONE(error)) {
       gpr_log(GPR_INFO, "Operation failed: tag=%p, error=%s", tag,
               errmsg.c_str());
     }
   }
   cq_next_data* cqd = static_cast<cq_next_data*> DATA_FROM_CQ(cq);
-  int is_success = (error == GRPC_ERROR_NONE);
+  int is_success = (GRPC_ERROR_IS_NONE(error));
 
   storage->tag = tag;
   storage->done = done;
@@ -728,7 +737,7 @@ static void cq_end_op_for_next(
             cq->poller_vtable->kick(POLLSET_FROM_CQ(cq), nullptr);
         gpr_mu_unlock(cq->mu);
 
-        if (kick_error != GRPC_ERROR_NONE) {
+        if (!GRPC_ERROR_IS_NONE(kick_error)) {
           gpr_log(GPR_ERROR, "Kick failed: %s",
                   grpc_error_std_string(kick_error).c_str());
           GRPC_ERROR_UNREF(kick_error);
@@ -764,18 +773,18 @@ static void cq_end_op_for_pluck(
   GPR_TIMER_SCOPE("cq_end_op_for_pluck", 0);
 
   cq_pluck_data* cqd = static_cast<cq_pluck_data*> DATA_FROM_CQ(cq);
-  int is_success = (error == GRPC_ERROR_NONE);
+  int is_success = (GRPC_ERROR_IS_NONE(error));
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_api_trace) ||
       (GRPC_TRACE_FLAG_ENABLED(grpc_trace_operation_failures) &&
-       error != GRPC_ERROR_NONE)) {
+       !GRPC_ERROR_IS_NONE(error))) {
     std::string errmsg = grpc_error_std_string(error).c_str();
     GRPC_API_TRACE(
         "cq_end_op_for_pluck(cq=%p, tag=%p, error=%s, "
         "done=%p, done_arg=%p, storage=%p)",
         6, (cq, tag, errmsg.c_str(), done, done_arg, storage));
     if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_operation_failures) &&
-        error != GRPC_ERROR_NONE) {
+        !GRPC_ERROR_IS_NONE(error)) {
       gpr_log(GPR_ERROR, "Operation failed: tag=%p, error=%s", tag,
               errmsg.c_str());
     }
@@ -811,7 +820,7 @@ static void cq_end_op_for_pluck(
     grpc_error_handle kick_error =
         cq->poller_vtable->kick(POLLSET_FROM_CQ(cq), pluck_worker);
     gpr_mu_unlock(cq->mu);
-    if (kick_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(kick_error)) {
       gpr_log(GPR_ERROR, "Kick failed: %s",
               grpc_error_std_string(kick_error).c_str());
       GRPC_ERROR_UNREF(kick_error);
@@ -823,7 +832,7 @@ static void cq_end_op_for_pluck(
 
 static void functor_callback(void* arg, grpc_error_handle error) {
   auto* functor = static_cast<grpc_completion_queue_functor*>(arg);
-  functor->functor_run(functor, error == GRPC_ERROR_NONE);
+  functor->functor_run(functor, GRPC_ERROR_IS_NONE(error));
 }
 
 /* Complete an event on a completion queue of type GRPC_CQ_CALLBACK */
@@ -837,14 +846,14 @@ static void cq_end_op_for_callback(
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_api_trace) ||
       (GRPC_TRACE_FLAG_ENABLED(grpc_trace_operation_failures) &&
-       error != GRPC_ERROR_NONE)) {
+       !GRPC_ERROR_IS_NONE(error))) {
     std::string errmsg = grpc_error_std_string(error);
     GRPC_API_TRACE(
         "cq_end_op_for_callback(cq=%p, tag=%p, error=%s, "
         "done=%p, done_arg=%p, storage=%p)",
         6, (cq, tag, errmsg.c_str(), done, done_arg, storage));
     if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_operation_failures) &&
-        error != GRPC_ERROR_NONE) {
+        !GRPC_ERROR_IS_NONE(error)) {
       gpr_log(GPR_ERROR, "Operation failed: tag=%p, error=%s", tag,
               errmsg.c_str());
     }
@@ -871,7 +880,7 @@ static void cq_end_op_for_callback(
        grpc_core::ApplicationCallbackExecCtx::Available()) ||
       grpc_iomgr_is_any_background_poller_thread()) {
     grpc_core::ApplicationCallbackExecCtx::Enqueue(functor,
-                                                   (error == GRPC_ERROR_NONE));
+                                                   (GRPC_ERROR_IS_NONE(error)));
     GRPC_ERROR_UNREF(error);
     return;
   }
@@ -1048,7 +1057,7 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
         POLLSET_FROM_CQ(cq), nullptr, iteration_deadline);
     gpr_mu_unlock(cq->mu);
 
-    if (err != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(err)) {
       gpr_log(GPR_ERROR, "Completion queue next failed: %s",
               grpc_error_std_string(err).c_str());
       GRPC_ERROR_UNREF(err);
@@ -1293,7 +1302,7 @@ static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag,
     cq->num_polls++;
     grpc_error_handle err =
         cq->poller_vtable->work(POLLSET_FROM_CQ(cq), &worker, deadline_millis);
-    if (err != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(err)) {
       del_plucker(cq, tag, &worker);
       gpr_mu_unlock(cq->mu);
       gpr_log(GPR_ERROR, "Completion queue pluck failed: %s",

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

@@ -23,10 +23,14 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/grpc.h>
+#include <stdint.h>
+
+#include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
+#include "src/core/lib/gprpp/mpscq.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/pollset.h"
 
 /* These trace flags default to 1. The corresponding lines are only traced
@@ -37,7 +41,8 @@ extern grpc_core::DebugOnlyTraceFlag grpc_trace_pending_tags;
 extern grpc_core::DebugOnlyTraceFlag grpc_trace_cq_refcount;
 
 typedef struct grpc_cq_completion {
-  grpc_core::ManualConstructor<grpc_core::MultiProducerSingleConsumerQueue>
+  grpc_core::ManualConstructor<
+      grpc_core::MultiProducerSingleConsumerQueue::Node>
       node;
 
   /** user supplied tag */

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

@@ -20,6 +20,7 @@
 
 #include "src/core/lib/surface/completion_queue_factory.h"
 
+#include <grpc/grpc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/surface/completion_queue.h"

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

@@ -21,9 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/grpc.h>
-
-#include "src/core/lib/surface/completion_queue.h"
+#include <grpc/impl/codegen/grpc_types.h>
 
 typedef struct grpc_completion_queue_factory_vtable {
   grpc_completion_queue* (*create)(const grpc_completion_queue_factory*,

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

@@ -20,18 +20,12 @@
 
 #include "src/core/lib/surface/event_string.h"
 
-#include <stdio.h>
-
+#include <algorithm>
 #include <vector>
 
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
-#include <grpc/byte_buffer.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/string.h"
-
 static void addhdr(grpc_event* ev, std::vector<std::string>* buf) {
   buf->push_back(absl::StrFormat("tag:%p", ev->tag));
 }

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

@@ -23,7 +23,7 @@
 
 #include <string>
 
-#include <grpc/grpc.h>
+#include <grpc/impl/codegen/grpc_types.h>
 
 /* Returns a string describing an event. Must be later freed with gpr_free() */
 std::string grpc_event_string(grpc_event* ev);

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

@@ -21,49 +21,39 @@
 #include "src/core/lib/surface/init.h"
 
 #include <limits.h>
-#include <memory.h>
-#include <string.h>
+#include <stdint.h>
+
+#include "absl/base/thread_annotations.h"
 
 #include <grpc/fork.h>
 #include <grpc/grpc.h>
-#include <grpc/support/alloc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.h>
+#include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
-#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/channel_args.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/iomgr/call_combiner.h"
-#include "src/core/lib/iomgr/combiner.h"
+#include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/executor.h"
 #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/channel_init.h"
+#include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/completion_queue.h"
-#include "src/core/lib/surface/lame_client.h"
-#include "src/core/lib/surface/server.h"
-#include "src/core/lib/transport/bdp_estimator.h"
-#include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/transport_impl.h"
 
 /* (generated) built in registry of plugins */
 extern void grpc_register_built_in_plugins(void);
@@ -82,41 +72,25 @@ 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;
-      }
-    }
+  if (builder->channel_args().Contains(GRPC_ARG_SECURITY_CONNECTOR)) {
+    builder->PrependFilter(&grpc_core::ClientAuthFilter::kFilter);
   }
   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;
-      }
-    }
+  if (builder->channel_args().Contains(GRPC_SERVER_CREDENTIALS_ARG)) {
+    builder->PrependFilter(&grpc_server_auth_filter);
   }
   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);
+  if (builder->channel_args().GetPointer<grpc_authorization_policy_provider>(
+          GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER) != nullptr) {
+    builder->PrependFilter(&grpc_core::GrpcServerAuthzFilter::kFilterVtable);
   }
   return true;
 }
@@ -180,7 +154,6 @@ void grpc_init(void) {
     grpc_core::Fork::GlobalInit();
     grpc_fork_handlers_auto_register();
     grpc_stats_init();
-    grpc_core::channelz::ChannelzRegistry::Init();
     grpc_core::ApplicationCallbackExecCtx::GlobalInit();
     grpc_iomgr_init();
     gpr_timers_global_init();
@@ -213,8 +186,6 @@ void grpc_shutdown_internal_locked(void)
     grpc_iomgr_shutdown();
     gpr_timers_global_destroy();
     grpc_tracer_shutdown();
-    grpc_core::channelz::ChannelzRegistry::Shutdown();
-    grpc_stats_shutdown();
     grpc_core::Fork::GlobalShutdown();
   }
   grpc_core::ApplicationCallbackExecCtx::GlobalShutdown();

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

@@ -20,14 +20,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <memory>
-
-namespace grpc_event_engine {
-namespace experimental {
-class EventEngine;
-}
-}  // namespace grpc_event_engine
-
 void grpc_maybe_wait_for_async_shutdown(void);
 
 #endif /* GRPC_CORE_LIB_SURFACE_INIT_H */