grpc 1.68.1 → 1.71.0

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

@@ -20,7 +20,7 @@
 #include <grpc/support/port_platform.h>
 #include <stddef.h>
 
-#include "src/core/lib/config/core_configuration.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 
 typedef struct grpc_resource_quota grpc_resource_quota;

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

@@ -30,6 +30,7 @@
 #include <stddef.h>
 
 #include <atomic>
+#include <cstddef>
 #include <iosfwd>
 #include <memory>
 #include <utility>
@@ -190,6 +191,14 @@ class Arena final : public RefCounted<Arena, NonPolymorphicRefCount,
     return &p->t;
   }
 
+  template <typename T, typename... Args>
+  absl::enable_if_t<std::is_same<typename T::RefCountedUnrefBehaviorType,
+                                 UnrefCallDtor>::value,
+                    RefCountedPtr<T>>
+  MakeRefCounted(Args&&... args) {
+    return RefCountedPtr<T>(New<T>(std::forward<Args>(args)...));
+  }
+
   class PooledDeleter {
    public:
     PooledDeleter() = default;
@@ -362,6 +371,84 @@ class Arena final : public RefCounted<Arena, NonPolymorphicRefCount,
   RefCountedPtr<ArenaFactory> arena_factory_;
 };
 
+// Arena backed single-producer-single-consumer queue
+// Based on implementation from
+// https://www.1024cores.net/home/lock-free-algorithms/queues/unbounded-spsc-queue
+template <typename T, bool kOptimizeAlignment = true>
+class ArenaSpsc {
+ public:
+  explicit ArenaSpsc(Arena* arena) : arena_(arena) {}
+
+  ~ArenaSpsc() {
+    while (Pop().has_value()) {
+    }
+  }
+
+  ArenaSpsc(const ArenaSpsc&) = delete;
+  ArenaSpsc& operator=(const ArenaSpsc&) = delete;
+
+  // Push `value` onto the queue; at most one thread can be calling this at a
+  // time.
+  void Push(T value) {
+    Node* n = AllocNode();
+    Construct(&n->value, std::move(value));
+    n->next.store(nullptr, std::memory_order_relaxed);
+    head_->next.store(n, std::memory_order_release);
+    head_ = n;
+  }
+
+  // Pop a value from the queue; at most one thread can be calling this at a
+  // time. If the queue was empty when called, returns nullopt.
+  std::optional<T> Pop() {
+    Node* n = tail_.load(std::memory_order_relaxed);
+    Node* next = n->next.load(std::memory_order_acquire);
+    if (next == nullptr) return std::nullopt;
+    T result = std::move(next->value);
+    Destruct(&next->value);
+    tail_.store(next, std::memory_order_release);
+    return result;
+  }
+
+ private:
+  struct Node {
+    Node() {}
+    ~Node() {}
+    explicit Node(std::nullptr_t) : next{nullptr} {}
+    std::atomic<Node*> next;
+    union {
+      T value;
+    };
+  };
+
+  Node* AllocNode() {
+    if (first_ != tail_copy_) {
+      Node* n = first_;
+      first_ = first_->next.load(std::memory_order_relaxed);
+      return n;
+    }
+    tail_copy_ = tail_.load(std::memory_order_acquire);
+    if (first_ != tail_copy_) {
+      Node* n = first_;
+      first_ = first_->next.load(std::memory_order_relaxed);
+      return n;
+    }
+    return arena_->New<Node>();
+  }
+
+  Arena* const arena_;
+  Node first_node_{nullptr};
+  // Accessed mainly by consumer, infrequently by producer
+  std::atomic<Node*> tail_{&first_node_};
+  // Ensure alignment on next cacheline to deliminate producer and consumer
+  // Head of queue
+  alignas(kOptimizeAlignment ? GPR_CACHELINE_SIZE
+                             : alignof(Node*)) Node* head_{&first_node_};
+  // Last unused node
+  Node* first_{&first_node_};
+  // Helper, points somewhere between first and tail
+  Node* tail_copy_{&first_node_};
+};
+
 // Arenas form a context for activities
 template <>
 struct ContextType<Arena> {};

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

@@ -48,6 +48,10 @@ class ConnectionQuota : public RefCounted<ConnectionQuota> {
   // Mark connections as closed.
   void ReleaseConnections(int num_connections);
 
+  int TestOnlyActiveIncomingConnections() const {
+    return active_incoming_connections_;
+  }
+
  private:
   std::atomic<int> active_incoming_connections_{0};
   std::atomic<int> max_incoming_connections_{std::numeric_limits<int>::max()};

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

@@ -130,8 +130,18 @@ class SliceRefCount : public grpc_slice_refcount {
   size_t size_;
 };
 
+std::atomic<double> container_memory_pressure{0.0};
+
 }  // namespace
 
