grpc 1.70.1 → 1.71.0

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

@@ -178,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();
 }
@@ -304,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();
@@ -433,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(),

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

@@ -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/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));
   });
@@ -398,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) !=
@@ -411,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));
   });

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

@@ -44,7 +44,6 @@ FileExternalAccountCredentials::FileFetchBody::FileFetchBody(
   // Start work asynchronously, since we can't invoke the callback
   // synchronously without causing a deadlock.
   creds->event_engine().Run([self = RefAsSubclass<FileFetchBody>()]() mutable {
-    ApplicationCallbackExecCtx application_exec_ctx;
     ExecCtx exec_ctx;
     self->ReadFile();
     self.reset();

data/src/core/lib/security/credentials/google_default/credentials_generic.cc

@@ -18,11 +18,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/credentials/google_default/google_default_credentials.h"
 #include "src/core/util/env.h"

data/src/core/lib/security/credentials/google_default/google_default_credentials.cc

@@ -29,6 +29,7 @@
 #include <string.h>
 
 #include <memory>
+#include <optional>
 #include <string>
 
 #include "absl/log/check.h"
@@ -37,7 +38,6 @@
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -106,7 +106,7 @@ struct metadata_server_detector {
 
 namespace {
 
-bool IsXdsNonCfeCluster(absl::optional<absl::string_view> xds_cluster) {
+bool IsXdsNonCfeCluster(std::optional<absl::string_view> xds_cluster) {
   if (!xds_cluster.has_value()) return false;
   if (absl::StartsWith(*xds_cluster, "google_cfe_")) return false;
   if (!absl::StartsWith(*xds_cluster, "xdstp:")) return true;

data/src/core/lib/security/credentials/iam/iam_credentials.cc

@@ -50,7 +50,7 @@ grpc_google_iam_credentials::GetRequestMetadata(
 
 grpc_google_iam_credentials::grpc_google_iam_credentials(
     const char* token, const char* authority_selector)
-    : token_(token == nullptr ? absl::optional<grpc_core::Slice>()
+    : token_(token == nullptr ? std::optional<grpc_core::Slice>()
                               : grpc_core::Slice::FromCopiedString(token)),
       authority_selector_(
           grpc_core::Slice::FromCopiedString(authority_selector)),

data/src/core/lib/security/credentials/iam/iam_credentials.h

@@ -23,10 +23,10 @@
 #include <grpc/grpc_security.h>
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 
 #include "absl/status/statusor.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/slice/slice.h"
@@ -58,7 +58,7 @@ class grpc_google_iam_credentials : public grpc_call_credentials {
         static_cast<const grpc_call_credentials*>(this), other);
   }
 
-  const absl::optional<grpc_core::Slice> token_;
+  const std::optional<grpc_core::Slice> token_;
   const grpc_core::Slice authority_selector_;
   const std::string debug_string_;
 };

data/src/core/lib/security/credentials/jwt/jwt_credentials.cc

@@ -68,7 +68,7 @@ grpc_service_account_jwt_access_credentials::GetRequestMetadata(
     return grpc_core::Immediate(uri.status());
   }
   // See if we can return a cached jwt.
-  absl::optional<grpc_core::Slice> jwt_value;
+  std::optional<grpc_core::Slice> jwt_value;
   {
     gpr_mu_lock(&cache_mu_);
     if (cached_.has_value() && cached_->service_url == *uri &&
@@ -162,7 +162,6 @@ grpc_call_credentials* grpc_service_account_jwt_access_credentials_create(
     gpr_free(clean_json);
   }
   CHECK_EQ(reserved, nullptr);
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   return grpc_service_account_jwt_access_credentials_create_from_auth_json_key(
              grpc_auth_json_key_create_from_string(json_key), token_lifetime)

data/src/core/lib/security/credentials/jwt/jwt_credentials.h

@@ -26,13 +26,13 @@
 #include <grpc/support/time.h>
 #include <stdint.h>
 
+#include <optional>
 #include <string>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/credentials/jwt/json_token.h"
@@ -84,7 +84,7 @@ class grpc_service_account_jwt_access_credentials
     std::string service_url;
     gpr_timespec jwt_expiration;
   };
-  absl::optional<Cache> cached_;
+  std::optional<Cache> cached_;
 
   grpc_auth_json_key key_;
   gpr_timespec jwt_lifetime_;

data/src/core/lib/security/credentials/jwt/jwt_verifier.cc

@@ -377,7 +377,6 @@ static verifier_cb_ctx* verifier_cb_ctx_create(
     grpc_jwt_claims* claims, const char* audience, const grpc_slice& signature,
     const char* signed_jwt, size_t signed_jwt_len, void* user_data,
     grpc_jwt_verification_done_cb cb) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   verifier_cb_ctx* ctx = new verifier_cb_ctx();
   ctx->verifier = verifier;

data/src/core/lib/security/credentials/oauth2/oauth2_credentials.cc

@@ -144,7 +144,7 @@ void grpc_auth_refresh_token_destruct(grpc_auth_refresh_token* refresh_token) {
 
 grpc_credentials_status
 grpc_oauth2_token_fetcher_credentials_parse_server_response_body(
-    absl::string_view body, absl::optional<grpc_core::Slice>* token_value,
+    absl::string_view body, std::optional<grpc_core::Slice>* token_value,
     grpc_core::Duration* token_lifetime) {
   auto json = grpc_core::JsonParse(body);
   if (!json.ok()) {
@@ -187,9 +187,9 @@ grpc_oauth2_token_fetcher_credentials_parse_server_response_body(
 grpc_credentials_status
 grpc_oauth2_token_fetcher_credentials_parse_server_response(
     const grpc_http_response* response,
-    absl::optional<grpc_core::Slice>* token_value,
+    std::optional<grpc_core::Slice>* token_value,
     grpc_core::Duration* token_lifetime) {
-  *token_value = absl::nullopt;
+  *token_value = std::nullopt;
   if (response == nullptr) {
     LOG(ERROR) << "Received NULL response.";
     return GRPC_CREDENTIALS_ERROR;
@@ -241,7 +241,7 @@ class Oauth2TokenFetcherCredentials::HttpFetchRequest final
       return;
     }
     // Parse oauth2 token.
-    absl::optional<Slice> access_token_value;
+    std::optional<Slice> access_token_value;
     Duration token_lifetime;
     grpc_credentials_status status =
         grpc_oauth2_token_fetcher_credentials_parse_server_response(

data/src/core/lib/security/credentials/oauth2/oauth2_credentials.h

@@ -26,12 +26,12 @@
 #include <grpc/support/time.h>
 
 #include <atomic>
+#include <optional>
 #include <string>
 #include <utility>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/polling_entity.h"
@@ -176,14 +176,14 @@ grpc_refresh_token_credentials_create_from_auth_refresh_token(
 
 grpc_credentials_status
 grpc_oauth2_token_fetcher_credentials_parse_server_response_body(
-    absl::string_view body, absl::optional<grpc_core::Slice>* token_value,
+    absl::string_view body, std::optional<grpc_core::Slice>* token_value,
     grpc_core::Duration* token_lifetime);
 
 // Exposed for testing only.
 grpc_credentials_status
 grpc_oauth2_token_fetcher_credentials_parse_server_response(
     const struct grpc_http_response* response,
-    absl::optional<grpc_core::Slice>* token_value,
+    std::optional<grpc_core::Slice>* token_value,
     grpc_core::Duration* token_lifetime);
 
 namespace grpc_core {

data/src/core/lib/security/credentials/plugin/plugin_credentials.cc

@@ -115,7 +115,6 @@ void grpc_plugin_credentials::PendingRequest::RequestMetadataReady(
     void* request, const grpc_metadata* md, size_t num_md,
     grpc_status_code status, const char* error_details) {
   // called from application code
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx(GRPC_EXEC_CTX_FLAG_IS_FINISHED |
                               GRPC_EXEC_CTX_FLAG_THREAD_RESOURCE_LOOP);
   grpc_core::RefCountedPtr<grpc_plugin_credentials::PendingRequest> r(

data/src/core/lib/security/credentials/ssl/ssl_credentials.cc

@@ -24,12 +24,12 @@
 #include <grpc/support/string_util.h>
 #include <string.h>
 
+#include <optional>
 #include <string>
 #include <utility>
 
 #include "absl/log/check.h"
 #include "absl/log/log.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/security/security_connector/ssl_utils.h"
@@ -86,7 +86,7 @@ grpc_ssl_credentials::create_security_connector(
                   "must have root certs.";
     return nullptr;
   }
-  absl::optional<std::string> overridden_target_name =
+  std::optional<std::string> overridden_target_name =
       args->GetOwnedString(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG);
   auto* ssl_session_cache = args->GetObject<tsi::SslSessionLRUCache>();
   tsi_ssl_session_cache* session_cache =