grpc 1.70.1 → 1.72.0

data/src/core/lib/resource_quota/memory_quota.h

@@ -25,6 +25,7 @@
 #include <cstddef>
 #include <limits>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -34,7 +35,6 @@
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/promise/activity.h"
@@ -151,7 +151,7 @@ class ReclaimerQueue {
 
     class Sweep {
      public:
-      virtual void RunAndDelete(absl::optional<ReclamationSweep> sweep) = 0;
+      virtual void RunAndDelete(std::optional<ReclamationSweep> sweep) = 0;
 
      protected:
       explicit Sweep(std::shared_ptr<State> state) : state_(std::move(state)) {}
@@ -167,7 +167,7 @@ class ReclaimerQueue {
      public:
       explicit SweepFn(F&& f, std::shared_ptr<State> state)
           : Sweep(std::move(state)), f_(std::move(f)) {}
-      void RunAndDelete(absl::optional<ReclamationSweep> sweep) override {
+      void RunAndDelete(std::optional<ReclamationSweep> sweep) override {
         if (!sweep.has_value()) MarkCancelled();
         f_(std::move(sweep));
         delete this;
@@ -459,7 +459,7 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
   static constexpr size_t kMaxQuotaBufferSize = 1024 * 1024;
 
   // Primitive reservation function.
-  GRPC_MUST_USE_RESULT absl::optional<size_t> TryReserve(MemoryRequest request);
+  GRPC_MUST_USE_RESULT std::optional<size_t> TryReserve(MemoryRequest request);
   // This function may be invoked during a memory release operation.
   // It will try to return half of our free pool to the quota.
   void MaybeDonateBack();

data/src/core/lib/security/authorization/evaluate_args.cc

@@ -23,9 +23,9 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
+#include "src/core/credentials/transport/tls/tls_utils.h"
 #include "src/core/handshaker/endpoint_info/endpoint_info_handshaker.h"
 #include "src/core/lib/address_utils/parse_address.h"
-#include "src/core/lib/security/credentials/tls/tls_utils.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/uri.h"
@@ -115,13 +115,13 @@ absl::string_view EvaluateArgs::GetMethod() const {
   return absl::string_view();
 }
 
-absl::optional<absl::string_view> EvaluateArgs::GetHeaderValue(
+std::optional<absl::string_view> EvaluateArgs::GetHeaderValue(
     absl::string_view key, std::string* concatenated_value) const {
   if (metadata_ == nullptr) {
-    return absl::nullopt;
+    return std::nullopt;
   }
   if (absl::EqualsIgnoreCase(key, "te")) {
-    return absl::nullopt;
+    return std::nullopt;
   }
   if (absl::EqualsIgnoreCase(key, "host")) {
     // Maps legacy host header to :authority.

data/src/core/lib/security/authorization/evaluate_args.h

@@ -18,14 +18,14 @@
 #include <grpc/grpc_security.h>
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 #include <vector>
 
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/lib/transport/metadata_batch.h"
 
 namespace grpc_core {
 
@@ -61,13 +61,13 @@ class EvaluateArgs final {
   absl::string_view GetAuthority() const;
   absl::string_view GetMethod() const;
   // Returns metadata value(s) for the specified key.
-  // If the key is not present in the batch, returns absl::nullopt.
+  // If the key is not present in the batch, returns std::nullopt.
   // If the key is present exactly once in the batch, returns a string_view of
   // that value.
   // If the key is present more than once in the batch, constructs a
   // comma-concatenated string of all values in concatenated_value and returns a
   // string_view of that string.
-  absl::optional<absl::string_view> GetHeaderValue(
+  std::optional<absl::string_view> GetHeaderValue(
       absl::string_view key, std::string* concatenated_value) const;
 
   grpc_resolved_address GetLocalAddress() const;

data/src/core/lib/security/authorization/grpc_server_authz_filter.cc

@@ -24,25 +24,18 @@
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_join.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/security/authorization/authorization_engine.h"
 #include "src/core/lib/security/authorization/evaluate_args.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/latent_see.h"
 
 namespace grpc_core {
 
-const NoInterceptor GrpcServerAuthzFilter::Call::OnServerInitialMetadata;
-const NoInterceptor GrpcServerAuthzFilter::Call::OnServerTrailingMetadata;
-const NoInterceptor GrpcServerAuthzFilter::Call::OnClientToServerMessage;
-const NoInterceptor GrpcServerAuthzFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor GrpcServerAuthzFilter::Call::OnServerToClientMessage;
-const NoInterceptor GrpcServerAuthzFilter::Call::OnFinalize;
-
 GrpcServerAuthzFilter::GrpcServerAuthzFilter(
     RefCountedPtr<grpc_auth_context> auth_context, const ChannelArgs& args,
     RefCountedPtr<grpc_authorization_policy_provider> provider)

data/src/core/lib/security/authorization/grpc_server_authz_filter.h

@@ -25,8 +25,8 @@
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/security/authorization/authorization_policy_provider.h"
 #include "src/core/lib/security/authorization/evaluate_args.h"
-#include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/transport/auth_context.h"
 #include "src/core/util/ref_counted_ptr.h"
 
 namespace grpc_core {
@@ -49,12 +49,12 @@ class GrpcServerAuthzFilter final
    public:
     absl::Status OnClientInitialMetadata(ClientMetadata& md,
                                          GrpcServerAuthzFilter* filter);
-    static const NoInterceptor OnServerInitialMetadata;
-    static const NoInterceptor OnServerTrailingMetadata;
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnFinalize;
+    static inline const NoInterceptor OnServerInitialMetadata;
+    static inline const NoInterceptor OnServerTrailingMetadata;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnFinalize;
   };
 
  private:

data/src/core/lib/security/authorization/matchers.h

@@ -19,10 +19,10 @@
 #include <stdint.h>
 
 #include <memory>
+#include <optional>
 #include <utility>
 #include <vector>
 
-#include "absl/types/optional.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/security/authorization/evaluate_args.h"
 #include "src/core/lib/security/authorization/rbac_policy.h"
@@ -158,13 +158,13 @@ class PortAuthorizationMatcher : public AuthorizationMatcher {
 // or DNS SAN in that order, otherwise uses subject field.
 class AuthenticatedAuthorizationMatcher : public AuthorizationMatcher {
  public:
-  explicit AuthenticatedAuthorizationMatcher(absl::optional<StringMatcher> auth)
+  explicit AuthenticatedAuthorizationMatcher(std::optional<StringMatcher> auth)
       : matcher_(std::move(auth)) {}
 
   bool Matches(const EvaluateArgs& args) const override;
 
  private:
-  const absl::optional<StringMatcher> matcher_;
+  const std::optional<StringMatcher> matcher_;
 };
 
 // Perform a match against the request server from the client's connection

data/src/core/lib/security/authorization/rbac_policy.cc

@@ -312,7 +312,7 @@ Rbac::Principal Rbac::Principal::MakeAnyPrincipal() {
 }
 
 Rbac::Principal Rbac::Principal::MakeAuthenticatedPrincipal(
-    absl::optional<StringMatcher> string_matcher) {
+    std::optional<StringMatcher> string_matcher) {
   Principal principal;
   principal.type = Principal::RuleType::kPrincipalName;
   principal.string_matcher = std::move(string_matcher);

data/src/core/lib/security/authorization/rbac_policy.h

@@ -21,10 +21,10 @@
 
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 
-#include "absl/types/optional.h"
 #include "src/core/util/matchers.h"
 
 namespace grpc_core {
@@ -127,7 +127,7 @@ struct Rbac {
     static Principal MakeNotPrincipal(Principal principal);
     static Principal MakeAnyPrincipal();
     static Principal MakeAuthenticatedPrincipal(
-        absl::optional<StringMatcher> string_matcher);
+        std::optional<StringMatcher> string_matcher);
     static Principal MakeSourceIpPrincipal(CidrRange ip);
     static Principal MakeDirectRemoteIpPrincipal(CidrRange ip);
     static Principal MakeRemoteIpPrincipal(CidrRange ip);
@@ -145,7 +145,7 @@ struct Rbac {
 
     RuleType type = RuleType::kAnd;
     HeaderMatcher header_matcher;
-    absl::optional<StringMatcher> string_matcher;
+    std::optional<StringMatcher> string_matcher;
     CidrRange ip;
     // For type kAnd/kOr/kNot. For kNot type, the vector will have only one
     // element.

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

@@ -432,6 +432,12 @@ class GPR_MSVC_EMPTY_BASE_CLASS_WORKAROUND Slice
   static Slice FromExternalString(absl::string_view str) {
     return FromStaticString(str);
   }
+
+  static Slice ZeroContentsWithLength(size_t length) {
+    grpc_slice backing = grpc_slice_malloc(length);
+    memset(GRPC_SLICE_START_PTR(backing), 0, length);
+    return Slice(backing);
+  }
 };
 
 }  // namespace grpc_core

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

@@ -55,10 +55,12 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/call_finalization.h"
+#include "src/core/call/metadata.h"
+#include "src/core/call/metadata_batch.h"
+#include "src/core/call/status_util.h"
 #include "src/core/channelz/channelz.h"
-#include "src/core/lib/channel/call_finalization.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/experiments/experiments.h"
@@ -86,8 +88,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.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"
@@ -191,7 +191,7 @@ void Call::PublishToParent(Call* parent) {
         cc->sibling_prev->child_->sibling_next = this;
   }
   if (parent->Completed()) {
-    CancelWithError(absl::CancelledError());
+    CancelWithError(absl::CancelledError("CANCELLED"));
   }
 }
 
@@ -215,16 +215,16 @@ void Call::MaybeUnpublishFromParent() {
 }
 
 void Call::CancelWithStatus(grpc_status_code status, const char* description) {
-  // copying 'description' is needed to ensure the grpc_call_cancel_with_status
-  // guarantee that can be short-lived.
-  // TODO(ctiller): change to
-  // absl::Status(static_cast<absl::StatusCode>(status), description)
-  // (ie remove the set_int, set_str).
-  CancelWithError(grpc_error_set_int(
-      grpc_error_set_str(
-          absl::Status(static_cast<absl::StatusCode>(status), description),
-          StatusStrProperty::kGrpcMessage, description),
-      StatusIntProperty::kRpcStatus, status));
+  if (!IsErrorFlattenEnabled()) {
+    CancelWithError(grpc_error_set_int(
+        grpc_error_set_str(
+            absl::Status(static_cast<absl::StatusCode>(status), description),
+            StatusStrProperty::kGrpcMessage, description),
+        StatusIntProperty::kRpcStatus, status));
+    return;
+  }
+  CancelWithError(
+      absl::Status(static_cast<absl::StatusCode>(status), description));
 }
 
 void Call::PropagateCancellationToChildren() {
@@ -238,7 +238,7 @@ void Call::PropagateCancellationToChildren() {
         Call* next_child_call = child->child_->sibling_next;
         if (child->cancellation_is_inherited_) {
           child->InternalRef("propagate_cancel");
-          child->CancelWithError(absl::CancelledError());
+          child->CancelWithError(absl::CancelledError("CANCELLED"));
           child->InternalUnref("propagate_cancel");
         }
         child = next_child_call;
@@ -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,9 +413,9 @@ 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());
+  grpc_core::Call::FromC(call)->CancelWithError(
+      absl::CancelledError("CANCELLED"));
   return GRPC_CALL_OK;
 }
 
@@ -431,14 +430,14 @@ 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;
 }
 
 void grpc_call_cancel_internal(grpc_call* call) {
-  grpc_core::Call::FromC(call)->CancelWithError(absl::CancelledError());
+  grpc_core::Call::FromC(call)->CancelWithError(
+      absl::CancelledError("CANCELLED"));
 }
 
 grpc_compression_algorithm grpc_call_test_only_get_compression_algorithm(
@@ -474,7 +473,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

@@ -46,7 +46,9 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
-#include "src/core/lib/channel/status_util.h"
+#include "src/core/call/metadata.h"
+#include "src/core/call/metadata_batch.h"
+#include "src/core/call/status_util.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/context.h"
@@ -56,8 +58,6 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/surface/validate_metadata.h"
-#include "src/core/lib/transport/metadata.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/match.h"
@@ -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

@@ -44,6 +44,9 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/message.h"
+#include "src/core/call/metadata.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/cancel_callback.h"
 #include "src/core/lib/promise/map.h"
@@ -51,9 +54,6 @@
 #include "src/core/lib/promise/seq.h"
 #include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/surface/completion_queue.h"
-#include "src/core/lib/transport/message.h"
-#include "src/core/lib/transport/metadata.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/util/crash.h"
 
 namespace grpc_core {
@@ -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,14 @@
 #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/call/call_arena_allocator.h"
+#include "src/core/call/call_destination.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
@@ -37,8 +39,6 @@
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/call_arena_allocator.h"
-#include "src/core/lib/transport/call_destination.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/util/cpp_impl_of.h"
 #include "src/core/util/ref_counted.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"