+void SetContainerMemoryPressure(double pressure) {
+  container_memory_pressure.store(pressure, std::memory_order_relaxed);
+}
+
+double ContainerMemoryPressure() {
+  return container_memory_pressure.load(std::memory_order_relaxed);
+}
+
 //
 // Reclaimer
 //
@@ -168,7 +178,7 @@ struct ReclaimerQueue::State {
 
 void ReclaimerQueue::Handle::Orphan() {
   if (auto* sweep = sweep_.exchange(nullptr, std::memory_order_acq_rel)) {
-    sweep->RunAndDelete(absl::nullopt);
+    sweep->RunAndDelete(std::nullopt);
   }
   Unref();
 }
@@ -294,7 +304,7 @@ size_t GrpcMemoryAllocatorImpl::Reserve(MemoryRequest request) {
   }
 }
 
-absl::optional<size_t> GrpcMemoryAllocatorImpl::TryReserve(
+std::optional<size_t> GrpcMemoryAllocatorImpl::TryReserve(
     MemoryRequest request) {
   // How much memory should we request? (see the scaling below)
   size_t scaled_size_over_min = request.max() - request.min();
@@ -346,7 +356,7 @@ void GrpcMemoryAllocatorImpl::MaybeDonateBack() {
     size_t ret = 0;
     if (!IsUnconstrainedMaxQuotaBufferSizeEnabled() &&
         free > kMaxQuotaBufferSize / 2) {
-      ret = std::max(ret, free - kMaxQuotaBufferSize / 2);
+      ret = std::max(ret, free - (kMaxQuotaBufferSize / 2));
     }
     ret = std::max(ret, free > 8192 ? free / 2 : free);
     const size_t new_free = free - ret;
@@ -423,54 +433,58 @@ void BasicMemoryQuota::Start() {
   // basically, wait until we are in overcommit (free_bytes_ < 0), and then:
   // while (free_bytes_ < 0) reclaim_memory()
   // ... and repeat
-  auto reclamation_loop = Loop(Seq(
-      [self]() -> Poll<int> {
-        // If there's free memory we no longer need to reclaim memory!
-        if (self->free_bytes_.load(std::memory_order_acquire) > 0) {
-          return Pending{};
-        }
-        return 0;
-      },
-      [self]() {
-        // Race biases to the first thing that completes... so this will
-        // choose the highest priority/least destructive thing to do that's
-        // available.
-        auto annotate = [](const char* name) {
-          return [name](RefCountedPtr<ReclaimerQueue::Handle> f) {
-            return std::make_tuple(name, std::move(f));
+  auto reclamation_loop = Loop([self]() {
+    return Seq(
+        [self]() -> Poll<int> {
+          // If there's free memory we no longer need to reclaim memory!
+          if (self->free_bytes_.load(std::memory_order_acquire) > 0) {
+            return Pending{};
+          }
+          return 0;
+        },
+        [self]() {
+          // Race biases to the first thing that completes... so this will
+          // choose the highest priority/least destructive thing to do that's
+          // available.
+          auto annotate = [](const char* name) {
+            return [name](RefCountedPtr<ReclaimerQueue::Handle> f) {
+              return std::tuple(name, std::move(f));
+            };
           };
-        };
-        return Race(Map(self->reclaimers_[0].Next(), annotate("benign")),
-                    Map(self->reclaimers_[1].Next(), annotate("idle")),
-                    Map(self->reclaimers_[2].Next(), annotate("destructive")));
-      },
-      [self](
-          std::tuple<const char*, RefCountedPtr<ReclaimerQueue::Handle>> arg) {
-        auto reclaimer = std::move(std::get<1>(arg));
-        if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
-          double free = std::max(intptr_t{0}, self->free_bytes_.load());
-          size_t quota_size = self->quota_size_.load();
-          LOG(INFO) << "RQ: " << self->name_ << " perform " << std::get<0>(arg)
-                    << " reclamation. Available free bytes: " << free
-                    << ", total quota_size: " << quota_size;
-        }
-        // One of the reclaimer queues gave us a way to get back memory.
-        // Call the reclaimer with a token that contains enough to wake us
-        // up again.
-        const uint64_t token =
-            self->reclamation_counter_.fetch_add(1, std::memory_order_relaxed) +
-            1;
-        reclaimer->Run(ReclamationSweep(
-            self, token, GetContext<Activity>()->MakeNonOwningWaker()));
-        // Return a promise that will wait for our barrier. This will be
-        // awoken by the token above being destroyed. So, once that token is
-        // destroyed, we'll be able to proceed.
-        return WaitForSweepPromise(self, token);
-      },
-      []() -> LoopCtl<absl::Status> {
-        // Continue the loop!
-        return Continue{};
-      }));
+          return Race(
+              Map(self->reclaimers_[0].Next(), annotate("benign")),
+              Map(self->reclaimers_[1].Next(), annotate("idle")),
+              Map(self->reclaimers_[2].Next(), annotate("destructive")));
+        },
+        [self](std::tuple<const char*, RefCountedPtr<ReclaimerQueue::Handle>>
+                   arg) {
+          auto reclaimer = std::move(std::get<1>(arg));
+          if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
+            double free = std::max(intptr_t{0}, self->free_bytes_.load());
+            size_t quota_size = self->quota_size_.load();
+            LOG(INFO) << "RQ: " << self->name_ << " perform "
+                      << std::get<0>(arg)
+                      << " reclamation. Available free bytes: " << free
+                      << ", total quota_size: " << quota_size;
+          }
+          // One of the reclaimer queues gave us a way to get back memory.
+          // Call the reclaimer with a token that contains enough to wake us
+          // up again.
+          const uint64_t token = self->reclamation_counter_.fetch_add(
+                                     1, std::memory_order_relaxed) +
+                                 1;
+          reclaimer->Run(ReclamationSweep(
+              self, token, GetContext<Activity>()->MakeNonOwningWaker()));
+          // Return a promise that will wait for our barrier. This will be
+          // awoken by the token above being destroyed. So, once that token is
+          // destroyed, we'll be able to proceed.
+          return WaitForSweepPromise(self, token);
+        },
+        []() -> LoopCtl<absl::Status> {
+          // Continue the loop!
+          return Continue{};
+        });
+  });
 
   reclaimer_activity_ =
       MakeActivity(std::move(reclamation_loop), ExecCtxWakeupScheduler(),
@@ -646,7 +660,8 @@ BasicMemoryQuota::PressureInfo BasicMemoryQuota::GetPressureInfo() {
   double size = quota_size;
   if (size < 1) return PressureInfo{1, 1, 1};
   PressureInfo pressure_info;
-  pressure_info.instantaneous_pressure = std::max(0.0, (size - free) / size);
+  pressure_info.instantaneous_pressure =
+      std::max({0.0, (size - free) / size, ContainerMemoryPressure()});
   pressure_info.pressure_control_value =
       pressure_tracker_.AddSampleAndGetControlValue(
           pressure_info.instantaneous_pressure);
@@ -708,7 +723,7 @@ double PressureController::Update(double error) {
     // The first switchover will have last_control_ being 0, and max_ being 2,
     // so we'll immediately choose 1.0 which will tend to really slow down
     // progress.
-    // If we end up targetting too low, we'll eventually move it back towards
+    // If we end up targeting too low, we'll eventually move it back towards
     // 1.0 after max_ticks_same_ ticks.
     ticks_same_ = 0;
     max_ = (last_control_ + max_) / 2.0;
@@ -719,8 +734,8 @@ double PressureController::Update(double error) {
   // (If we want a control value that's higher than the last one we snap
   // immediately because it's likely that memory pressure is growing unchecked).
   if (new_control < last_control_) {
-    new_control =
-        std::max(new_control, last_control_ - max_reduction_per_tick_ / 1000.0);
+    new_control = std::max(new_control,
+                           last_control_ - (max_reduction_per_tick_ / 1000.0));
   }
   last_control_ = new_control;
   return new_control;

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;
@@ -239,7 +239,7 @@ class PressureController {
  private:
   // How many update periods have we reached the same decision in a row?
   // Too many and we should start expanding the search space since we're not
-  // being agressive enough.
+  // being aggressive enough.
   uint8_t ticks_same_ = 0;
   // Maximum number of ticks with the same value until we start expanding the
   // control space.
@@ -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();
@@ -588,6 +588,10 @@ inline MemoryQuotaRefPtr MakeMemoryQuota(std::string name) {
 
 std::vector<std::shared_ptr<BasicMemoryQuota>> AllMemoryQuotas();
 
+void SetContainerMemoryPressure(double pressure);
+
+double ContainerMemoryPressure();
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_RESOURCE_QUOTA_MEMORY_QUOTA_H

data/src/core/lib/resource_quota/periodic_update.cc

@@ -32,7 +32,7 @@ bool PeriodicUpdate::MaybeEndPeriod(absl::FunctionRef<void(Duration)> f) {
   // the decrementer that got us there.
   // We can now safely mutate any non-atomic mutable variables (we've got a
   // guarantee that no other thread will), and by the time this function returns
-  // we must store a postive number into updates_remaining_.
+  // we must store a positive number into updates_remaining_.
   auto now = Timestamp::Now();
   Duration time_so_far = now - period_start_;
   if (time_so_far < period_) {

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

@@ -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,11 +18,11 @@
 #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/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/transport/metadata_batch.h"
@@ -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

@@ -36,13 +36,6 @@
 
 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

@@ -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/security/context/security_context.h

@@ -33,7 +33,9 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/security/credentials/credentials.h"  // IWYU pragma: keep
+#include "src/core/lib/surface/connection_context.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/useful.h"
@@ -77,6 +79,7 @@ struct grpc_auth_context
     if (chained_ != nullptr) {
       peer_identity_property_name_ = chained_->peer_identity_property_name_;
     }
+    connection_context_ = grpc_core::ConnectionContext::Create();
   }
 
   ~grpc_auth_context() {
@@ -98,6 +101,10 @@ struct grpc_auth_context
   const grpc_auth_context* chained() const { return chained_.get(); }
   const grpc_auth_property_array& properties() const { return properties_; }
 
+  grpc_core::ConnectionContext* connection_context() const {
+    return connection_context_.get();
+  }
+
   bool is_authenticated() const {
     return peer_identity_property_name_ != nullptr;
   }
@@ -120,6 +127,7 @@ struct grpc_auth_context
   grpc_auth_property_array properties_;
   const char* peer_identity_property_name_ = nullptr;
   std::unique_ptr<Extension> extension_;
+  grpc_core::OrphanablePtr<grpc_core::ConnectionContext> connection_context_;
 };
 
 // --- grpc_security_context_extension ---

data/src/core/lib/security/credentials/channel_creds_registry_init.cc

@@ -29,7 +29,7 @@
 #include <utility>
 
 #include "absl/strings/string_view.h"
-#include "src/core/lib/config/core_configuration.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/security/credentials/channel_creds_registry.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/credentials/fake/fake_credentials.h"

data/src/core/lib/security/credentials/external/aws_external_account_credentials.cc

@@ -25,6 +25,7 @@
 #include <string.h>
 
 #include <map>
+#include <optional>
 #include <utility>
 
 #include "absl/log/check.h"
@@ -34,7 +35,6 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_replace.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/util/env.h"
@@ -110,7 +110,6 @@ void AwsExternalAccountCredentials::AwsFetchBody::AsyncFinish(
     absl::StatusOr<std::string> result) {
   creds_->event_engine().Run(
       [this, self = Ref(), result = std::move(result)]() mutable {
-        ApplicationCallbackExecCtx application_exec_ctx;
         ExecCtx exec_ctx;
         Finish(std::move(result));
         self.reset();

data/src/core/lib/security/credentials/external/external_account_credentials.cc

@@ -78,7 +78,6 @@ ExternalAccountCredentials::NoOpFetchBody::NoOpFetchBody(
     : FetchBody(std::move(on_done)) {
   event_engine.Run([self = RefAsSubclass<NoOpFetchBody>(),
                     result = std::move(result)]() mutable {
-    ApplicationCallbackExecCtx application_exec_ctx;
     ExecCtx exec_ctx;
     self->Finish(std::move(result));
   });
@@ -229,15 +228,16 @@ void ExternalAccountCredentials::ExternalFetchRequest::ExchangeToken(
         }
         body_parts.push_back(
             absl::StrFormat("scope=%s", UrlEncode(scope).c_str()));
-        Json::Object addtional_options_json_object;
+        Json::Object additional_options_json_object;
         if (options().client_id.empty() && options().client_secret.empty()) {
-          addtional_options_json_object["userProject"] =
+          additional_options_json_object["userProject"] =
               Json::FromString(options().workforce_pool_user_project);
         }
-        Json addtional_options_json =
-            Json::FromObject(std::move(addtional_options_json_object));
+        Json additional_options_json =
+            Json::FromObject(std::move(additional_options_json_object));
         body_parts.push_back(absl::StrFormat(
-            "options=%s", UrlEncode(JsonDump(addtional_options_json)).c_str()));
+            "options=%s",
+            UrlEncode(JsonDump(additional_options_json)).c_str()));
         std::string body = absl::StrJoin(body_parts, "&");
         request.body = const_cast<char*>(body.c_str());
         request.body_length = body.size();
@@ -397,7 +397,7 @@ void ExternalAccountCredentials::ExternalFetchRequest::FinishTokenFetch(
                           absl::StrCat("error fetching oauth2 token: ",
                                        response_body.status().message()));
   } else {
-    absl::optional<Slice> token_value;
+    std::optional<Slice> token_value;
     Duration token_lifetime;
     if (grpc_oauth2_token_fetcher_credentials_parse_server_response_body(
             *response_body, &token_value, &token_lifetime) !=
@@ -410,7 +410,6 @@ void ExternalAccountCredentials::ExternalFetchRequest::FinishTokenFetch(
   }
   creds_->event_engine().Run([on_done = std::exchange(on_done_, nullptr),
                               result = std::move(result)]() mutable {
-    ApplicationCallbackExecCtx application_exec_ctx;
     ExecCtx exec_ctx;
     std::exchange(on_done, nullptr)(std::move(result));
   });