grpc 1.70.1 → 1.72.0

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

@@ -30,12 +30,12 @@
 
 #include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
+#include "src/core/call/call_filters.h"
+#include "src/core/call/interception_chain.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/call_filters.h"
-#include "src/core/lib/transport/interception_chain.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/unique_type_name.h"
 

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

@@ -17,18 +17,17 @@
 //
 #include "src/core/lib/surface/completion_queue.h"
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
-#include <inttypes.h>
 #include <stdio.h>
 
 #include <algorithm>
 #include <atomic>
-#include <new>
 #include <string>
 #include <utility>
 #include <vector>
@@ -38,11 +37,9 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
-#include "src/core/lib/event_engine/default_event_engine.h"
+#include "src/core/lib/event_engine/shim.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/surface/event_string.h"
 #include "src/core/telemetry/stats.h"
@@ -54,10 +51,6 @@
 #include "src/core/util/status_helper.h"
 #include "src/core/util/time.h"
 
-#ifdef GPR_WINDOWS
-#include "src/core/lib/experiments/experiments.h"
-#endif
-
 namespace {
 
 // Specifies a cq thread local cache.
@@ -73,7 +66,7 @@ struct plucker {
   void* tag;
 };
 struct cq_poller_vtable {
-  bool can_get_pollset;
+  bool (*can_get_pollset)();
   bool can_listen;
   size_t (*size)(void);
   void (*init)(grpc_pollset* pollset, gpr_mu** mu);
@@ -186,16 +179,83 @@ void non_polling_poller_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
   }
 }
 
