grpc 1.70.1 → 1.71.0

data/src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.cc

@@ -24,8 +24,8 @@
 #include "absl/status/status.h"
 
 void grpc_tls_certificate_distributor::SetKeyMaterials(
-    const std::string& cert_name, absl::optional<std::string> pem_root_certs,
-    absl::optional<grpc_core::PemKeyCertPairList> pem_key_cert_pairs) {
+    const std::string& cert_name, std::optional<std::string> pem_root_certs,
+    std::optional<grpc_core::PemKeyCertPairList> pem_key_cert_pairs) {
   CHECK(pem_root_certs.has_value() || pem_key_cert_pairs.has_value());
   grpc_core::MutexLock lock(&mu_);
   auto& cert_info = certificate_info_map_[cert_name];
@@ -37,8 +37,7 @@ void grpc_tls_certificate_distributor::SetKeyMaterials(
       const auto watcher_it = watchers_.find(watcher_ptr);
       CHECK(watcher_it != watchers_.end());
       CHECK(watcher_it->second.root_cert_name.has_value());
-      absl::optional<grpc_core::PemKeyCertPairList>
-          pem_key_cert_pairs_to_report;
+      std::optional<grpc_core::PemKeyCertPairList> pem_key_cert_pairs_to_report;
       if (pem_key_cert_pairs.has_value() &&
           watcher_it->second.identity_cert_name == cert_name) {
         pem_key_cert_pairs_to_report = pem_key_cert_pairs;
@@ -62,7 +61,7 @@ void grpc_tls_certificate_distributor::SetKeyMaterials(
       const auto watcher_it = watchers_.find(watcher_ptr);
       CHECK(watcher_it != watchers_.end());
       CHECK(watcher_it->second.identity_cert_name.has_value());
-      absl::optional<absl::string_view> pem_root_certs_to_report;
+      std::optional<absl::string_view> pem_root_certs_to_report;
       if (pem_root_certs.has_value() &&
           watcher_it->second.root_cert_name == cert_name) {
         // In this case, We've already sent the credential updates at the time
@@ -100,8 +99,8 @@ bool grpc_tls_certificate_distributor::HasKeyCertPairs(
 
 void grpc_tls_certificate_distributor::SetErrorForCert(
     const std::string& cert_name,
-    absl::optional<grpc_error_handle> root_cert_error,
-    absl::optional<grpc_error_handle> identity_cert_error) {
+    std::optional<grpc_error_handle> root_cert_error,
+    std::optional<grpc_error_handle> identity_cert_error) {
   CHECK(root_cert_error.has_value() || identity_cert_error.has_value());
   grpc_core::MutexLock lock(&mu_);
   CertificateInfo& cert_info = certificate_info_map_[cert_name];
@@ -169,8 +168,8 @@ void grpc_tls_certificate_distributor::SetError(grpc_error_handle error) {
 
 void grpc_tls_certificate_distributor::WatchTlsCertificates(
     std::unique_ptr<TlsCertificatesWatcherInterface> watcher,
-    absl::optional<std::string> root_cert_name,
-    absl::optional<std::string> identity_cert_name) {
+    std::optional<std::string> root_cert_name,
+    std::optional<std::string> identity_cert_name) {
   bool start_watching_root_cert = false;
   bool already_watching_identity_for_root_cert = false;
   bool start_watching_identity_cert = false;
@@ -187,8 +186,8 @@ void grpc_tls_certificate_distributor::WatchTlsCertificates(
     CHECK(watcher_it == watchers_.end());
     watchers_[watcher_ptr] = {std::move(watcher), root_cert_name,
                               identity_cert_name};
-    absl::optional<absl::string_view> updated_root_certs;
-    absl::optional<grpc_core::PemKeyCertPairList> updated_identity_pairs;
+    std::optional<absl::string_view> updated_root_certs;
+    std::optional<grpc_core::PemKeyCertPairList> updated_identity_pairs;
     grpc_error_handle root_error;
     grpc_error_handle identity_error;
     if (root_cert_name.has_value()) {
@@ -253,8 +252,8 @@ void grpc_tls_certificate_distributor::WatchTlsCertificates(
 
 void grpc_tls_certificate_distributor::CancelTlsCertificatesWatch(
     TlsCertificatesWatcherInterface* watcher) {
-  absl::optional<std::string> root_cert_name;
-  absl::optional<std::string> identity_cert_name;
+  std::optional<std::string> root_cert_name;
+  std::optional<std::string> identity_cert_name;
   bool stop_watching_root_cert = false;
   bool already_watching_identity_for_root_cert = false;
   bool stop_watching_identity_cert = false;

data/src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.h

@@ -22,13 +22,13 @@
 #include <functional>
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/security/security_connector/ssl_utils.h"
 #include "src/core/util/ref_counted.h"
@@ -48,7 +48,7 @@ struct grpc_tls_certificate_distributor
     virtual ~TlsCertificatesWatcherInterface() = default;
 
     // Handles the delivery of the updated root and identity certificates.
-    // An absl::nullopt value indicates no corresponding contents for
+    // An std::nullopt value indicates no corresponding contents for
     // root_certs or key_cert_pairs. Note that we will send updates of the
     // latest contents for both root and identity certificates, even when only
     // one side of it got updated.
@@ -57,8 +57,8 @@ struct grpc_tls_certificate_distributor
     // @param key_cert_pairs the contents of the reloaded identity key-cert
     // pairs.
     virtual void OnCertificatesChanged(
-        absl::optional<absl::string_view> root_certs,
-        absl::optional<grpc_core::PemKeyCertPairList> key_cert_pairs) = 0;
+        std::optional<absl::string_view> root_certs,
+        std::optional<grpc_core::PemKeyCertPairList> key_cert_pairs) = 0;
 
     // Handles an error that occurs while attempting to fetch certificate data.
     // Note that if a watcher sees an error, it simply means the Provider is
@@ -84,8 +84,8 @@ struct grpc_tls_certificate_distributor
   // @param pem_root_certs The content of root certificates.
   // @param pem_key_cert_pairs The content of identity key-cert pairs.
   void SetKeyMaterials(
-      const std::string& cert_name, absl::optional<std::string> pem_root_certs,
-      absl::optional<grpc_core::PemKeyCertPairList> pem_key_cert_pairs);
+      const std::string& cert_name, std::optional<std::string> pem_root_certs,
+      std::optional<grpc_core::PemKeyCertPairList> pem_key_cert_pairs);
 
   bool HasRootCerts(const std::string& root_cert_name);
 
@@ -101,8 +101,8 @@ struct grpc_tls_certificate_distributor
   // @param identity_cert_error The error that the caller encounters when
   // reloading identity certs.
   void SetErrorForCert(const std::string& cert_name,
-                       absl::optional<grpc_error_handle> root_cert_error,
-                       absl::optional<grpc_error_handle> identity_cert_error);
+                       std::optional<grpc_error_handle> root_cert_error,
+                       std::optional<grpc_error_handle> identity_cert_error);
 
   // Propagates the error that the caller (e.g. Producer) encounters to all
   // watchers.
@@ -142,14 +142,14 @@ struct grpc_tls_certificate_distributor
   //
   // @param watcher The watcher being registered.
   // @param root_cert_name The name of the root certificates that will be
-  // watched. If set to absl::nullopt, the root certificates won't be watched.
+  // watched. If set to std::nullopt, the root certificates won't be watched.
   // @param identity_cert_name The name of the identity certificates that will
-  // be watched. If set to absl::nullopt, the identity certificates won't be
+  // be watched. If set to std::nullopt, the identity certificates won't be
   // watched.
   void WatchTlsCertificates(
       std::unique_ptr<TlsCertificatesWatcherInterface> watcher,
-      absl::optional<std::string> root_cert_name,
-      absl::optional<std::string> identity_cert_name);
+      std::optional<std::string> root_cert_name,
+      std::optional<std::string> identity_cert_name);
 
   // Cancels a watcher.
   //
@@ -160,8 +160,8 @@ struct grpc_tls_certificate_distributor
   // Contains the information about each watcher.
   struct WatcherInfo {
     std::unique_ptr<TlsCertificatesWatcherInterface> watcher;
-    absl::optional<std::string> root_cert_name;
-    absl::optional<std::string> identity_cert_name;
+    std::optional<std::string> root_cert_name;
+    std::optional<std::string> identity_cert_name;
   };
   // CertificateInfo contains the credential contents and some additional
   // watcher information.

data/src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.cc

@@ -50,7 +50,10 @@ absl::Status ValidateRootCertificates(absl::string_view root_certificates) {
   absl::StatusOr<std::vector<X509*>> parsed_roots =
       ParsePemCertificateChain(root_certificates);
   if (!parsed_roots.ok()) {
-    return parsed_roots.status();
+    return absl::Status(
+        parsed_roots.status().code(),
+        absl::StrCat("Failed to parse root certificates as PEM: ",
+                     parsed_roots.status().message()));
   }
   for (X509* x509 : *parsed_roots) {
     X509_free(x509);
@@ -65,7 +68,10 @@ absl::Status ValidatePemKeyCertPair(absl::string_view cert_chain,
   absl::StatusOr<std::vector<X509*>> parsed_certs =
       ParsePemCertificateChain(cert_chain);
   if (!parsed_certs.ok()) {
-    return parsed_certs.status();
+    return absl::Status(
+        parsed_certs.status().code(),
+        absl::StrCat("Failed to parse certificate chain as PEM: ",
+                     parsed_certs.status().message()));
   }
   for (X509* x509 : *parsed_certs) {
     X509_free(x509);
@@ -74,7 +80,9 @@ absl::Status ValidatePemKeyCertPair(absl::string_view cert_chain,
   absl::StatusOr<EVP_PKEY*> parsed_private_key =
       ParsePemPrivateKey(private_key);
   if (!parsed_private_key.ok()) {
-    return parsed_private_key.status();
+    return absl::Status(parsed_private_key.status().code(),
+                        absl::StrCat("Failed to parse private key as PEM: ",
+                                     parsed_private_key.status().message()));
   }
   EVP_PKEY_free(*parsed_private_key);
   return absl::OkStatus();
@@ -91,8 +99,8 @@ StaticDataCertificateProvider::StaticDataCertificateProvider(
                                               bool root_being_watched,
                                               bool identity_being_watched) {
     MutexLock lock(&mu_);
-    absl::optional<std::string> root_certificate;
-    absl::optional<PemKeyCertPairList> pem_key_cert_pairs;
+    std::optional<std::string> root_certificate;
+    std::optional<PemKeyCertPairList> pem_key_cert_pairs;
     StaticDataCertificateProvider::WatcherInfo& info = watcher_info_[cert_name];
     if (!info.root_being_watched && root_being_watched &&
         !root_certificate_.empty()) {
@@ -208,8 +216,8 @@ FileWatcherCertificateProvider::FileWatcherCertificateProvider(
                                               bool root_being_watched,
                                               bool identity_being_watched) {
     MutexLock lock(&mu_);
-    absl::optional<std::string> root_certificate;
-    absl::optional<PemKeyCertPairList> pem_key_cert_pairs;
+    std::optional<std::string> root_certificate;
+    std::optional<PemKeyCertPairList> pem_key_cert_pairs;
     FileWatcherCertificateProvider::WatcherInfo& info =
         watcher_info_[cert_name];
     if (!info.root_being_watched && root_being_watched &&
@@ -277,8 +285,8 @@ absl::Status FileWatcherCertificateProvider::ValidateCredentials() const {
 }
 
 void FileWatcherCertificateProvider::ForceUpdate() {
-  absl::optional<std::string> root_certificate;
-  absl::optional<PemKeyCertPairList> pem_key_cert_pairs;
+  std::optional<std::string> root_certificate;
+  std::optional<PemKeyCertPairList> pem_key_cert_pairs;
   if (!root_cert_path_.empty()) {
     root_certificate = ReadRootCertificatesFromFile(root_cert_path_);
   }
@@ -317,8 +325,8 @@ void FileWatcherCertificateProvider::ForceUpdate() {
     for (const auto& p : watcher_info_) {
       const std::string& cert_name = p.first;
       const WatcherInfo& info = p.second;
-      absl::optional<std::string> root_to_report;
-      absl::optional<PemKeyCertPairList> identity_to_report;
+      std::optional<std::string> root_to_report;
+      std::optional<PemKeyCertPairList> identity_to_report;
       // Set key materials to the distributor if their contents changed.
       if (info.root_being_watched && !root_certificate_.empty() &&
           root_cert_changed) {
@@ -346,7 +354,7 @@ void FileWatcherCertificateProvider::ForceUpdate() {
   }
 }
 
-absl::optional<std::string>
+std::optional<std::string>
 FileWatcherCertificateProvider::ReadRootCertificatesFromFile(
     const std::string& root_cert_full_path) {
   // Read the root file.
@@ -355,7 +363,7 @@ FileWatcherCertificateProvider::ReadRootCertificatesFromFile(
   if (!root_slice.ok()) {
     LOG(ERROR) << "Reading file " << root_cert_full_path
                << " failed: " << root_slice.status();
-    return absl::nullopt;
+    return std::nullopt;
   }
   return std::string(root_slice->as_string_view());
 }
@@ -372,7 +380,7 @@ time_t GetModificationTime(const char* filename) {
 
 }  // namespace
 
-absl::optional<PemKeyCertPairList>
+std::optional<PemKeyCertPairList>
 FileWatcherCertificateProvider::ReadIdentityKeyCertPairFromFiles(
     const std::string& private_key_path,
     const std::string& identity_certificate_path) {
@@ -433,7 +441,7 @@ FileWatcherCertificateProvider::ReadIdentityKeyCertPairFromFiles(
   }
   LOG(ERROR) << "All retry attempts failed. Will try again after the next "
                 "interval.";
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 int64_t FileWatcherCertificateProvider::TestOnlyGetRefreshIntervalSecond()

data/src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h

@@ -23,13 +23,13 @@
 #include <stdint.h>
 
 #include <map>
+#include <optional>
 #include <string>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/log/check.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.h"
 #include "src/core/lib/security/security_connector/ssl_utils.h"
 #include "src/core/util/ref_counted.h"
@@ -166,11 +166,11 @@ class FileWatcherCertificateProvider final
   // Force an update from the file system regardless of the interval.
   void ForceUpdate();
   // Read the root certificates from files and update the distributor.
-  absl::optional<std::string> ReadRootCertificatesFromFile(
+  std::optional<std::string> ReadRootCertificatesFromFile(
       const std::string& root_cert_full_path);
   // Read the private key and the certificate chain from files and update the
   // distributor.
-  absl::optional<PemKeyCertPairList> ReadIdentityKeyCertPairFromFiles(
+  std::optional<PemKeyCertPairList> ReadIdentityKeyCertPairFromFiles(
       const std::string& private_key_path,
       const std::string& identity_certificate_path);
 

data/src/core/lib/security/credentials/tls/grpc_tls_crl_provider.cc

@@ -191,7 +191,6 @@ void DirectoryReloaderCrlProvider::UpdateAndStartTimer() {
   std::weak_ptr<DirectoryReloaderCrlProvider> self = shared_from_this();
   refresh_handle_ =
       event_engine_->RunAfter(refresh_duration_, [self = std::move(self)]() {
-        ApplicationCallbackExecCtx callback_exec_ctx;
         ExecCtx exec_ctx;
         if (std::shared_ptr<DirectoryReloaderCrlProvider> valid_ptr =
                 self.lock()) {

data/src/core/lib/security/credentials/tls/grpc_tls_crl_provider.h

@@ -36,7 +36,6 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/util/directory_reader.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
@@ -120,7 +119,7 @@ class DirectoryReloaderCrlProvider
   Mutex mu_;
   absl::flat_hash_map<::std::string, ::std::shared_ptr<Crl>> crls_
       ABSL_GUARDED_BY(mu_);
-  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+  std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
       refresh_handle_;
 };
 

data/src/core/lib/security/credentials/tls/tls_credentials.cc

@@ -24,11 +24,11 @@
 #include <grpc/support/port_platform.h>
 
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 
 #include "absl/log/log.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_verifier.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h"
@@ -103,7 +103,7 @@ grpc_core::RefCountedPtr<grpc_channel_security_connector>
 TlsCredentials::create_security_connector(
     grpc_core::RefCountedPtr<grpc_call_credentials> call_creds,
     const char* target_name, grpc_core::ChannelArgs* args) {
-  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>();
   grpc_core::RefCountedPtr<grpc_channel_security_connector> sc =

data/src/core/lib/security/credentials/token_fetcher/token_fetcher_credentials.cc

@@ -67,7 +67,6 @@ TokenFetcherCredentials::FetchState::BackoffTimer::BackoffTimer(
       << ": starting backoff timer for " << delay;
   timer_handle_ = fetch_state_->creds_->event_engine().RunAfter(
       delay, [self = Ref()]() mutable {
-        ApplicationCallbackExecCtx callback_exec_ctx;
         ExecCtx exec_ctx;
         self->OnTimer();
         self.reset();
@@ -101,7 +100,7 @@ void TokenFetcherCredentials::FetchState::BackoffTimer::OnTimer() {
       << "]: fetch_state=" << fetch_state_.get() << " backoff_timer=" << this
       << ": backoff timer fired";
   auto* self_ptr =
-      absl::get_if<OrphanablePtr<BackoffTimer>>(&fetch_state_->state_);
+      std::get_if<OrphanablePtr<BackoffTimer>>(&fetch_state_->state_);
   // This condition should always be true, but check to be defensive.
   if (self_ptr != nullptr && self_ptr->get() == this) {
     // Reset pointer in fetch_state_, so that subsequent RPCs know that
@@ -135,7 +134,7 @@ void TokenFetcherCredentials::FetchState::Orphan() {
 }
 
 absl::Status TokenFetcherCredentials::FetchState::status() const {
-  auto* backoff_ptr = absl::get_if<OrphanablePtr<BackoffTimer>>(&state_);
+  auto* backoff_ptr = std::get_if<OrphanablePtr<BackoffTimer>>(&state_);
   if (backoff_ptr == nullptr || *backoff_ptr == nullptr) {
     return absl::OkStatus();
   }
@@ -157,7 +156,7 @@ void TokenFetcherCredentials::FetchState::TokenFetchComplete(
     absl::StatusOr<RefCountedPtr<Token>> token) {
   MutexLock lock(&creds_->mu_);
   // If we were shut down, clean up.
-  if (absl::holds_alternative<Shutdown>(state_)) {
+  if (std::holds_alternative<Shutdown>(state_)) {
     if (token.ok()) token = absl::CancelledError("credentials shutdown");
     GRPC_TRACE_LOG(token_fetcher_credentials, INFO)
         << "[TokenFetcherCredentials " << creds_.get()
@@ -210,7 +209,7 @@ TokenFetcherCredentials::FetchState::QueueCall(
   queued_call->md = std::move(initial_metadata);
   queued_calls_.insert(queued_call);
   // If backoff has expired since the last attempt, trigger a new one.
-  auto* backoff_ptr = absl::get_if<OrphanablePtr<BackoffTimer>>(&state_);
+  auto* backoff_ptr = std::get_if<OrphanablePtr<BackoffTimer>>(&state_);
   if (backoff_ptr != nullptr && backoff_ptr->get() == nullptr) {
     StartFetchAttempt();
   }

data/src/core/lib/security/credentials/token_fetcher/token_fetcher_credentials.h

@@ -22,11 +22,11 @@
 #include <atomic>
 #include <memory>
 #include <utility>
+#include <variant>
 
 #include "absl/container/flat_hash_set.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/status/statusor.h"
-#include "absl/types/variant.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/security/credentials/credentials.h"
@@ -135,7 +135,7 @@ class TokenFetcherCredentials : public grpc_call_credentials {
 
       RefCountedPtr<FetchState> fetch_state_;
       const absl::Status status_;
-      absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+      std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
           timer_handle_ ABSL_GUARDED_BY(&TokenFetcherCredentials::mu_);
     };
 
@@ -149,8 +149,8 @@ class TokenFetcherCredentials : public grpc_call_credentials {
 
     WeakRefCountedPtr<TokenFetcherCredentials> creds_;
     // Pending token-fetch request or backoff timer, if any.
-    absl::variant<OrphanablePtr<FetchRequest>, OrphanablePtr<BackoffTimer>,
-                  Shutdown>
+    std::variant<OrphanablePtr<FetchRequest>, OrphanablePtr<BackoffTimer>,
+                 Shutdown>
         state_ ABSL_GUARDED_BY(&TokenFetcherCredentials::mu_);
     // Calls that are queued up waiting for the token.
     absl::flat_hash_set<RefCountedPtr<QueuedCall>> queued_calls_

data/src/core/lib/security/credentials/xds/xds_credentials.cc

@@ -22,8 +22,9 @@
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/port_platform.h>
 
+#include <optional>
+
 #include "absl/log/check.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h"

data/src/core/lib/security/security_connector/alts/alts_security_connector.cc

@@ -28,13 +28,13 @@
 #include <string.h>
 
 #include <algorithm>
+#include <optional>
 #include <utility>
 
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/handshaker/security/security_handshaker.h"
 #include "src/core/lib/channel/channel_args.h"

data/src/core/lib/security/security_connector/fake/fake_security_connector.cc

@@ -26,6 +26,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <optional>
 #include <string>
 #include <utility>
 
@@ -35,7 +36,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/handshaker/security/security_handshaker.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -200,9 +200,9 @@ class grpc_fake_channel_security_connector final
   }
 
   char* target_;
-  absl::optional<std::string> expected_targets_;
+  std::optional<std::string> expected_targets_;
   bool is_lb_channel_;
-  absl::optional<std::string> target_name_override_;
+  std::optional<std::string> target_name_override_;
 };
 
 void fake_check_peer(grpc_security_connector* /*sc*/, tsi_peer peer,

data/src/core/lib/security/security_connector/local/local_security_connector.cc

@@ -25,6 +25,7 @@
 #include <grpc/support/string_util.h>
 #include <string.h>
 
+#include <optional>
 #include <string>
 #include <utility>
 
@@ -34,7 +35,6 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/match.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/handshaker/security/security_handshaker.h"

data/src/core/lib/security/security_connector/tls/tls_security_connector.cc

@@ -296,11 +296,11 @@ TlsChannelSecurityConnector::TlsChannelSecurityConnector(
   // Register the watcher with the distributor.
   grpc_tls_certificate_distributor* distributor =
       options_->certificate_distributor();
-  absl::optional<std::string> watched_root_cert_name;
+  std::optional<std::string> watched_root_cert_name;
   if (options_->watch_root_cert()) {
     watched_root_cert_name = options_->root_cert_name();
   }
-  absl::optional<std::string> watched_identity_cert_name;
+  std::optional<std::string> watched_identity_cert_name;
   if (options_->watch_identity_pair()) {
     watched_identity_cert_name = options_->identity_cert_name();
   }
@@ -312,7 +312,7 @@ TlsChannelSecurityConnector::TlsChannelSecurityConnector(
   // hence no need to register the watcher.
   bool use_default_roots = !options_->watch_root_cert();
   if (use_default_roots && !options_->watch_identity_pair()) {
-    watcher_ptr->OnCertificatesChanged(absl::nullopt, absl::nullopt);
+    watcher_ptr->OnCertificatesChanged(std::nullopt, std::nullopt);
   } else {
     distributor->WatchTlsCertificates(std::move(watcher_ptr),
                                       watched_root_cert_name,
@@ -428,8 +428,8 @@ ArenaPromise<absl::Status> TlsChannelSecurityConnector::CheckCallHost(
 }
 
 void TlsChannelSecurityConnector::TlsChannelCertificateWatcher::
-    OnCertificatesChanged(absl::optional<absl::string_view> root_certs,
-                          absl::optional<PemKeyCertPairList> key_cert_pairs) {
+    OnCertificatesChanged(std::optional<absl::string_view> root_certs,
+                          std::optional<PemKeyCertPairList> key_cert_pairs) {
   CHECK_NE(security_connector_, nullptr);
   MutexLock lock(&security_connector_->mu_);
   if (root_certs.has_value()) {
@@ -588,11 +588,11 @@ TlsServerSecurityConnector::TlsServerSecurityConnector(
   // Register the watcher with the distributor.
   grpc_tls_certificate_distributor* distributor =
       options_->certificate_distributor();
-  absl::optional<std::string> watched_root_cert_name;
+  std::optional<std::string> watched_root_cert_name;
   if (options_->watch_root_cert()) {
     watched_root_cert_name = options_->root_cert_name();
   }
-  absl::optional<std::string> watched_identity_cert_name;
+  std::optional<std::string> watched_identity_cert_name;
   if (options_->watch_identity_pair()) {
     watched_identity_cert_name = options_->identity_cert_name();
   }
@@ -688,8 +688,8 @@ int TlsServerSecurityConnector::cmp(
 }
 
 void TlsServerSecurityConnector::TlsServerCertificateWatcher::
-    OnCertificatesChanged(absl::optional<absl::string_view> root_certs,
-                          absl::optional<PemKeyCertPairList> key_cert_pairs) {
+    OnCertificatesChanged(std::optional<absl::string_view> root_certs,
+                          std::optional<PemKeyCertPairList> key_cert_pairs) {
   CHECK_NE(security_connector_, nullptr);
   MutexLock lock(&security_connector_->mu_);
   if (root_certs.has_value()) {

data/src/core/lib/security/security_connector/tls/tls_security_connector.h

@@ -25,12 +25,12 @@
 #include <grpc/support/port_platform.h>
 
 #include <map>
+#include <optional>
 #include <string>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -94,12 +94,12 @@ class TlsChannelSecurityConnector final
     return client_handshaker_factory_;
   };
 
-  absl::optional<absl::string_view> RootCertsForTesting() {
+  std::optional<absl::string_view> RootCertsForTesting() {
     MutexLock lock(&mu_);
     return pem_root_certs_;
   }
 
-  absl::optional<PemKeyCertPairList> KeyCertPairListForTesting() {
+  std::optional<PemKeyCertPairList> KeyCertPairListForTesting() {
     MutexLock lock(&mu_);
     return pem_key_cert_pair_list_;
   }
@@ -115,8 +115,8 @@ class TlsChannelSecurityConnector final
         TlsChannelSecurityConnector* security_connector)
         : security_connector_(security_connector) {}
     void OnCertificatesChanged(
-        absl::optional<absl::string_view> root_certs,
-        absl::optional<PemKeyCertPairList> key_cert_pairs) override;
+        std::optional<absl::string_view> root_certs,
+        std::optional<PemKeyCertPairList> key_cert_pairs) override;
     void OnError(grpc_error_handle root_cert_error,
                  grpc_error_handle identity_cert_error) override;
 
@@ -165,8 +165,8 @@ class TlsChannelSecurityConnector final
       ABSL_GUARDED_BY(mu_) = nullptr;
   tsi_ssl_session_cache* ssl_session_cache_ ABSL_GUARDED_BY(mu_) = nullptr;
   RefCountedPtr<TlsSessionKeyLogger> tls_session_key_logger_;
-  absl::optional<absl::string_view> pem_root_certs_ ABSL_GUARDED_BY(mu_);
-  absl::optional<PemKeyCertPairList> pem_key_cert_pair_list_
+  std::optional<absl::string_view> pem_root_certs_ ABSL_GUARDED_BY(mu_);
+  std::optional<PemKeyCertPairList> pem_key_cert_pair_list_
       ABSL_GUARDED_BY(mu_);
   std::map<grpc_closure* /*on_peer_checked*/, ChannelPendingVerifierRequest*>
       pending_verifier_requests_ ABSL_GUARDED_BY(verifier_request_map_mu_);
@@ -204,12 +204,12 @@ class TlsServerSecurityConnector final : public grpc_server_security_connector {
     return server_handshaker_factory_;
   };
 
-  absl::optional<absl::string_view> RootCertsForTesting() {
+  std::optional<absl::string_view> RootCertsForTesting() {
     MutexLock lock(&mu_);
     return pem_root_certs_;
   }
 
-  absl::optional<PemKeyCertPairList> KeyCertPairListForTesting() {
+  std::optional<PemKeyCertPairList> KeyCertPairListForTesting() {
     MutexLock lock(&mu_);
     return pem_key_cert_pair_list_;
   }
@@ -225,8 +225,8 @@ class TlsServerSecurityConnector final : public grpc_server_security_connector {
         TlsServerSecurityConnector* security_connector)
         : security_connector_(security_connector) {}
     void OnCertificatesChanged(
-        absl::optional<absl::string_view> root_certs,
-        absl::optional<PemKeyCertPairList> key_cert_pairs) override;
+        std::optional<absl::string_view> root_certs,
+        std::optional<PemKeyCertPairList> key_cert_pairs) override;
 
     void OnError(grpc_error_handle root_cert_error,
                  grpc_error_handle identity_cert_error) override;
@@ -272,8 +272,8 @@ class TlsServerSecurityConnector final : public grpc_server_security_connector {
       certificate_watcher_ = nullptr;
   tsi_ssl_server_handshaker_factory* server_handshaker_factory_
       ABSL_GUARDED_BY(mu_) = nullptr;
-  absl::optional<absl::string_view> pem_root_certs_ ABSL_GUARDED_BY(mu_);
-  absl::optional<PemKeyCertPairList> pem_key_cert_pair_list_
+  std::optional<absl::string_view> pem_root_certs_ ABSL_GUARDED_BY(mu_);
+  std::optional<PemKeyCertPairList> pem_key_cert_pair_list_
       ABSL_GUARDED_BY(mu_);
   RefCountedPtr<TlsSessionKeyLogger> tls_session_key_logger_;
   std::map<grpc_closure* /*on_peer_checked*/, ServerPendingVerifierRequest*>