grpc 1.70.1 → 1.71.0

data/src/core/handshaker/http_connect/http_proxy_mapper.cc

@@ -25,6 +25,7 @@
 #include <string.h>
 
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 
@@ -40,7 +41,6 @@
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
-#include "absl/types/optional.h"
 #include "src/core/handshaker/http_connect/http_connect_handshaker.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -82,9 +82,9 @@ bool ExactMatchOrSubdomain(absl::string_view host_name,
 
 // Parses the list of host names, addresses or subnet masks and returns true if
 // the target address or host matches any value.
-bool AddressIncluded(
-    const absl::optional<grpc_resolved_address>& target_address,
-    absl::string_view host_name, absl::string_view addresses_and_subnets) {
+bool AddressIncluded(const std::optional<grpc_resolved_address>& target_address,
+                     absl::string_view host_name,
+                     absl::string_view addresses_and_subnets) {
   for (absl::string_view entry :
        absl::StrSplit(addresses_and_subnets, ',', absl::SkipEmpty())) {
     absl::string_view sanitized_entry = absl::StripAsciiWhitespace(entry);
@@ -103,8 +103,8 @@ bool AddressIncluded(
 /// credentials if present in the 'http_proxy' env var, otherwise leaves it
 /// unchanged.
 ///
-absl::optional<std::string> GetHttpProxyServer(
-    const ChannelArgs& args, absl::optional<std::string>* user_cred) {
+std::optional<std::string> GetHttpProxyServer(
+    const ChannelArgs& args, std::optional<std::string>* user_cred) {
   CHECK_NE(user_cred, nullptr);
   absl::StatusOr<URI> uri;
   // We check the following places to determine the HTTP proxy to use, stopping
@@ -115,23 +115,22 @@ absl::optional<std::string> GetHttpProxyServer(
   // 4. http_proxy environment variable
   // If none of the above are set, then no HTTP proxy will be used.
   //
-  absl::optional<std::string> uri_str =
-      args.GetOwnedString(GRPC_ARG_HTTP_PROXY);
+  std::optional<std::string> uri_str = args.GetOwnedString(GRPC_ARG_HTTP_PROXY);
   if (!uri_str.has_value()) uri_str = GetEnv("grpc_proxy");
   if (!uri_str.has_value()) uri_str = GetEnv("https_proxy");
   if (!uri_str.has_value()) uri_str = GetEnv("http_proxy");
-  if (!uri_str.has_value()) return absl::nullopt;
+  if (!uri_str.has_value()) return std::nullopt;
   // an empty value means "don't use proxy"
-  if (uri_str->empty()) return absl::nullopt;
+  if (uri_str->empty()) return std::nullopt;
   uri = URI::Parse(*uri_str);
   if (!uri.ok() || uri->authority().empty()) {
     LOG(ERROR) << "cannot parse value of 'http_proxy' env var. Error: "
                << uri.status();
-    return absl::nullopt;
+    return std::nullopt;
   }
   if (uri->scheme() != "http") {
     LOG(ERROR) << "'" << uri->scheme() << "' scheme not supported in proxy URI";
-    return absl::nullopt;
+    return std::nullopt;
   }
   // Split on '@' to separate user credentials from host
   char** authority_strs = nullptr;
@@ -139,7 +138,7 @@ absl::optional<std::string> GetHttpProxyServer(
   gpr_string_split(uri->authority().c_str(), "@", &authority_strs,
                    &authority_nstrs);
   CHECK_NE(authority_nstrs, 0u);  // should have at least 1 string
-  absl::optional<std::string> proxy_name;
+  std::optional<std::string> proxy_name;
   if (authority_nstrs == 1) {
     // User cred not present in authority
     proxy_name = authority_strs[0];
@@ -150,7 +149,7 @@ absl::optional<std::string> GetHttpProxyServer(
     VLOG(2) << "userinfo found in proxy URI";
   } else {
     // Bad authority
-    proxy_name = absl::nullopt;
+    proxy_name = std::nullopt;
   }
   for (size_t i = 0; i < authority_nstrs; i++) {
     gpr_free(authority_strs[i]);
@@ -170,7 +169,7 @@ std::string MaybeAddDefaultPort(absl::string_view target) {
   return std::string(target);
 }
 
-absl::optional<std::string> GetChannelArgOrEnvVarValue(
+std::optional<std::string> GetChannelArgOrEnvVarValue(
     const ChannelArgs& args, absl::string_view channel_arg,
     const char* env_var) {
   auto arg_value = args.GetOwnedString(channel_arg);
@@ -180,31 +179,31 @@ absl::optional<std::string> GetChannelArgOrEnvVarValue(
   return GetEnv(env_var);
 }
 
-absl::optional<grpc_resolved_address> GetAddressProxyServer(
+std::optional<grpc_resolved_address> GetAddressProxyServer(
     const ChannelArgs& args) {
   auto address_value = GetChannelArgOrEnvVarValue(
       args, GRPC_ARG_ADDRESS_HTTP_PROXY, HttpProxyMapper::kAddressProxyEnvVar);
   if (!address_value.has_value()) {
-    return absl::nullopt;
+    return std::nullopt;
   }
   auto address = StringToSockaddr(*address_value);
   if (!address.ok()) {
     LOG(ERROR) << "cannot parse value of '"
                << std::string(HttpProxyMapper::kAddressProxyEnvVar)
                << "' env var. Error: " << address.status().ToString();
-    return absl::nullopt;
+    return std::nullopt;
   }
   return *address;
 }
 
 }  // namespace
 
-absl::optional<std::string> HttpProxyMapper::MapName(
+std::optional<std::string> HttpProxyMapper::MapName(
     absl::string_view server_uri, ChannelArgs* args) {
   if (!args->GetBool(GRPC_ARG_ENABLE_HTTP_PROXY).value_or(true)) {
-    return absl::nullopt;
+    return std::nullopt;
   }
-  absl::optional<std::string> user_cred;
+  std::optional<std::string> user_cred;
   auto name_to_resolve = GetHttpProxyServer(*args, &user_cred);
   if (!name_to_resolve.has_value()) return name_to_resolve;
   absl::StatusOr<URI> uri = URI::Parse(server_uri);
@@ -212,15 +211,15 @@ absl::optional<std::string> HttpProxyMapper::MapName(
     LOG(ERROR) << "'http_proxy' environment variable set, but cannot "
                   "parse server URI '"
                << server_uri << "' -- not using proxy. Error: " << uri.status();
-    return absl::nullopt;
+    return std::nullopt;
   }
   if (uri->scheme() == "unix") {
     VLOG(2) << "not using proxy for Unix domain socket '" << server_uri << "'";
-    return absl::nullopt;
+    return std::nullopt;
   }
   if (uri->scheme() == "vsock") {
     VLOG(2) << "not using proxy for VSock '" << server_uri << "'";
-    return absl::nullopt;
+    return std::nullopt;
   }
   // Prefer using 'no_grpc_proxy'. Fallback on 'no_proxy' if it is not set.
   auto no_proxy_str = GetEnv("no_grpc_proxy");
@@ -238,12 +237,12 @@ absl::optional<std::string> HttpProxyMapper::MapName(
     } else {
       auto address = StringToSockaddr(server_host, 0);
       if (AddressIncluded(address.ok()
-                              ? absl::optional<grpc_resolved_address>(*address)
-                              : absl::nullopt,
+                              ? std::optional<grpc_resolved_address>(*address)
+                              : std::nullopt,
                           server_host, *no_proxy_str)) {
         VLOG(2) << "not using proxy for host in no_proxy list '" << server_uri
                 << "'";
-        return absl::nullopt;
+        return std::nullopt;
       }
     }
   }
@@ -259,30 +258,30 @@ absl::optional<std::string> HttpProxyMapper::MapName(
   return name_to_resolve;
 }
 
-absl::optional<grpc_resolved_address> HttpProxyMapper::MapAddress(
+std::optional<grpc_resolved_address> HttpProxyMapper::MapAddress(
     const grpc_resolved_address& address, ChannelArgs* args) {
   auto proxy_address = GetAddressProxyServer(*args);
   if (!proxy_address.has_value()) {
-    return absl::nullopt;
+    return std::nullopt;
   }
   auto address_string = grpc_sockaddr_to_string(&address, true);
   if (!address_string.ok()) {
     LOG(ERROR) << "Unable to convert address to string: "
                << address_string.status();
-    return absl::nullopt;
+    return std::nullopt;
   }
   std::string host_name, port;
   if (!SplitHostPort(*address_string, &host_name, &port)) {
     LOG(ERROR) << "Address " << *address_string
                << " cannot be split in host and port";
-    return absl::nullopt;
+    return std::nullopt;
   }
   auto enabled_addresses = GetChannelArgOrEnvVarValue(
       *args, GRPC_ARG_ADDRESS_HTTP_PROXY_ENABLED_ADDRESSES,
       kAddressProxyEnabledAddressesEnvVar);
   if (!enabled_addresses.has_value() ||
       !AddressIncluded(address, host_name, *enabled_addresses)) {
-    return absl::nullopt;
+    return std::nullopt;
   }
   *args = args->Set(GRPC_ARG_HTTP_CONNECT_SERVER, *address_string);
   return proxy_address;

data/src/core/handshaker/http_connect/http_proxy_mapper.h

@@ -21,10 +21,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/handshaker/proxy_mapper.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -38,10 +38,10 @@ class HttpProxyMapper final : public ProxyMapperInterface {
   static constexpr char const* kAddressProxyEnabledAddressesEnvVar =
       "GRPC_ADDRESS_HTTP_PROXY_ENABLED_ADDRESSES";
 
-  absl::optional<std::string> MapName(absl::string_view server_uri,
-                                      ChannelArgs* args) override;
+  std::optional<std::string> MapName(absl::string_view server_uri,
+                                     ChannelArgs* args) override;
 
-  absl::optional<grpc_resolved_address> MapAddress(
+  std::optional<grpc_resolved_address> MapAddress(
       const grpc_resolved_address& address, ChannelArgs* args) override;
 };
 

data/src/core/handshaker/http_connect/xds_http_proxy_mapper.cc

@@ -17,10 +17,10 @@
 #include "src/core/handshaker/http_connect/xds_http_proxy_mapper.h"
 
 #include <memory>
+#include <optional>
 #include <string>
 
 #include "absl/log/log.h"
-#include "absl/types/optional.h"
 #include "src/core/handshaker/http_connect/http_connect_handshaker.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -29,21 +29,21 @@
 
 namespace grpc_core {
 
-absl::optional<grpc_resolved_address> XdsHttpProxyMapper::MapAddress(
+std::optional<grpc_resolved_address> XdsHttpProxyMapper::MapAddress(
     const grpc_resolved_address& endpoint_address, ChannelArgs* args) {
   auto proxy_address_str = args->GetString(GRPC_ARG_XDS_HTTP_PROXY);
-  if (!proxy_address_str.has_value()) return absl::nullopt;
+  if (!proxy_address_str.has_value()) return std::nullopt;
   auto proxy_address = StringToSockaddr(*proxy_address_str);
   if (!proxy_address.ok()) {
     LOG(ERROR) << "error parsing address \"" << *proxy_address_str
                << "\": " << proxy_address.status();
-    return absl::nullopt;
+    return std::nullopt;
   }
   auto endpoint_address_str = grpc_sockaddr_to_string(&endpoint_address, true);
   if (!endpoint_address_str.ok()) {
     LOG(ERROR) << "error converting address to string: "
                << endpoint_address_str.status();
-    return absl::nullopt;
+    return std::nullopt;
   }
   *args = args->Set(GRPC_ARG_HTTP_CONNECT_SERVER, *endpoint_address_str);
   return *proxy_address;

data/src/core/handshaker/http_connect/xds_http_proxy_mapper.h

@@ -17,10 +17,10 @@
 #ifndef GRPC_SRC_CORE_HANDSHAKER_HTTP_CONNECT_XDS_HTTP_PROXY_MAPPER_H
 #define GRPC_SRC_CORE_HANDSHAKER_HTTP_CONNECT_XDS_HTTP_PROXY_MAPPER_H
 
+#include <optional>
 #include <string>
 
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/handshaker/proxy_mapper.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -30,12 +30,12 @@ namespace grpc_core {
 
 class XdsHttpProxyMapper final : public ProxyMapperInterface {
  public:
-  absl::optional<std::string> MapName(absl::string_view /*server_uri*/,
-                                      ChannelArgs* /*args*/) override {
-    return absl::nullopt;
+  std::optional<std::string> MapName(absl::string_view /*server_uri*/,
+                                     ChannelArgs* /*args*/) override {
+    return std::nullopt;
   }
 
-  absl::optional<grpc_resolved_address> MapAddress(
+  std::optional<grpc_resolved_address> MapAddress(
       const grpc_resolved_address& address, ChannelArgs* args) override;
 };
 

data/src/core/handshaker/proxy_mapper.h

@@ -21,10 +21,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 
 #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"
 
@@ -37,13 +37,13 @@ class ProxyMapperInterface {
   /// Determines the proxy name to resolve for \a server_uri.
   /// If no proxy is needed, returns nullopt.
   /// Otherwise, updates \a args and returns the name to resolve.
-  virtual absl::optional<std::string> MapName(absl::string_view server_uri,
-                                              ChannelArgs* args) = 0;
+  virtual std::optional<std::string> MapName(absl::string_view server_uri,
+                                             ChannelArgs* args) = 0;
 
   /// Determines the proxy address to use to contact \a address.
   /// If no proxy is needed, returns nullopt.
   /// Otherwise, updates \a args, and returns a new address.
-  virtual absl::optional<grpc_resolved_address> MapAddress(
+  virtual std::optional<grpc_resolved_address> MapAddress(
       const grpc_resolved_address& address, ChannelArgs* args) = 0;
 };
 

data/src/core/handshaker/proxy_mapper_registry.cc

@@ -22,11 +22,10 @@
 
 #include <algorithm>
 #include <memory>
+#include <optional>
 #include <utility>
 #include <vector>
 
-#include "absl/types/optional.h"
-
 namespace grpc_core {
 
 void ProxyMapperRegistry::Builder::Register(
@@ -44,7 +43,7 @@ ProxyMapperRegistry ProxyMapperRegistry::Builder::Build() {
   return registry;
 }
 
-absl::optional<std::string> ProxyMapperRegistry::MapName(
+std::optional<std::string> ProxyMapperRegistry::MapName(
     absl::string_view server_uri, ChannelArgs* args) const {
   ChannelArgs args_backup = *args;
   for (const auto& mapper : mappers_) {
@@ -53,10 +52,10 @@ absl::optional<std::string> ProxyMapperRegistry::MapName(
     if (r.has_value()) return r;
   }
   *args = args_backup;
-  return absl::nullopt;
+  return std::nullopt;
 }
 
-absl::optional<grpc_resolved_address> ProxyMapperRegistry::MapAddress(
+std::optional<grpc_resolved_address> ProxyMapperRegistry::MapAddress(
     const grpc_resolved_address& address, ChannelArgs* args) const {
   ChannelArgs args_backup = *args;
   for (const auto& mapper : mappers_) {
@@ -65,7 +64,7 @@ absl::optional<grpc_resolved_address> ProxyMapperRegistry::MapAddress(
     if (r.has_value()) return r;
   }
   *args = args_backup;
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 }  // namespace grpc_core

data/src/core/handshaker/proxy_mapper_registry.h

@@ -23,11 +23,11 @@
 
 #include <algorithm>
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/handshaker/proxy_mapper.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
@@ -57,10 +57,10 @@ class ProxyMapperRegistry {
   ProxyMapperRegistry(ProxyMapperRegistry&&) = default;
   ProxyMapperRegistry& operator=(ProxyMapperRegistry&&) = default;
 
-  absl::optional<std::string> MapName(absl::string_view server_uri,
-                                      ChannelArgs* args) const;
+  std::optional<std::string> MapName(absl::string_view server_uri,
+                                     ChannelArgs* args) const;
 
-  absl::optional<grpc_resolved_address> MapAddress(
+  std::optional<grpc_resolved_address> MapAddress(
       const grpc_resolved_address& address, ChannelArgs* args) const;
 
  private:

data/src/core/handshaker/security/secure_endpoint.cc

@@ -31,6 +31,7 @@
 #include <algorithm>
 #include <atomic>
 #include <memory>
+#include <optional>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
@@ -38,7 +39,6 @@
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
@@ -191,7 +191,7 @@ static void maybe_post_reclaimer(secure_endpoint* ep) {
     ep->has_posted_reclaimer.exchange(true, std::memory_order_relaxed);
     ep->memory_owner.PostReclaimer(
         grpc_core::ReclamationPass::kBenign,
-        [ep](absl::optional<grpc_core::ReclamationSweep> sweep) {
+        [ep](std::optional<grpc_core::ReclamationSweep> sweep) {
           if (sweep.has_value()) {
             GRPC_TRACE_LOG(resource_quota, INFO)
                 << "secure endpoint: benign reclamation to free memory";

data/src/core/handshaker/security/security_handshaker.cc

@@ -31,6 +31,7 @@
 
 #include <algorithm>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 
@@ -40,7 +41,6 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/handshaker/handshaker.h"
@@ -199,7 +199,7 @@ MakeChannelzSecurityFromAuthContext(grpc_auth_context* auth_context) {
   // https://github.com/grpc/grpc/blob/fcd43e90304862a823316b224ee733d17a8cfd90/src/proto/grpc/channelz/channelz.proto#L326
   // from grpc_auth_context.
   security->type = channelz::SocketNode::Security::ModelType::kTls;
-  security->tls = absl::make_optional<channelz::SocketNode::Security::Tls>();
+  security->tls = std::make_optional<channelz::SocketNode::Security::Tls>();
   grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name(
       auth_context, GRPC_X509_PEM_CERT_PROPERTY_NAME);
   const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);
@@ -245,7 +245,7 @@ void SecurityHandshaker::OnPeerCheckedFn(grpc_error_handle error) {
   tsi_frame_protector* protector = nullptr;
   switch (frame_protector_type) {
     case TSI_FRAME_PROTECTOR_ZERO_COPY:
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case TSI_FRAME_PROTECTOR_NORMAL_OR_ZERO_COPY:
       // Create zero-copy frame protector.
       result = tsi_handshaker_result_create_zero_copy_grpc_protector(
@@ -440,7 +440,6 @@ void SecurityHandshaker::OnHandshakeDataReceivedFromPeerFnScheduler(
     grpc_error_handle error) {
   args_->event_engine->Run([self = RefAsSubclass<SecurityHandshaker>(),
                             error = std::move(error)]() mutable {
-    ApplicationCallbackExecCtx callback_exec_ctx;
     ExecCtx exec_ctx;
     self->OnHandshakeDataReceivedFromPeerFn(std::move(error));
     // Avoid destruction outside of an ExecCtx (since this is non-cancelable).
@@ -472,7 +471,6 @@ void SecurityHandshaker::OnHandshakeDataSentToPeerFnScheduler(
     grpc_error_handle error) {
   args_->event_engine->Run([self = RefAsSubclass<SecurityHandshaker>(),
                             error = std::move(error)]() mutable {
-    ApplicationCallbackExecCtx callback_exec_ctx;
     ExecCtx exec_ctx;
     self->OnHandshakeDataSentToPeerFn(std::move(error));
     // Avoid destruction outside of an ExecCtx (since this is non-cancelable).

data/src/core/handshaker/tcp_connect/tcp_connect_handshaker.cc

@@ -24,6 +24,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <memory>
+#include <optional>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
@@ -31,7 +32,6 @@
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/handshaker/handshaker_factory.h"
@@ -125,11 +125,13 @@ void TCPConnectHandshaker::DoHandshake(
   }
   CHECK_EQ(args->endpoint.get(), nullptr);
   args_ = args;
-  absl::StatusOr<URI> uri = URI::Parse(
-      args->args.GetString(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS).value());
+  absl::string_view resolved_address_text =
+      args->args.GetString(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS).value();
+  absl::StatusOr<URI> uri = URI::Parse(resolved_address_text);
   if (!uri.ok() || !grpc_parse_uri(*uri, &addr_)) {
     MutexLock lock(&mu_);
-    FinishLocked(GRPC_ERROR_CREATE("Resolved address in invalid format"));
+    FinishLocked(GRPC_ERROR_CREATE(absl::StrCat(
+        "Resolved address in invalid format: ", resolved_address_text)));
     return;
   }
   bind_endpoint_to_pollset_ =

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

@@ -218,34 +218,34 @@ ChannelArgs ChannelArgs::RemoveAllKeysWithPrefix(
   return ChannelArgs(std::move(args));
 }
 
-absl::optional<int> ChannelArgs::GetInt(absl::string_view name) const {
+std::optional<int> ChannelArgs::GetInt(absl::string_view name) const {
   auto* v = Get(name);
-  if (v == nullptr) return absl::nullopt;
+  if (v == nullptr) return std::nullopt;
   return v->GetIfInt();
 }
 
-absl::optional<Duration> ChannelArgs::GetDurationFromIntMillis(
+std::optional<Duration> ChannelArgs::GetDurationFromIntMillis(
     absl::string_view name) const {
   auto ms = GetInt(name);
-  if (!ms.has_value()) return absl::nullopt;
+  if (!ms.has_value()) return std::nullopt;
   if (*ms == INT_MAX) return Duration::Infinity();
   if (*ms == INT_MIN) return Duration::NegativeInfinity();
   return Duration::Milliseconds(*ms);
 }
 
-absl::optional<absl::string_view> ChannelArgs::GetString(
+std::optional<absl::string_view> ChannelArgs::GetString(
     absl::string_view name) const {
   auto* v = Get(name);
-  if (v == nullptr) return absl::nullopt;
+  if (v == nullptr) return std::nullopt;
   const auto s = v->GetIfString();
-  if (s == nullptr) return absl::nullopt;
+  if (s == nullptr) return std::nullopt;
   return s->as_string_view();
 }
 
-absl::optional<std::string> ChannelArgs::GetOwnedString(
+std::optional<std::string> ChannelArgs::GetOwnedString(
     absl::string_view name) const {
-  absl::optional<absl::string_view> v = GetString(name);
-  if (!v.has_value()) return absl::nullopt;
+  std::optional<absl::string_view> v = GetString(name);
+  if (!v.has_value()) return std::nullopt;
   return std::string(*v);
 }
 
@@ -257,13 +257,13 @@ void* ChannelArgs::GetVoidPointer(absl::string_view name) const {
   return pp->c_pointer();
 }
 
-absl::optional<bool> ChannelArgs::GetBool(absl::string_view name) const {
+std::optional<bool> ChannelArgs::GetBool(absl::string_view name) const {
   auto* v = Get(name);
-  if (v == nullptr) return absl::nullopt;
+  if (v == nullptr) return std::nullopt;
   auto i = v->GetIfInt();
   if (!i.has_value()) {
     LOG(ERROR) << name << " ignored: it must be an integer";
-    return absl::nullopt;
+    return std::nullopt;
   }
   switch (*i) {
     case 0:

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

@@ -28,13 +28,13 @@
 #include <algorithm>  // IWYU pragma: keep
 #include <iosfwd>
 #include <memory>
+#include <optional>
 #include <string>
 #include <type_traits>
 #include <utility>
 
 #include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/util/avl.h"
 #include "src/core/util/debug_location.h"
@@ -353,8 +353,8 @@ class ChannelArgs {
         : rep_(RefCountedString::Make(s).release(), &string_vtable_) {}
     explicit Value(Pointer p) : rep_(std::move(p)) {}
 
-    absl::optional<int> GetIfInt() const {
-      if (rep_.c_vtable() != &int_vtable_) return absl::nullopt;
+    std::optional<int> GetIfInt() const {
+      if (rep_.c_vtable() != &int_vtable_) return std::nullopt;
       return reinterpret_cast<intptr_t>(rep_.c_pointer());
     }
     RefCountedPtr<RefCountedString> GetIfString() const {
@@ -496,9 +496,9 @@ class ChannelArgs {
     return Get(ChannelArgNameTraits<T>::ChannelArgName()) != nullptr;
   }
 
-  absl::optional<int> GetInt(absl::string_view name) const;
-  absl::optional<absl::string_view> GetString(absl::string_view name) const;
-  absl::optional<std::string> GetOwnedString(absl::string_view name) const;
+  std::optional<int> GetInt(absl::string_view name) const;
+  std::optional<absl::string_view> GetString(absl::string_view name) const;
+  std::optional<std::string> GetOwnedString(absl::string_view name) const;
   // WARNING: this is broken if `name` represents something that was stored as a
   // RefCounted<const T> - we will discard the const-ness.
   void* GetVoidPointer(absl::string_view name) const;
@@ -508,9 +508,9 @@ class ChannelArgs {
     return static_cast<typename GetObjectImpl<T>::StoredType>(
         GetVoidPointer(name));
   }
-  absl::optional<Duration> GetDurationFromIntMillis(
+  std::optional<Duration> GetDurationFromIntMillis(
       absl::string_view name) const;
-  absl::optional<bool> GetBool(absl::string_view name) const;
+  std::optional<bool> GetBool(absl::string_view name) const;
 
   // Object based get/set.
   // Deal with the common case that we set a pointer to an object under

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

@@ -26,6 +26,7 @@
 
 #include <functional>
 #include <memory>
+#include <optional>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -33,7 +34,6 @@
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/call_finalization.h"
 #include "src/core/lib/channel/channel_args.h"