+bool non_polling_poller_can_never_get_pollset() { return false; }
+
+bool maybe_event_engine_poller_can_get_pollset() {
+  return !grpc_event_engine::experimental::UsePollsetAlternative();
+}
+
+// maybe_event_engine*: If iomgr isn't relied upon for polling, then we can use
+// the non-polling poller implementations below.
+size_t maybe_event_engine_poller_size(void) {
+  if (grpc_event_engine::experimental::UsePollsetAlternative()) {
+    return non_polling_poller_size();
+  } else {
+    return grpc_pollset_size();
+  }
+}
+
+void maybe_event_engine_poller_init(grpc_pollset* pollset, gpr_mu** mu) {
+  if (grpc_event_engine::experimental::UsePollsetAlternative()) {
+    non_polling_poller_init(pollset, mu);
+  } else {
+    grpc_pollset_init(pollset, mu);
+  }
+}
+
+void maybe_event_engine_poller_destroy(grpc_pollset* pollset) {
+  if (grpc_event_engine::experimental::UsePollsetAlternative()) {
+    non_polling_poller_destroy(pollset);
+  } else {
+    grpc_pollset_destroy(pollset);
+  }
+}
+
+grpc_error_handle maybe_event_engine_pollset_work(
+    grpc_pollset* pollset, grpc_pollset_worker** worker,
+    grpc_core::Timestamp deadline) {
+  if (grpc_event_engine::experimental::UsePollsetAlternative()) {
+    return non_polling_poller_work(pollset, worker, deadline);
+  } else {
+    return grpc_pollset_work(pollset, worker, deadline);
+  }
+}
+
+grpc_error_handle maybe_event_engine_poller_kick(
+    grpc_pollset* pollset, grpc_pollset_worker* specific_worker) {
+  if (grpc_event_engine::experimental::UsePollsetAlternative()) {
+    return non_polling_poller_kick(pollset, specific_worker);
+  } else {
+    return grpc_pollset_kick(pollset, specific_worker);
+  }
+}
+
+void maybe_event_engine_poller_shutdown(grpc_pollset* pollset,
+                                        grpc_closure* closure) {
+  if (grpc_event_engine::experimental::UsePollsetAlternative()) {
+    non_polling_poller_shutdown(pollset, closure);
+  } else {
+    grpc_pollset_shutdown(pollset, closure);
+  }
+}
+
+// TODO(hork): Once EE is the default everywhere, the only variations will be
+// the bool args controlling whether the poller can get a pollset and whether it
+// can listen.
 const cq_poller_vtable g_poller_vtable_by_poller_type[] = {
     // GRPC_CQ_DEFAULT_POLLING
-    {true, true, grpc_pollset_size, grpc_pollset_init, grpc_pollset_kick,
-     grpc_pollset_work, grpc_pollset_shutdown, grpc_pollset_destroy},
+    {maybe_event_engine_poller_can_get_pollset, true,
+     maybe_event_engine_poller_size, maybe_event_engine_poller_init,
+     maybe_event_engine_poller_kick, maybe_event_engine_pollset_work,
+     maybe_event_engine_poller_shutdown, maybe_event_engine_poller_destroy},
     // GRPC_CQ_NON_LISTENING
-    {true, false, grpc_pollset_size, grpc_pollset_init, grpc_pollset_kick,
-     grpc_pollset_work, grpc_pollset_shutdown, grpc_pollset_destroy},
+    {maybe_event_engine_poller_can_get_pollset, false,
+     maybe_event_engine_poller_size, maybe_event_engine_poller_init,
+     maybe_event_engine_poller_kick, maybe_event_engine_pollset_work,
+     maybe_event_engine_poller_shutdown, maybe_event_engine_poller_destroy},
     // GRPC_CQ_NON_POLLING
-    {false, false, non_polling_poller_size, non_polling_poller_init,
-     non_polling_poller_kick, non_polling_poller_work,
+    {non_polling_poller_can_never_get_pollset, false, non_polling_poller_size,
+     non_polling_poller_init, non_polling_poller_kick, non_polling_poller_work,
      non_polling_poller_shutdown, non_polling_poller_destroy},
 };
 
@@ -816,16 +876,12 @@ 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.ok());
-}
-
 // Complete an event on a completion queue of type GRPC_CQ_CALLBACK
 static void cq_end_op_for_callback(
     grpc_completion_queue* cq, void* tag, grpc_error_handle error,
     void (*done)(void* done_arg, grpc_cq_completion* storage), void* done_arg,
     grpc_cq_completion* storage, bool internal) {
+  (void)internal;
   cq_callback_data* cqd = static_cast<cq_callback_data*> DATA_FROM_CQ(cq);
 
   if (GRPC_TRACE_FLAG_ENABLED(api) ||
@@ -851,32 +907,11 @@ static void cq_end_op_for_callback(
   }
 
   auto* functor = static_cast<grpc_completion_queue_functor*>(tag);
-  if (grpc_core::IsEventEngineApplicationCallbacksEnabled()) {
-    // Run the callback on EventEngine threads.
-    cqd->event_engine->Run(
-        [engine = cqd->event_engine, functor, ok = error.ok()]() {
-          grpc_core::ExecCtx exec_ctx;
-          (*functor->functor_run)(functor, ok);
-        });
-    return;
-  }
-  // If possible, schedule the callback onto an existing thread-local
-  // ApplicationCallbackExecCtx, which is a work queue. This is possible for:
-  // 1. The callback is internally-generated and there is an ACEC available
-  // 2. The callback is marked inlineable and there is an ACEC available
-  // 3. We are already running in a background poller thread (which always has
-  //    an ACEC available at the base of the stack).
-  if (((internal || functor->inlineable) &&
-       grpc_core::ApplicationCallbackExecCtx::Available()) ||
-      grpc_iomgr_is_any_background_poller_thread()) {
-    grpc_core::ApplicationCallbackExecCtx::Enqueue(functor, (error.ok()));
-    return;
-  }
-
-  // Schedule the callback on a closure if not internal or triggered
-  // from a background poller thread.
-  grpc_core::Executor::Run(
-      GRPC_CLOSURE_CREATE(functor_callback, functor, nullptr), error);
+  cqd->event_engine->Run(
+      [engine = cqd->event_engine, functor, ok = error.ok()]() {
+        grpc_core::ExecCtx exec_ctx;
+        (*functor->functor_run)(functor, ok);
+      });
 }
 
 void grpc_cq_end_op(grpc_completion_queue* cq, void* tag,
@@ -1347,23 +1382,10 @@ static void cq_finish_shutdown_callback(grpc_completion_queue* cq) {
 
   cq->poller_vtable->shutdown(POLLSET_FROM_CQ(cq), &cq->pollset_shutdown_done);
 
-  if (grpc_core::IsEventEngineApplicationCallbacksEnabled()) {
-    cqd->event_engine->Run([engine = cqd->event_engine, callback]() {
-      grpc_core::ExecCtx exec_ctx;
-      callback->functor_run(callback, /*true=*/1);
-    });
-    return;
-  }
-  if (grpc_iomgr_is_any_background_poller_thread()) {
-    grpc_core::ApplicationCallbackExecCtx::Enqueue(callback, true);
-    return;
-  }
-
-  // Schedule the callback on a closure if not internal or triggered
-  // from a background poller thread.
-  grpc_core::Executor::Run(
-      GRPC_CLOSURE_CREATE(functor_callback, callback, nullptr),
-      absl::OkStatus());
+  cqd->event_engine->Run([engine = cqd->event_engine, callback]() {
+    grpc_core::ExecCtx exec_ctx;
+    callback->functor_run(callback, /*true=*/1);
+  });
 }
 
 static void cq_shutdown_callback(grpc_completion_queue* cq) {
@@ -1395,7 +1417,6 @@ static void cq_shutdown_callback(grpc_completion_queue* cq) {
 // Shutdown simply drops a ref that we reserved at creation time; if we drop
 // to zero here, then enter shutdown mode and wake up any waiters
 void grpc_completion_queue_shutdown(grpc_completion_queue* cq) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_completion_queue_shutdown(cq=" << cq << ")";
@@ -1411,7 +1432,7 @@ void grpc_completion_queue_destroy(grpc_completion_queue* cq) {
 }
 
 grpc_pollset* grpc_cq_pollset(grpc_completion_queue* cq) {
-  return cq->poller_vtable->can_get_pollset ? POLLSET_FROM_CQ(cq) : nullptr;
+  return cq->poller_vtable->can_get_pollset() ? POLLSET_FROM_CQ(cq) : nullptr;
 }
 
 bool grpc_cq_can_listen(grpc_completion_queue* cq) {

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

@@ -42,6 +42,7 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
@@ -57,7 +58,6 @@
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/server/server_interface.h"
 #include "src/core/telemetry/call_tracer.h"
@@ -114,6 +114,7 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
   *out_call = call->c_ptr();
   grpc_slice path = grpc_empty_slice();
   ScopedContext ctx(call);
+  Call* parent = Call::FromC(args->parent);
   if (call->is_client()) {
     call->final_op_.client.status_details = nullptr;
     call->final_op_.client.status = nullptr;
@@ -129,8 +130,15 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
     call->send_initial_metadata_.Set(
         GrpcRegisteredMethod(), reinterpret_cast<void*>(static_cast<uintptr_t>(
                                     args->registered_method)));
-    channel_stack->stats_plugin_group->AddClientCallTracers(
-        Slice(CSliceRef(path)), args->registered_method, arena.get());
+    if (parent != nullptr) {
+      add_init_error(&error, absl_status_to_grpc_error(call->InitParent(
+                                 parent, args->propagation_mask)));
+    }
+    // Client call tracers should be created after propagating relevant
+    // properties (tracing included) from the parent.
+    (*channel_stack->stats_plugin_group)
+        ->AddClientCallTracers(Slice(CSliceRef(path)), args->registered_method,
+                               arena.get());
   } else {
     global_stats().IncrementServerCallsCreated();
     call->final_op_.server.cancelled = nullptr;
@@ -157,19 +165,14 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
         arena->SetContext<CallTracerInterface>(server_call_tracer);
       }
     }
-    channel_stack->stats_plugin_group->AddServerCallTracers(arena.get());
+    (*channel_stack->stats_plugin_group)->AddServerCallTracers(arena.get());
   }
 
-  Call* parent = Call::FromC(args->parent);
-  if (parent != nullptr) {
-    add_init_error(&error, absl_status_to_grpc_error(call->InitParent(
-                               parent, args->propagation_mask)));
-  }
   // initial refcount dropped by grpc_call_unref
   grpc_call_element_args call_args = {
-      call->call_stack(),   args->server_transport_data, path,
-      call->start_time(),   call->send_deadline(),       call->arena(),
-      &call->call_combiner_};
+      call->call_stack(), args->server_transport_data,
+      call->start_time(), call->send_deadline(),
+      call->arena(),      &call->call_combiner_};
   add_init_error(&error, grpc_call_stack_init(channel_stack, 1, DestroyCall,
                                               call, &call_args));
   // Publish this call to parent only after the call stack has been initialized.
@@ -263,7 +266,6 @@ void FilterStackCall::DestroyCall(void* call, grpc_error_handle /*error*/) {
 void FilterStackCall::ExternalUnref() {
   if (GPR_LIKELY(!ext_ref_.Unref())) return;
 
-  ApplicationCallbackExecCtx callback_exec_ctx;
   ExecCtx exec_ctx;
 
   GRPC_TRACE_LOG(api, INFO) << "grpc_call_unref(c=" << this << ")";
@@ -274,7 +276,7 @@ void FilterStackCall::ExternalUnref() {
   destroy_called_ = true;
   bool cancel = gpr_atm_acq_load(&received_final_op_atm_) == 0;
   if (cancel) {
-    CancelWithError(absl::CancelledError());
+    CancelWithError(absl::CancelledError("CANCELLED"));
   } else {
     // Unset the call combiner cancellation closure.  This has the
     // effect of scheduling the previously set cancellation closure, if
@@ -450,24 +452,33 @@ void FilterStackCall::RecvTrailingFilter(grpc_metadata_batch* b,
   if (!batch_error.ok()) {
     SetFinalStatus(batch_error);
   } else {
-    absl::optional<grpc_status_code> grpc_status =
-        b->Take(GrpcStatusMetadata());
+    std::optional<grpc_status_code> grpc_status = b->Take(GrpcStatusMetadata());
     if (grpc_status.has_value()) {
-      grpc_status_code status_code = *grpc_status;
       grpc_error_handle error;
-      if (status_code != GRPC_STATUS_OK) {
-        Slice peer = GetPeerString();
-        error = grpc_error_set_int(
-            GRPC_ERROR_CREATE(absl::StrCat("Error received from peer ",
-                                           peer.as_string_view())),
-            StatusIntProperty::kRpcStatus, static_cast<intptr_t>(status_code));
-      }
-      auto grpc_message = b->Take(GrpcMessageMetadata());
-      if (grpc_message.has_value()) {
-        error = grpc_error_set_str(error, StatusStrProperty::kGrpcMessage,
-                                   grpc_message->as_string_view());
-      } else if (!error.ok()) {
-        error = grpc_error_set_str(error, StatusStrProperty::kGrpcMessage, "");
+      if (IsErrorFlattenEnabled()) {
+        auto grpc_message = b->Take(GrpcMessageMetadata());
+        absl::string_view message;
+        if (grpc_message.has_value()) message = grpc_message->as_string_view();
+        error =
+            absl::Status(static_cast<absl::StatusCode>(*grpc_status), message);
+      } else {
+        grpc_status_code status_code = *grpc_status;
+        if (status_code != GRPC_STATUS_OK) {
+          Slice peer = GetPeerString();
+          error = grpc_error_set_int(
+              GRPC_ERROR_CREATE(absl::StrCat("Error received from peer ",
+                                             peer.as_string_view())),
+              StatusIntProperty::kRpcStatus,
+              static_cast<intptr_t>(status_code));
+        }
+        auto grpc_message = b->Take(GrpcMessageMetadata());
+        if (grpc_message.has_value()) {
+          error = grpc_error_set_str(error, StatusStrProperty::kGrpcMessage,
+                                     grpc_message->as_string_view());
+        } else if (!error.ok()) {
+          error =
+              grpc_error_set_str(error, StatusStrProperty::kGrpcMessage, "");
+        }
       }
       SetFinalStatus(error);
     } else if (!is_client()) {
@@ -658,7 +669,7 @@ void FilterStackCall::BatchControl::ReceivingInitialMetadataReady(
     grpc_metadata_batch* md = &call->recv_initial_metadata_;
     call->RecvInitialFilter(md);
 
-    absl::optional<Timestamp> deadline = md->get(GrpcTimeoutMetadata());
+    std::optional<Timestamp> deadline = md->get(GrpcTimeoutMetadata());
     if (deadline.has_value() && !call->is_client()) {
       call_->set_send_deadline(*deadline);
     }

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

@@ -42,6 +42,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/polling_entity.h"
@@ -51,7 +52,6 @@
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/server/server_interface.h"
 #include "src/core/telemetry/call_tracer.h"
@@ -300,7 +300,7 @@ class FilterStackCall final : public Call {
   grpc_call_final_info final_info_;
 
   SliceBuffer send_slice_buffer_;
-  absl::optional<SliceBuffer> receiving_slice_buffer_;
+  std::optional<SliceBuffer> receiving_slice_buffer_;
   uint32_t receiving_stream_flags_;
   uint32_t test_only_last_message_flags_ = 0;
   // Compression algorithm for *incoming* data

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

@@ -33,6 +33,8 @@
 #include "absl/time/time.h"
 #include "src/core/client_channel/backup_poller.h"
 #include "src/core/config/core_configuration.h"
+#include "src/core/credentials/transport/security_connector.h"
+#include "src/core/filter/auth/auth_filters.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
 #include "src/core/lib/experiments/config.h"
@@ -41,9 +43,6 @@
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/timer_manager.h"
 #include "src/core/lib/security/authorization/grpc_server_authz_filter.h"
-#include "src/core/lib/security/credentials/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/surface/channel_stack_type.h"
 #include "src/core/lib/surface/init_internally.h"
 #include "src/core/util/fork.h"
@@ -72,12 +71,21 @@ static bool g_shutting_down ABSL_GUARDED_BY(g_init_mu) = false;
 
 namespace grpc_core {
 void RegisterSecurityFilters(CoreConfiguration::Builder* builder) {
-  builder->channel_init()
-      ->RegisterV2Filter<ClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
-      .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
-  builder->channel_init()
-      ->RegisterV2Filter<ClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
-      .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
+  if (IsCallv3ClientAuthFilterEnabled()) {
+    builder->channel_init()
+        ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
+        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
+    builder->channel_init()
+        ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
+        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
+  } else {
+    builder->channel_init()
+        ->RegisterV2Filter<LegacyClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
+        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
+    builder->channel_init()
+        ->RegisterV2Filter<LegacyClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
+        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
+  }
   builder->channel_init()
       ->RegisterFilter<ServerAuthFilter>(GRPC_SERVER_CHANNEL)
       .IfHasChannelArg(GRPC_SERVER_CREDENTIALS_ARG);
@@ -168,14 +176,9 @@ void grpc_shutdown(void) {
   grpc_core::MutexLock lock(g_init_mu);
 
   if (--g_initializations == 0) {
-    grpc_core::ApplicationCallbackExecCtx* acec =
-        grpc_core::ApplicationCallbackExecCtx::Get();
     if (!grpc_iomgr_is_any_background_poller_thread() &&
         !grpc_event_engine::experimental::TimerManager::
             IsTimerManagerThread() &&
-        (acec == nullptr ||
-         (acec->Flags() & GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD) ==
-             0) &&
         grpc_core::ExecCtx::Get() == nullptr) {
       // just run clean-up when this is called on non-executor thread.
       VLOG(2) << "grpc_shutdown starts clean-up now";
@@ -229,7 +232,8 @@ bool grpc_wait_for_shutdown_with_timeout(absl::Duration timeout) {
   grpc_core::MutexLock lock(g_init_mu);
   while (g_initializations != 0) {
     if (g_shutting_down_cv->WaitWithDeadline(g_init_mu, deadline)) {
-      LOG(ERROR) << "grpc_wait_for_shutdown_with_timeout() timed out.";
+      GRPC_TRACE_LOG(api, ERROR)
+          << "grpc_wait_for_shutdown_with_timeout() timed out.";
       return false;
     }
   }

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

@@ -28,6 +28,7 @@
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_args_preconditioning.h"
@@ -40,7 +41,6 @@
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/ref_counted_ptr.h"

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

@@ -24,11 +24,12 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/port_platform.h>
 
+#include <optional>
+
 #include "absl/base/thread_annotations.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
-#include "absl/types/optional.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/config/core_configuration.h"
@@ -70,26 +71,10 @@ absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
       args = channel_args_mutator(target.c_str(), args, channel_stack_type);
     }
   }
-  ChannelStackBuilderImpl builder(
-      grpc_channel_stack_type_string(channel_stack_type), channel_stack_type,
-      args);
-  builder.SetTarget(target.c_str());
-  if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
-    return nullptr;
-  }
-  // Only need to update stats for server channels here.  Stats for client
-  // channels are handled in our base class.
-  if (builder.channel_stack_type() == GRPC_SERVER_CHANNEL) {
-    global_stats().IncrementServerChannelsCreated();
-  }
-  absl::StatusOr<RefCountedPtr<grpc_channel_stack>> r = builder.Build();
-  if (!r.ok()) {
-    auto status = r.status();
-    LOG(ERROR) << "channel stack builder failed: " << status;
-    return status;
-  }
+  std::shared_ptr<GlobalStatsPluginRegistry::StatsPluginGroup>
+      stats_plugin_group;
   if (channel_stack_type == GRPC_SERVER_CHANNEL) {
-    *(*r)->stats_plugin_group =
+    stats_plugin_group =
         GlobalStatsPluginRegistry::GetStatsPluginsForServer(args);
     // Add per-server stats plugins.
     auto* stats_plugin_list = args.GetPointer<
@@ -97,8 +82,8 @@ absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
         GRPC_ARG_EXPERIMENTAL_STATS_PLUGINS);
     if (stats_plugin_list != nullptr) {
       for (const auto& plugin : **stats_plugin_list) {
-        (*r)->stats_plugin_group->AddStatsPlugin(
-            plugin, plugin->GetServerScopeConfig(args));
+        stats_plugin_group->AddStatsPlugin(plugin,
+                                           plugin->GetServerScopeConfig(args));
       }
     }
   } else {
@@ -110,7 +95,7 @@ absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
         args);
     experimental::StatsPluginChannelScope scope(target, authority,
                                                 endpoint_config);
-    *(*r)->stats_plugin_group =
+    stats_plugin_group =
         GlobalStatsPluginRegistry::GetStatsPluginsForChannel(scope);
     // Add per-channel stats plugins.
     auto* stats_plugin_list = args.GetPointer<
@@ -118,11 +103,31 @@ absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
         GRPC_ARG_EXPERIMENTAL_STATS_PLUGINS);
     if (stats_plugin_list != nullptr) {
       for (const auto& plugin : **stats_plugin_list) {
-        (*r)->stats_plugin_group->AddStatsPlugin(
+        stats_plugin_group->AddStatsPlugin(
             plugin, plugin->GetChannelScopeConfig(scope));
       }
     }
   }
+  args = args.SetObject(stats_plugin_group);
+  ChannelStackBuilderImpl builder(
+      grpc_channel_stack_type_string(channel_stack_type), channel_stack_type,
+      args);
+  builder.SetTarget(target.c_str());
+  if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
+    return nullptr;
+  }
+  // Only need to update stats for server channels here.  Stats for client
+  // channels are handled in our base class.
+  if (builder.channel_stack_type() == GRPC_SERVER_CHANNEL) {
+    global_stats().IncrementServerChannelsCreated();
+  }
+  absl::StatusOr<RefCountedPtr<grpc_channel_stack>> r = builder.Build();
+  if (!r.ok()) {
+    auto status = r.status();
+    LOG(ERROR) << "channel stack builder failed: " << status;
+    return status;
+  }
+  *(*r)->stats_plugin_group = std::move(stats_plugin_group);
   return MakeRefCounted<LegacyChannel>(
       grpc_channel_stack_type_is_client(builder.channel_stack_type()),
       std::move(target), args, std::move(*r));
@@ -178,11 +183,13 @@ bool LegacyChannel::IsLame() const {
   return elem->filter == &LameClientFilter::kFilter;
 }
 
-grpc_call* LegacyChannel::CreateCall(
-    grpc_call* parent_call, uint32_t propagation_mask,
-    grpc_completion_queue* cq, grpc_pollset_set* pollset_set_alternative,
-    Slice path, absl::optional<Slice> authority, Timestamp deadline,
-    bool registered_method) {
+grpc_call* LegacyChannel::CreateCall(grpc_call* parent_call,
+                                     uint32_t propagation_mask,
+                                     grpc_completion_queue* cq,
+                                     grpc_pollset_set* pollset_set_alternative,
+                                     Slice path, std::optional<Slice> authority,
+                                     Timestamp deadline,
+                                     bool registered_method) {
   CHECK(is_client_);
   CHECK(!(cq != nullptr && pollset_set_alternative != nullptr));
   grpc_call_create_args args;
@@ -286,7 +293,6 @@ class LegacyChannel::StateWatcher final : public DualRefCounted<StateWatcher> {
     MutexLock lock(&mu_);
     timer_handle_ =
         channel_->event_engine()->RunAfter(timeout, [self = Ref()]() mutable {
-          ApplicationCallbackExecCtx callback_exec_ctx;
           ExecCtx exec_ctx;
           self->TimeoutComplete();
           // StateWatcher deletion might require an active ExecCtx.
@@ -343,7 +349,7 @@ class LegacyChannel::StateWatcher final : public DualRefCounted<StateWatcher> {
   // timer callback fired immediately on an EventEngine thread before
   // RunAfter() returns.
   Mutex mu_;
-  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+  std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
       timer_handle_ ABSL_GUARDED_BY(mu_);
   bool timer_fired_ = false;
 };