grpc 1.70.1 → 1.71.0

data/src/core/lib/security/transport/auth_filters.h

@@ -29,6 +29,7 @@
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/security_connector/security_connector.h"
@@ -38,7 +39,7 @@
 namespace grpc_core {
 
 // Handles calling out to credentials to fill in metadata per call.
-class ClientAuthFilter final : public ChannelFilter {
+class ClientAuthFilter final : public ImplementChannelFilter<ClientAuthFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
@@ -51,6 +52,93 @@ class ClientAuthFilter final : public ChannelFilter {
   static absl::StatusOr<std::unique_ptr<ClientAuthFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args);
 
+ private:
+  // These methods are early in the declaration order as auto return type is
+  // needed by Call.
+  auto GetMetadataFromCreds(RefCountedPtr<grpc_call_credentials> creds,
+                            ClientMetadataHandle md) {
+    return Map(creds->GetRequestMetadata(std::move(md), &args_),
+               [](absl::StatusOr<ClientMetadataHandle> new_metadata) mutable {
+                 if (!new_metadata.ok()) {
+                   return absl::StatusOr<ClientMetadataHandle>(
+                       MaybeRewriteIllegalStatusCode(new_metadata.status(),
+                                                     "call credentials"));
+                 }
+                 return new_metadata;
+               });
+  }
+
+  auto GetCallCredsMetadata(ClientMetadataHandle md) {
+    auto creds = GetCallCreds();
+    return If(
+        creds.ok(),
+        [this, &creds, md = std::move(md)]() mutable {
+          return If(
+              *creds != nullptr,
+              [this, &creds, &md]() {
+                return GetMetadataFromCreds(std::move(*creds), std::move(md));
+              },
+              [&md]() {
+                return Immediate(
+                    absl::StatusOr<ClientMetadataHandle>(std::move(md)));
+              });
+        },
+        [&creds]() {
+          return Immediate(
+              absl::StatusOr<ClientMetadataHandle>(creds.status()));
+        });
+  }
+
+ public:
+  class Call {
+   public:
+    auto OnClientInitialMetadata(ClientMetadataHandle md,
+                                 ClientAuthFilter* filter) {
+      filter->InstallContext();
+      auto* host = md->get_pointer(HttpAuthorityMetadata());
+      return WithResult<absl::StatusOr<ClientMetadataHandle>>(If(
+          host == nullptr,
+          [&md]() mutable -> absl::StatusOr<ClientMetadataHandle> {
+            return std::move(md);
+          },
+          [filter, host, &md]() mutable {
+            return TrySeq(
+                filter->args_.security_connector->CheckCallHost(
+                    host->as_string_view(), filter->args_.auth_context.get()),
+                [filter, md = std::move(md)]() mutable {
+                  return filter->GetCallCredsMetadata(std::move(md));
+                });
+          }));
+    }
+    static const inline NoInterceptor OnServerInitialMetadata;
+    static const inline NoInterceptor OnClientToServerMessage;
+    static const inline NoInterceptor OnClientToServerHalfClose;
+    static const inline NoInterceptor OnServerToClientMessage;
+    static const inline NoInterceptor OnServerTrailingMetadata;
+    static const inline NoInterceptor OnFinalize;
+  };
+
+ private:
+  void InstallContext();
+  absl::StatusOr<RefCountedPtr<grpc_call_credentials>> GetCallCreds();
+
+  // Contains refs to security connector and auth context.
+  grpc_call_credentials::GetRequestMetadataArgs args_;
+};
+
+class LegacyClientAuthFilter final : public ChannelFilter {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::string_view TypeName() { return "client-auth-filter"; }
+
+  LegacyClientAuthFilter(
+      RefCountedPtr<grpc_channel_security_connector> security_connector,
+      RefCountedPtr<grpc_auth_context> auth_context);
+
+  static absl::StatusOr<std::unique_ptr<ClientAuthFilter>> Create(
+      const ChannelArgs& args, ChannelFilter::Args);
+
   // Construct a promise for one call.
   ArenaPromise<ServerMetadataHandle> MakeCallPromise(
       CallArgs call_args, NextPromiseFactory next_promise_factory) override;
@@ -116,12 +204,12 @@ class ServerAuthFilter final : public ImplementChannelFilter<ServerAuthFilter> {
           ImmediateOkStatus(),
           [filter, md = &md]() { return RunApplicationCode(filter, *md); });
     }
-    static const NoInterceptor OnServerInitialMetadata;
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnServerTrailingMetadata;
-    static const NoInterceptor OnFinalize;
+    static inline const NoInterceptor OnServerInitialMetadata;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnServerTrailingMetadata;
+    static inline const NoInterceptor OnFinalize;
   };
 
  private:

data/src/core/lib/security/transport/client_auth_filter.cc

@@ -100,13 +100,103 @@ bool grpc_check_security_level(grpc_security_level channel_level,
 
 namespace grpc_core {
 
+// ClientAuthFilter
+
 ClientAuthFilter::ClientAuthFilter(
     RefCountedPtr<grpc_channel_security_connector> security_connector,
     RefCountedPtr<grpc_auth_context> auth_context)
     : args_{std::move(security_connector), std::move(auth_context)} {}
 
-ArenaPromise<absl::StatusOr<CallArgs>> ClientAuthFilter::GetCallCredsMetadata(
-    CallArgs call_args) {
+absl::StatusOr<RefCountedPtr<grpc_call_credentials>>
+ClientAuthFilter::GetCallCreds() {
+  auto* ctx = GetContext<grpc_client_security_context>();
+  grpc_call_credentials* channel_call_creds =
+      args_.security_connector->mutable_request_metadata_creds();
+  const bool call_creds_has_md = (ctx != nullptr) && (ctx->creds != nullptr);
+
+  if (channel_call_creds == nullptr && !call_creds_has_md) {
+    // Skip sending metadata altogether.
+    return nullptr;
+  }
+
+  RefCountedPtr<grpc_call_credentials> creds;
+  if (channel_call_creds != nullptr && call_creds_has_md) {
+    creds = RefCountedPtr<grpc_call_credentials>(
+        grpc_composite_call_credentials_create(channel_call_creds,
+                                               ctx->creds.get(), nullptr));
+    if (creds == nullptr) {
+      return absl::UnauthenticatedError(
+          "Incompatible credentials set on channel and call.");
+    }
+  } else if (call_creds_has_md) {
+    creds = ctx->creds->Ref();
+  } else {
+    creds = channel_call_creds->Ref();
+  }
+
+  // Check security level of call credential and channel, and do not send
+  // metadata if the check fails.
+  grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name(
+      args_.auth_context.get(), GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME);
+  const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);
+  if (prop == nullptr) {
+    return absl::UnauthenticatedError(
+        "Established channel does not have an auth "
+        "property representing a security level.");
+  }
+  const grpc_security_level call_cred_security_level =
+      creds->min_security_level();
+  const bool is_security_level_ok = grpc_check_security_level(
+      convert_security_level_string_to_enum(prop->value),
+      call_cred_security_level);
+  if (!is_security_level_ok) {
+    return absl::UnauthenticatedError(
+        "Established channel does not have a sufficient security level to "
+        "transfer call credential.");
+  }
+
+  return std::move(creds);
+}
+
+void ClientAuthFilter::InstallContext() {
+  auto* sec_ctx = MaybeGetContext<grpc_client_security_context>();
+  if (sec_ctx == nullptr) {
+    sec_ctx = grpc_client_security_context_create(GetContext<Arena>(),
+                                                  /*creds=*/nullptr);
+    SetContext<SecurityContext>(sec_ctx);
+  }
+  sec_ctx->auth_context = args_.auth_context;
+}
+
+absl::StatusOr<std::unique_ptr<ClientAuthFilter>> ClientAuthFilter::Create(
+    const ChannelArgs& args, ChannelFilter::Args) {
+  auto* sc = args.GetObject<grpc_security_connector>();
+  if (sc == nullptr) {
+    return absl::InvalidArgumentError(
+        "Security connector missing from client auth filter args");
+  }
+  auto* auth_context = args.GetObject<grpc_auth_context>();
+  if (auth_context == nullptr) {
+    return absl::InvalidArgumentError(
+        "Auth context missing from client auth filter args");
+  }
+  return std::make_unique<ClientAuthFilter>(
+      sc->RefAsSubclass<grpc_channel_security_connector>(),
+      auth_context->Ref());
+}
+
+const grpc_channel_filter ClientAuthFilter::kFilter =
+    MakePromiseBasedFilter<ClientAuthFilter, FilterEndpoint::kClient>();
+
+// LegacyClientAuthFilter
+
+LegacyClientAuthFilter::LegacyClientAuthFilter(
+    RefCountedPtr<grpc_channel_security_connector> security_connector,
+    RefCountedPtr<grpc_auth_context> auth_context)
+    : args_{std::move(security_connector), std::move(auth_context)} {}
+
+ArenaPromise<absl::StatusOr<CallArgs>>
+LegacyClientAuthFilter::GetCallCredsMetadata(CallArgs call_args) {
   auto* ctx = GetContext<grpc_client_security_context>();
   grpc_call_credentials* channel_call_creds =
       args_.security_connector->mutable_request_metadata_creds();
@@ -172,7 +262,7 @@ ArenaPromise<absl::StatusOr<CallArgs>> ClientAuthFilter::GetCallCredsMetadata(
       });
 }
 
-ArenaPromise<ServerMetadataHandle> ClientAuthFilter::MakeCallPromise(
+ArenaPromise<ServerMetadataHandle> LegacyClientAuthFilter::MakeCallPromise(
     CallArgs call_args, NextPromiseFactory next_promise_factory) {
   auto* sec_ctx = MaybeGetContext<grpc_client_security_context>();
   if (sec_ctx == nullptr) {
@@ -196,8 +286,8 @@ ArenaPromise<ServerMetadataHandle> ClientAuthFilter::MakeCallPromise(
       next_promise_factory);
 }
 
-absl::StatusOr<std::unique_ptr<ClientAuthFilter>> ClientAuthFilter::Create(
-    const ChannelArgs& args, ChannelFilter::Args) {
+absl::StatusOr<std::unique_ptr<ClientAuthFilter>>
+LegacyClientAuthFilter::Create(const ChannelArgs& args, ChannelFilter::Args) {
   auto* sc = args.GetObject<grpc_security_connector>();
   if (sc == nullptr) {
     return absl::InvalidArgumentError(
@@ -213,7 +303,7 @@ absl::StatusOr<std::unique_ptr<ClientAuthFilter>> ClientAuthFilter::Create(
       auth_context->Ref());
 }
 
-const grpc_channel_filter ClientAuthFilter::kFilter =
+const grpc_channel_filter LegacyClientAuthFilter::kFilter =
     MakePromiseBasedFilter<ClientAuthFilter, FilterEndpoint::kClient>();
 
 }  // namespace grpc_core

data/src/core/lib/security/transport/server_auth_filter.cc

@@ -63,13 +63,6 @@ namespace grpc_core {
 const grpc_channel_filter ServerAuthFilter::kFilter =
     MakePromiseBasedFilter<ServerAuthFilter, FilterEndpoint::kServer>();
 
-const NoInterceptor ServerAuthFilter::Call::OnClientToServerMessage;
-const NoInterceptor ServerAuthFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor ServerAuthFilter::Call::OnServerToClientMessage;
-const NoInterceptor ServerAuthFilter::Call::OnServerInitialMetadata;
-const NoInterceptor ServerAuthFilter::Call::OnServerTrailingMetadata;
-const NoInterceptor ServerAuthFilter::Call::OnFinalize;
-
 namespace {
 
 class ArrayEncoder {
@@ -151,7 +144,6 @@ void ServerAuthFilter::RunApplicationCode::OnMdProcessingDone(
     void* user_data, const grpc_metadata* consumed_md, size_t num_consumed_md,
     const grpc_metadata* response_md, size_t num_response_md,
     grpc_status_code status, const char* error_details) {
-  ApplicationCallbackExecCtx callback_exec_ctx;
   ExecCtx exec_ctx;
 
   auto* state = static_cast<State*>(user_data);

data/src/core/lib/slice/slice_buffer.cc

@@ -421,8 +421,8 @@ void grpc_slice_buffer_move_first_into_buffer(grpc_slice_buffer* src, size_t n,
   }
 }
 
-void grpc_slice_buffer_copy_first_into_buffer(grpc_slice_buffer* src, size_t n,
-                                              void* dst) {
+void grpc_slice_buffer_copy_first_into_buffer(const grpc_slice_buffer* src,
+                                              size_t n, void* dst) {
   uint8_t* dstp = static_cast<uint8_t*>(dst);
   CHECK(src->length >= n);
 

data/src/core/lib/slice/slice_buffer.h

@@ -27,8 +27,8 @@
 #include "src/core/lib/slice/slice.h"
 
 // Copy the first n bytes of src into memory pointed to by dst.
-void grpc_slice_buffer_copy_first_into_buffer(grpc_slice_buffer* src, size_t n,
-                                              void* dst);
+void grpc_slice_buffer_copy_first_into_buffer(const grpc_slice_buffer* src,
+                                              size_t n, void* dst);
 
 void grpc_slice_buffer_move_first_no_inline(grpc_slice_buffer* src, size_t n,
                                             grpc_slice_buffer* dst);

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

@@ -370,7 +370,6 @@ void Call::ResetDeadline() {
 }
 
 void Call::Run() {
-  ApplicationCallbackExecCtx callback_exec_ctx;
   ExecCtx exec_ctx;
   GRPC_TRACE_LOG(call, INFO)
       << "call deadline expired "
@@ -414,7 +413,6 @@ grpc_call_error grpc_call_cancel(grpc_call* call, void* reserved) {
   if (call == nullptr) {
     return GRPC_CALL_ERROR;
   }
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   grpc_core::Call::FromC(call)->CancelWithError(absl::CancelledError());
   return GRPC_CALL_OK;
@@ -431,7 +429,6 @@ grpc_call_error grpc_call_cancel_with_status(grpc_call* c,
   if (c == nullptr) {
     return GRPC_CALL_ERROR;
   }
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   grpc_core::Call::FromC(c)->CancelWithStatus(status, description);
   return GRPC_CALL_OK;
@@ -474,7 +471,6 @@ grpc_call_error grpc_call_start_batch(grpc_call* call, const grpc_op* ops,
   if (reserved != nullptr || call == nullptr) {
     return GRPC_CALL_ERROR;
   } else {
-    grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
     grpc_core::ExecCtx exec_ctx;
     return grpc_core::Call::FromC(call)->StartBatch(ops, nops, tag, false);
   }

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

@@ -26,11 +26,12 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <optional>
+
 #include "absl/functional/any_invocable.h"
 #include "absl/functional/function_ref.h"
 #include "absl/log/check.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
@@ -64,8 +65,8 @@ typedef struct grpc_call_create_args {
 
   const void* server_transport_data;
 
-  absl::optional<grpc_core::Slice> path;
-  absl::optional<grpc_core::Slice> authority;
+  std::optional<grpc_core::Slice> path;
+  std::optional<grpc_core::Slice> authority;
 
   grpc_core::Timestamp send_deadline;
   bool registered_method;  // client_only

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

@@ -122,7 +122,7 @@ Poll<Empty> WaitForCqEndOp::operator()() {
   GRPC_TRACE_LOG(promise_primitives, INFO)
       << Activity::current()->DebugTag() << "WaitForCqEndOp[" << this << "] "
       << StateString(state_);
-  if (auto* n = absl::get_if<NotStarted>(&state_)) {
+  if (auto* n = std::get_if<NotStarted>(&state_)) {
     if (n->is_closure) {
       ExecCtx::Run(DEBUG_LOCATION, static_cast<grpc_closure*>(n->tag),
                    std::move(n->error));
@@ -142,7 +142,7 @@ Poll<Empty> WaitForCqEndOp::operator()() {
           &started, &started.completion);
     }
   }
-  auto& started = absl::get<Started>(state_);
+  auto& started = std::get<Started>(state_);
   if (started.done.load(std::memory_order_acquire)) {
     return Empty{};
   } else {

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

@@ -197,14 +197,18 @@ class OpHandlerImpl {
   Poll<StatusFlag> operator()() {
     switch (state_) {
       case State::kDismissed:
+        GRPC_TRACE_LOG(call, INFO)
+            << Activity::current()->DebugTag() << "Dismissed " << OpName();
         return Success{};
       case State::kPromiseFactory: {
+        GRPC_TRACE_LOG(call, INFO)
+            << Activity::current()->DebugTag() << "Construct " << OpName();
         auto promise = promise_factory_.Make();
         Destruct(&promise_factory_);
         Construct(&promise_, std::move(promise));
         state_ = State::kPromise;
       }
-        ABSL_FALLTHROUGH_INTENDED;
+        [[fallthrough]];
       case State::kPromise: {
         GRPC_TRACE_LOG(call, INFO)
             << Activity::current()->DebugTag() << "BeginPoll " << OpName();
@@ -294,11 +298,11 @@ class WaitForCqEndOp {
   WaitForCqEndOp(const WaitForCqEndOp&) = delete;
   WaitForCqEndOp& operator=(const WaitForCqEndOp&) = delete;
   WaitForCqEndOp(WaitForCqEndOp&& other) noexcept
-      : state_(std::move(absl::get<NotStarted>(other.state_))) {
+      : state_(std::move(std::get<NotStarted>(other.state_))) {
     other.state_.emplace<Invalid>();
   }
   WaitForCqEndOp& operator=(WaitForCqEndOp&& other) noexcept {
-    state_ = std::move(absl::get<NotStarted>(other.state_));
+    state_ = std::move(std::get<NotStarted>(other.state_));
     other.state_.emplace<Invalid>();
     return *this;
   }
@@ -317,7 +321,7 @@ class WaitForCqEndOp {
     std::atomic<bool> done{false};
   };
   struct Invalid {};
-  using State = absl::variant<NotStarted, Started, Invalid>;
+  using State = std::variant<NotStarted, Started, Invalid>;
 
   static std::string StateString(const State& state);
 

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

@@ -72,8 +72,8 @@ Channel::Channel(std::string target, const ChannelArgs& channel_args)
 Channel::RegisteredCall* Channel::RegisterCall(const char* method,
                                                const char* host) {
   MutexLock lock(&mu_);
-  auto key = std::make_pair(std::string(host != nullptr ? host : ""),
-                            std::string(method != nullptr ? method : ""));
+  auto key = std::pair(std::string(host != nullptr ? host : ""),
+                       std::string(method != nullptr ? method : ""));
   auto rc_posn = registration_table_.find(key);
   if (rc_posn != registration_table_.end()) {
     return &rc_posn->second;
@@ -90,7 +90,6 @@ Channel::RegisteredCall* Channel::RegisterCall(const char* method,
 //
 
 void grpc_channel_destroy(grpc_channel* channel) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_channel_destroy(channel=" << channel << ")";
@@ -104,14 +103,13 @@ grpc_call* grpc_channel_create_call(grpc_channel* channel,
                                     grpc_slice method, const grpc_slice* host,
                                     gpr_timespec deadline, void* reserved) {
   CHECK(!reserved);
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   return grpc_core::Channel::FromC(channel)->CreateCall(
       parent_call, propagation_mask, completion_queue, nullptr,
       grpc_core::Slice(grpc_core::CSliceRef(method)),
       host != nullptr
-          ? absl::optional<grpc_core::Slice>(grpc_core::CSliceRef(*host))
-          : absl::nullopt,
+          ? std::optional<grpc_core::Slice>(grpc_core::CSliceRef(*host))
+          : std::nullopt,
       grpc_core::Timestamp::FromTimespecRoundUp(deadline),
       /*registered_method=*/false);
 }
@@ -122,7 +120,6 @@ void* grpc_channel_register_call(grpc_channel* channel, const char* method,
                             << ", method=" << method << ", host=" << host
                             << ", reserved=" << reserved << ")";
   CHECK(!reserved);
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   return grpc_core::Channel::FromC(channel)->RegisterCall(method, host);
 }
@@ -143,13 +140,12 @@ grpc_call* grpc_channel_create_registered_call(
       << ", tv_nsec: " << deadline.tv_nsec
       << ", clock_type: " << (int)deadline.clock_type
       << " }, reserved=" << reserved << ")";
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   return grpc_core::Channel::FromC(channel)->CreateCall(
       parent_call, propagation_mask, completion_queue, nullptr, rc->path.Ref(),
       rc->authority.has_value()
-          ? absl::optional<grpc_core::Slice>(rc->authority->Ref())
-          : absl::nullopt,
+          ? std::optional<grpc_core::Slice>(rc->authority->Ref())
+          : std::nullopt,
       grpc_core::Timestamp::FromTimespecRoundUp(deadline),
       /*registered_method=*/true);
 }
@@ -165,13 +161,11 @@ char* grpc_channel_get_target(grpc_channel* channel) {
 
 void grpc_channel_get_info(grpc_channel* channel,
                            const grpc_channel_info* channel_info) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   grpc_core::Channel::FromC(channel)->GetInfo(channel_info);
 }
 
 void grpc_channel_reset_connect_backoff(grpc_channel* channel) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_channel_reset_connect_backoff(channel=" << channel << ")";
@@ -184,7 +178,6 @@ int grpc_channel_support_connectivity_watcher(grpc_channel* channel) {
 
 grpc_connectivity_state grpc_channel_check_connectivity_state(
     grpc_channel* channel, int try_to_connect) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_channel_check_connectivity_state(channel=" << channel
@@ -196,7 +189,6 @@ grpc_connectivity_state grpc_channel_check_connectivity_state(
 void grpc_channel_watch_connectivity_state(
     grpc_channel* channel, grpc_connectivity_state last_observed_state,
     gpr_timespec deadline, grpc_completion_queue* cq, void* tag) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_channel_watch_connectivity_state(channel=" << channel

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

@@ -24,12 +24,12 @@
 #include <grpc/support/time.h>
 
 #include <map>
+#include <optional>
 #include <string>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
@@ -59,7 +59,7 @@ class Channel : public UnstartedCallDestination,
  public:
   struct RegisteredCall {
     Slice path;
-    absl::optional<Slice> authority;
+    std::optional<Slice> authority;
 
     explicit RegisteredCall(const char* method_arg, const char* host_arg);
     RegisteredCall(const RegisteredCall& other);
@@ -75,7 +75,7 @@ class Channel : public UnstartedCallDestination,
                                 uint32_t propagation_mask,
                                 grpc_completion_queue* cq,
                                 grpc_pollset_set* pollset_set_alternative,
-                                Slice path, absl::optional<Slice> authority,
+                                Slice path, std::optional<Slice> authority,
                                 Timestamp deadline, bool registered_method) = 0;
 
   virtual grpc_event_engine::experimental::EventEngine* event_engine()

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

@@ -23,6 +23,7 @@
 
 #include <algorithm>
 #include <map>
+#include <optional>
 #include <queue>
 #include <set>
 #include <string>
@@ -33,7 +34,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/util/crash.h"

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

@@ -100,7 +100,7 @@ grpc_call_error ValidateClientBatch(const grpc_op* ops, size_t nops) {
 }  // namespace
 
 ClientCall::ClientCall(grpc_call*, uint32_t, grpc_completion_queue* cq,
-                       Slice path, absl::optional<Slice> authority,
+                       Slice path, std::optional<Slice> authority,
                        bool registered_method, Timestamp deadline,
                        grpc_compression_options compression_options,
                        RefCountedPtr<Arena> arena,
@@ -318,7 +318,7 @@ void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
           return Map(
               started_call_initiator_.PullServerInitialMetadata(),
               [this,
-               array](ValueOrFailure<absl::optional<ServerMetadataHandle>> md) {
+               array](ValueOrFailure<std::optional<ServerMetadataHandle>> md) {
                 ServerMetadataHandle metadata;
                 if (!md.ok() || !md->has_value()) {
                   is_trailers_only_ = true;
@@ -335,9 +335,16 @@ void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
               });
         };
       });
-  auto primary_ops = AllOk<StatusFlag>(
-      TrySeq(std::move(send_message), std::move(send_close_from_client)),
-      TrySeq(std::move(recv_initial_metadata), std::move(recv_message)));
+  // We capture 'this' in the op handlers, but the call may be destroyed before
+  // the party owned by CallInitiator/CallHandler is destroyed -- meaning that
+  // op callbacks may happen after call destruction if we don't hold a ref.
+  // We do that via an implicitly captured one in a Map() here so that we don't
+  // need a ref held per batch operation -- they have the same lifetime always.
+  auto primary_ops = Map(
+      AllOk<StatusFlag>(
+          TrySeq(std::move(send_message), std::move(send_close_from_client)),
+          TrySeq(std::move(recv_initial_metadata), std::move(recv_message))),
+      [self = WeakRef()](StatusFlag x) { return x; });
   Party::WakeupHold wakeup_hold;
   if (const grpc_op* op = op_index.op(GRPC_OP_SEND_INITIAL_METADATA)) {
     wakeup_hold = StartCall(*op);
@@ -431,7 +438,7 @@ char* ClientCall::GetPeer() {
 
 grpc_call* MakeClientCall(grpc_call* parent_call, uint32_t propagation_mask,
                           grpc_completion_queue* cq, Slice path,
-                          absl::optional<Slice> authority,
+                          std::optional<Slice> authority,
                           bool registered_method, Timestamp deadline,
                           grpc_compression_options compression_options,
                           RefCountedPtr<Arena> arena,

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

@@ -59,7 +59,7 @@ class ClientCall final
  public:
   ClientCall(grpc_call* parent_call, uint32_t propagation_mask,
              grpc_completion_queue* cq, Slice path,
-             absl::optional<Slice> authority, bool registered_method,
+             std::optional<Slice> authority, bool registered_method,
              Timestamp deadline, grpc_compression_options compression_options,
              RefCountedPtr<Arena> arena,
              RefCountedPtr<UnstartedCallDestination> destination);
@@ -181,7 +181,7 @@ class ClientCall final
 
 grpc_call* MakeClientCall(grpc_call* parent_call, uint32_t propagation_mask,
                           grpc_completion_queue* cq, Slice path,
-                          absl::optional<Slice> authority,
+                          std::optional<Slice> authority,
                           bool registered_method, Timestamp deadline,
                           grpc_compression_options compression_options,
                           RefCountedPtr<Arena> arena,