grpc 1.70.1 → 1.71.0

data/src/core/server/server_call_tracer_filter.cc

@@ -87,16 +87,12 @@ class ServerCallTracerFilter
       call_tracer->RecordSendTrailingMetadata(&server_trailing_metadata);
     }
 
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
   };
 };
 
-const NoInterceptor ServerCallTracerFilter::Call::OnClientToServerMessage;
-const NoInterceptor ServerCallTracerFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor ServerCallTracerFilter::Call::OnServerToClientMessage;
-
 const grpc_channel_filter ServerCallTracerFilter::kFilter =
     MakePromiseBasedFilter<ServerCallTracerFilter, FilterEndpoint::kServer,
                            kFilterExaminesServerInitialMetadata>();

data/src/core/server/server_config_selector_filter.cc

@@ -18,13 +18,13 @@
 
 #include <functional>
 #include <memory>
+#include <optional>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
@@ -71,12 +71,12 @@ class ServerConfigSelectorFilter final
    public:
     absl::Status OnClientInitialMetadata(ClientMetadata& md,
                                          ServerConfigSelectorFilter* 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;
   };
 
   absl::StatusOr<RefCountedPtr<ServerConfigSelector>> config_selector() {
@@ -103,7 +103,7 @@ class ServerConfigSelectorFilter final
 
   RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider_;
   Mutex mu_;
-  absl::optional<absl::StatusOr<RefCountedPtr<ServerConfigSelector>>>
+  std::optional<absl::StatusOr<RefCountedPtr<ServerConfigSelector>>>
       config_selector_ ABSL_GUARDED_BY(mu_);
 };
 
@@ -159,13 +159,6 @@ absl::Status ServerConfigSelectorFilter::Call::OnClientInitialMetadata(
   return absl::OkStatus();
 }
 
-const NoInterceptor ServerConfigSelectorFilter::Call::OnServerInitialMetadata;
-const NoInterceptor ServerConfigSelectorFilter::Call::OnServerTrailingMetadata;
-const NoInterceptor ServerConfigSelectorFilter::Call::OnClientToServerMessage;
-const NoInterceptor ServerConfigSelectorFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor ServerConfigSelectorFilter::Call::OnServerToClientMessage;
-const NoInterceptor ServerConfigSelectorFilter::Call::OnFinalize;
-
 }  // namespace
 
 const grpc_channel_filter kServerConfigSelectorFilter =

data/src/core/server/xds_server_config_fetcher.cc

@@ -27,9 +27,11 @@
 #include <algorithm>
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
@@ -43,8 +45,6 @@
 #include "absl/strings/str_join.h"
 #include "absl/strings/str_replace.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -198,10 +198,10 @@ class XdsServerConfigFetcher::ListenerWatcher final
 class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager final
     : public ServerConfigFetcher::ConnectionManager {
  public:
-  FilterChainMatchManager(RefCountedPtr<GrpcXdsClient> xds_client,
-                          XdsListenerResource::FilterChainMap filter_chain_map,
-                          absl::optional<XdsListenerResource::FilterChainData>
-                              default_filter_chain);
+  FilterChainMatchManager(
+      RefCountedPtr<GrpcXdsClient> xds_client,
+      XdsListenerResource::FilterChainMap filter_chain_map,
+      std::optional<XdsListenerResource::FilterChainData> default_filter_chain);
 
   ~FilterChainMatchManager() override {
     xds_client_.reset(DEBUG_LOCATION, "FilterChainMatchManager");
@@ -218,7 +218,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager final
     return filter_chain_map_;
   }
 
-  const absl::optional<XdsListenerResource::FilterChainData>&
+  const std::optional<XdsListenerResource::FilterChainData>&
   default_filter_chain() const {
     return default_filter_chain_;
   }
@@ -227,8 +227,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager final
   class RouteConfigWatcher;
   struct RdsUpdateState {
     RouteConfigWatcher* watcher;
-    absl::optional<
-        absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>>>
+    std::optional<absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>>>
         rds_update;
   };
 
@@ -257,7 +256,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager final
   // a pointer to the filter chain data within that LDS resource, rather
   // than copying the filter chain data here.
   XdsListenerResource::FilterChainMap filter_chain_map_;
-  absl::optional<XdsListenerResource::FilterChainData> default_filter_chain_;
+  std::optional<XdsListenerResource::FilterChainData> default_filter_chain_;
   Mutex mu_;
   size_t rds_resources_yet_to_fetch_ ABSL_GUARDED_BY(mu_) = 0;
   std::map<std::string /* resource_name */, RdsUpdateState> rds_map_
@@ -584,7 +583,7 @@ void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
       << "[ListenerWatcher " << this << "] Received LDS update from xds client "
       << xds_client_.get() << ": " << (*listener)->ToString();
   auto* tcp_listener =
-      absl::get_if<XdsListenerResource::TcpListener>(&(*listener)->listener);
+      std::get_if<XdsListenerResource::TcpListener>(&(*listener)->listener);
   if (tcp_listener == nullptr) {
     MutexLock lock(&mu_);
     OnFatalError(
@@ -679,7 +678,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     FilterChainMatchManager(
         RefCountedPtr<GrpcXdsClient> xds_client,
         XdsListenerResource::FilterChainMap filter_chain_map,
-        absl::optional<XdsListenerResource::FilterChainData>
+        std::optional<XdsListenerResource::FilterChainData>
             default_filter_chain)
     : xds_client_(std::move(xds_client)),
       filter_chain_map_(std::move(filter_chain_map)),
@@ -697,7 +696,7 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       for (const auto& source_ip : source_type) {
         for (const auto& source_port_pair : source_ip.ports_map) {
           auto* filter_chain_data = source_port_pair.second.data.get();
-          const auto* rds_name = absl::get_if<std::string>(
+          const auto* rds_name = std::get_if<std::string>(
               &filter_chain_data->http_connection_manager.route_config);
           if (rds_name != nullptr) resource_names.insert(*rds_name);
           filter_chain_data_set.insert(filter_chain_data);
@@ -707,7 +706,7 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
   }
   if (default_filter_chain_.has_value()) {
     auto& hcm = default_filter_chain_->http_connection_manager;
-    const auto* rds_name = absl::get_if<std::string>(&hcm.route_config);
+    const auto* rds_name = std::get_if<std::string>(&hcm.route_config);
     if (rds_name != nullptr) resource_names.insert(*rds_name);
     std::reverse(hcm.http_filters.begin(), hcm.http_filters.end());
   }
@@ -730,7 +729,7 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       auto route_config_watcher = MakeRefCounted<RouteConfigWatcher>(
           resource_name, WeakRefAsSubclass<FilterChainMatchManager>());
       rds_map_.emplace(resource_name, RdsUpdateState{route_config_watcher.get(),
-                                                     absl::nullopt});
+                                                     std::nullopt});
       watchers_to_start.push_back(
           WatcherToStart{resource_name, std::move(route_config_watcher)});
     }
@@ -773,7 +772,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
   if (it != certificate_providers_map_.end()) return it->second;
   // Configure root cert.
   auto* ca_cert_provider =
-      absl::get_if<CommonTlsContext::CertificateProviderPluginInstance>(
+      std::get_if<CommonTlsContext::CertificateProviderPluginInstance>(
           &filter_chain->downstream_tls_context.common_tls_context
                .certificate_validation_context.ca_certs);
   absl::string_view root_provider_cert_name;
@@ -1115,7 +1114,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       auto& config_selector_route = virtual_host.routes.back();
       config_selector_route.matchers = route.matchers;
       config_selector_route.unsupported_action =
-          absl::get_if<XdsRouteConfigResource::Route::NonForwardingAction>(
+          std::get_if<XdsRouteConfigResource::Route::NonForwardingAction>(
               &route.action) == nullptr;
       auto result = XdsRouting::GeneratePerHTTPFilterConfigsForMethodConfig(
           http_filter_registry, http_filters, vhost, route, nullptr,
@@ -1289,7 +1288,6 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 
 grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(
     grpc_server_xds_status_notifier notifier, const grpc_channel_args* args) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   grpc_core::ChannelArgs channel_args = grpc_core::CoreConfiguration::Get()
                                             .channel_args_preconditioning()

data/src/core/service_config/service_config_channel_arg_filter.cc

@@ -22,13 +22,13 @@
 
 #include <functional>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 
 #include "absl/log/log.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/ext/filters/message_size/message_size_filter.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -81,30 +81,18 @@ class ServiceConfigChannelArgFilter final
    public:
     void OnClientInitialMetadata(ClientMetadata& md,
                                  ServiceConfigChannelArgFilter* 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:
   RefCountedPtr<ServiceConfig> service_config_;
 };
 
-const NoInterceptor
-    ServiceConfigChannelArgFilter::Call::OnServerInitialMetadata;
-const NoInterceptor
-    ServiceConfigChannelArgFilter::Call::OnServerTrailingMetadata;
-const NoInterceptor
-    ServiceConfigChannelArgFilter::Call::OnClientToServerMessage;
-const NoInterceptor
-    ServiceConfigChannelArgFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor
-    ServiceConfigChannelArgFilter::Call::OnServerToClientMessage;
-const NoInterceptor ServiceConfigChannelArgFilter::Call::OnFinalize;
-
 void ServiceConfigChannelArgFilter::Call::OnClientInitialMetadata(
     ClientMetadata& md, ServiceConfigChannelArgFilter* filter) {
   GRPC_LATENT_SEE_INNER_SCOPE(

data/src/core/service_config/service_config_impl.cc

@@ -19,13 +19,13 @@
 #include <grpc/support/port_platform.h>
 #include <string.h>
 
+#include <optional>
 #include <string>
 #include <utility>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -44,8 +44,8 @@ namespace {
 
 struct MethodConfig {
   struct Name {
-    absl::optional<std::string> service;
-    absl::optional<std::string> method;
+    std::optional<std::string> service;
+    std::optional<std::string> method;
 
     static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
       static const auto* loader = JsonObjectLoader<Name>()

data/src/core/telemetry/call_tracer.cc

@@ -101,13 +101,13 @@ class DelegatingClientCallTracer : public ClientCallTracer {
         tracer->RecordSendTrailingMetadata(send_trailing_metadata);
       }
     }
-    void RecordSendMessage(const SliceBuffer& send_message) override {
+    void RecordSendMessage(const Message& send_message) override {
       for (auto* tracer : tracers_) {
         tracer->RecordSendMessage(send_message);
       }
     }
     void RecordSendCompressedMessage(
-        const SliceBuffer& send_compressed_message) override {
+        const Message& send_compressed_message) override {
       for (auto* tracer : tracers_) {
         tracer->RecordSendCompressedMessage(send_compressed_message);
       }
@@ -118,13 +118,13 @@ class DelegatingClientCallTracer : public ClientCallTracer {
         tracer->RecordReceivedInitialMetadata(recv_initial_metadata);
       }
     }
-    void RecordReceivedMessage(const SliceBuffer& recv_message) override {
+    void RecordReceivedMessage(const Message& recv_message) override {
       for (auto* tracer : tracers_) {
         tracer->RecordReceivedMessage(recv_message);
       }
     }
     void RecordReceivedDecompressedMessage(
-        const SliceBuffer& recv_decompressed_message) override {
+        const Message& recv_decompressed_message) override {
       for (auto* tracer : tracers_) {
         tracer->RecordReceivedDecompressedMessage(recv_decompressed_message);
       }
@@ -247,13 +247,13 @@ class DelegatingServerCallTracer : public ServerCallTracer {
       tracer->RecordSendTrailingMetadata(send_trailing_metadata);
     }
   }
-  void RecordSendMessage(const SliceBuffer& send_message) override {
+  void RecordSendMessage(const Message& send_message) override {
     for (auto* tracer : tracers_) {
       tracer->RecordSendMessage(send_message);
     }
   }
   void RecordSendCompressedMessage(
-      const SliceBuffer& send_compressed_message) override {
+      const Message& send_compressed_message) override {
     for (auto* tracer : tracers_) {
       tracer->RecordSendCompressedMessage(send_compressed_message);
     }
@@ -264,13 +264,13 @@ class DelegatingServerCallTracer : public ServerCallTracer {
       tracer->RecordReceivedInitialMetadata(recv_initial_metadata);
     }
   }
-  void RecordReceivedMessage(const SliceBuffer& recv_message) override {
+  void RecordReceivedMessage(const Message& recv_message) override {
     for (auto* tracer : tracers_) {
       tracer->RecordReceivedMessage(recv_message);
     }
   }
   void RecordReceivedDecompressedMessage(
-      const SliceBuffer& recv_decompressed_message) override {
+      const Message& recv_decompressed_message) override {
     for (auto* tracer : tracers_) {
       tracer->RecordReceivedDecompressedMessage(recv_decompressed_message);
     }

data/src/core/telemetry/call_tracer.h

@@ -23,17 +23,18 @@
 #include <grpc/support/time.h>
 
 #include <memory>
+#include <optional>
 #include <string>
 
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/call_final_info.h"
+#include "src/core/lib/transport/message.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/telemetry/tcp_tracer.h"
 #include "src/core/util/ref_counted_string.h"
@@ -95,19 +96,19 @@ class CallTracerInterface : public CallTracerAnnotationInterface {
       grpc_metadata_batch* send_initial_metadata) = 0;
   virtual void RecordSendTrailingMetadata(
       grpc_metadata_batch* send_trailing_metadata) = 0;
-  virtual void RecordSendMessage(const SliceBuffer& send_message) = 0;
+  virtual void RecordSendMessage(const Message& send_message) = 0;
   // Only invoked if message was actually compressed.
   virtual void RecordSendCompressedMessage(
-      const SliceBuffer& send_compressed_message) = 0;
+      const Message& send_compressed_message) = 0;
   // The `RecordReceivedInitialMetadata()` and `RecordReceivedMessage()`
   // methods should only be invoked when the metadata/message was
   // successfully received, i.e., without any error.
   virtual void RecordReceivedInitialMetadata(
       grpc_metadata_batch* recv_initial_metadata) = 0;
-  virtual void RecordReceivedMessage(const SliceBuffer& recv_message) = 0;
+  virtual void RecordReceivedMessage(const Message& recv_message) = 0;
   // Only invoked if message was actually decompressed.
   virtual void RecordReceivedDecompressedMessage(
-      const SliceBuffer& recv_decompressed_message) = 0;
+      const Message& recv_decompressed_message) = 0;
   virtual void RecordCancel(grpc_error_handle cancel_error) = 0;
 
   struct TransportByteSize {

data/src/core/telemetry/metrics.cc

@@ -17,9 +17,9 @@
 #include <grpc/support/port_platform.h>
 
 #include <memory>
+#include <optional>
 
 #include "absl/log/check.h"
-#include "absl/types/optional.h"
 #include "src/core/util/crash.h"
 
 namespace grpc_core {
@@ -164,7 +164,7 @@ GlobalStatsPluginRegistry::GetStatsPluginsForServer(const ChannelArgs& args) {
   return group;
 }
 
-absl::optional<GlobalInstrumentsRegistry::GlobalInstrumentHandle>
+std::optional<GlobalInstrumentsRegistry::GlobalInstrumentHandle>
 GlobalInstrumentsRegistry::FindInstrumentByName(absl::string_view name) {
   const auto& instruments = GetInstrumentList();
   for (const auto& descriptor : instruments) {
@@ -174,7 +174,7 @@ GlobalInstrumentsRegistry::FindInstrumentByName(absl::string_view name) {
       return handle;
     }
   }
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 }  // namespace grpc_core

data/src/core/telemetry/metrics.h

@@ -209,7 +209,7 @@ class GlobalInstrumentsRegistry {
       absl::FunctionRef<void(const GlobalInstrumentDescriptor&)> f);
   static const GlobalInstrumentDescriptor& GetInstrumentDescriptor(
       GlobalInstrumentHandle handle);
-  static absl::optional<GlobalInstrumentsRegistry::GlobalInstrumentHandle>
+  static std::optional<GlobalInstrumentsRegistry::GlobalInstrumentHandle>
   FindInstrumentByName(absl::string_view name);
 
  private:
@@ -479,7 +479,6 @@ class GlobalStatsPluginRegistry {
       std::shared_ptr<StatsPlugin> plugin;
     };
 
-    // C++17 has fold expression that may simplify this.
     template <GlobalInstrumentsRegistry::ValueType V,
               GlobalInstrumentsRegistry::InstrumentType I, size_t M, size_t N>
     static constexpr void AssertIsCallbackGaugeHandle(
@@ -491,11 +490,6 @@ class GlobalStatsPluginRegistry {
           I == GlobalInstrumentsRegistry::InstrumentType::kCallbackGauge,
           "InstrumentType must be kCallbackGauge");
     }
-    template <typename T, typename... Args>
-    static constexpr void AssertIsCallbackGaugeHandle(T t, Args&&... args) {
-      AssertIsCallbackGaugeHandle(t);
-      AssertIsCallbackGaugeHandle(args...);
-    }
 
     std::vector<PluginState> plugins_state_;
   };
@@ -557,7 +551,7 @@ inline std::unique_ptr<RegisteredMetricCallback>
 GlobalStatsPluginRegistry::StatsPluginGroup::RegisterCallback(
     absl::AnyInvocable<void(CallbackMetricReporter&)> callback,
     Duration min_interval, Args... args) {
-  AssertIsCallbackGaugeHandle(args...);
+  (AssertIsCallbackGaugeHandle(args), ...);
   return std::make_unique<RegisteredMetricCallback>(
       *this, std::move(callback),
       std::vector<GlobalInstrumentsRegistry::GlobalInstrumentHandle>{args...},

data/src/core/telemetry/tcp_tracer.h

@@ -23,10 +23,10 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <optional>
 #include <string>
 
 #include "absl/time/time.h"
-#include "absl/types/optional.h"
 
 namespace grpc_core {
 
@@ -53,87 +53,87 @@ class TcpTracerInterface {
     // Congestion control name.
     std::string congestion_ctrl;
     // Delivery rate in Bps.
-    absl::optional<uint64_t> delivery_rate;
+    std::optional<uint64_t> delivery_rate;
     // Total bytes retransmitted so far.
-    absl::optional<uint64_t> data_retx;
+    std::optional<uint64_t> data_retx;
     // Total bytes sent so far.
-    absl::optional<uint64_t> data_sent;
+    std::optional<uint64_t> data_sent;
     // Total packets lost so far.
     // Includes lost or spuriously retransmitted packets.
-    absl::optional<uint32_t> packet_retx;
+    std::optional<uint32_t> packet_retx;
     // Total packets spuriously retransmitted so far.
-    absl::optional<uint32_t> packet_spurious_retx;
+    std::optional<uint32_t> packet_spurious_retx;
     // Total packets sent so far.
-    absl::optional<uint32_t> packet_sent;
+    std::optional<uint32_t> packet_sent;
     // Total packets delivered so far.
-    absl::optional<uint32_t> packet_delivered;
+    std::optional<uint32_t> packet_delivered;
     // Total packets delivered so far with ECE marked.
     // This metric is smaller than or equal to packet_delivered.
-    absl::optional<uint32_t> packet_delivered_ce;
+    std::optional<uint32_t> packet_delivered_ce;
     // Total bytes in write queue but not sent.
-    absl::optional<uint64_t> data_notsent;
+    std::optional<uint64_t> data_notsent;
     // Minimum RTT observed in usec.
-    absl::optional<uint32_t> min_rtt;
+    std::optional<uint32_t> min_rtt;
     // Smoothed RTT in usec
-    absl::optional<uint32_t> srtt;
+    std::optional<uint32_t> srtt;
     // TTL or hop limit of a packet received
     // Only available with ACKED timestamps.
-    absl::optional<uint32_t> ttl;
+    std::optional<uint32_t> ttl;
     // Represents the number of recurring retransmissions of
     // the first sequence that is not acknowledged yet.
-    absl::optional<uint32_t> recurring_retrans;
+    std::optional<uint32_t> recurring_retrans;
     // Network RTT using hardware timestamps (in usec).
     // A value of -1 indicates that net_rtt could not be measured.
-    absl::optional<int32_t> net_rtt_usec;
+    std::optional<int32_t> net_rtt_usec;
     // Timeout-triggered rehash attempts.
-    absl::optional<uint32_t> timeout_rehash;
+    std::optional<uint32_t> timeout_rehash;
     // Rehash due to ECN congestion.
-    absl::optional<uint32_t> ecn_rehash;
+    std::optional<uint32_t> ecn_rehash;
     // Earliest departure time (CLOCK_MONOTONIC).
     // Only available with SCHEDULED and SENT timestamps.
-    absl::optional<uint64_t> edt;
+    std::optional<uint64_t> edt;
     // If the delivery rate is limited by the application, this is set to
     // true.
-    absl::optional<bool> is_delivery_rate_app_limited;
+    std::optional<bool> is_delivery_rate_app_limited;
     // Pacing rate of the connection in Bps.
-    absl::optional<uint64_t> pacing_rate;
+    std::optional<uint64_t> pacing_rate;
     // Send congestion window in packets.
-    absl::optional<uint32_t> congestion_window;
+    std::optional<uint32_t> congestion_window;
     // Maximum degree of reordering (i.e., maximum number of packets reodered)
     // on the connection.
-    absl::optional<uint32_t> reordering;
+    std::optional<uint32_t> reordering;
     // Cumulative duration (in usec) that the transport protocol
     // was busy sending time.
-    absl::optional<uint64_t> busy_usec;
+    std::optional<uint64_t> busy_usec;
     // Cumulative duration (in usec) that the transport protocol
     // was limited by the receive window size.
-    absl::optional<uint64_t> rwnd_limited_usec;
+    std::optional<uint64_t> rwnd_limited_usec;
     // Cumulative duration (in usec) that the transport protocol
     // was limited by the send buffer size.
-    absl::optional<uint64_t> sndbuf_limited_usec;
+    std::optional<uint64_t> sndbuf_limited_usec;
     // Slow start size threshold in packets.
     // Set to TCP_INFINITE_SSTHRESH when still in slow start.
-    absl::optional<uint32_t> snd_ssthresh;
+    std::optional<uint32_t> snd_ssthresh;
     // The extra time it takes for the receiver to generate the
     // acknowledgement after receiving the last packet. This metric is not
     // cumulative. Only available with ACKED timestamps.
-    absl::optional<uint32_t> time_to_ack_usec;
+    std::optional<uint32_t> time_to_ack_usec;
     // Last socket error code. Only populated for CLOSED timestamps.
-    absl::optional<uint32_t> socket_errno;
+    std::optional<uint32_t> socket_errno;
     // Peer's receive window after scaling (tcpi_snd_wnd).
     // Only available with SENDMSG timestamps.
-    absl::optional<uint32_t> peer_rwnd;
+    std::optional<uint32_t> peer_rwnd;
     // Receive queue drops.
-    absl::optional<uint32_t> rcvq_drops;
+    std::optional<uint32_t> rcvq_drops;
     // The NIC Rx delay reported by the remote host.
-    absl::optional<uint32_t> nic_rx_delay_usec;
+    std::optional<uint32_t> nic_rx_delay_usec;
   };
 
   virtual ~TcpTracerInterface() = default;
   // Records a per-message event with an optional snapshot of connection
   // metrics.
   virtual void RecordEvent(Type type, absl::Time time, size_t byte_offset,
-                           absl::optional<ConnectionMetrics> metrics) = 0;
+                           std::optional<ConnectionMetrics> metrics) = 0;
   // Records a snapshot of connection metrics.
   virtual void RecordConnectionMetrics(ConnectionMetrics metrics) = 0;
 };

data/src/core/tsi/alts/handshaker/alts_handshaker_client.cc

@@ -744,7 +744,7 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
                 /*parent_call=*/nullptr, GRPC_PROPAGATE_DEFAULTS,
                 /*cq=*/nullptr, interested_parties,
                 grpc_core::Slice::FromStaticString(ALTS_SERVICE_METHOD),
-                /*authority=*/absl::nullopt, grpc_core::Timestamp::InfFuture(),
+                /*authority=*/std::nullopt, grpc_core::Timestamp::InfFuture(),
                 /*registered_method=*/true);
   GRPC_CLOSURE_INIT(&client->on_handshaker_service_resp_recv, grpc_cb, client,
                     grpc_schedule_on_exec_ctx);
@@ -930,7 +930,7 @@ void alts_handshaker_client_destroy(alts_handshaker_client* c) {
 
 size_t MaxNumberOfConcurrentHandshakes() {
   size_t max_concurrent_handshakes = 100;
-  absl::optional<std::string> env_var_max_concurrent_handshakes =
+  std::optional<std::string> env_var_max_concurrent_handshakes =
       grpc_core::GetEnv(kMaxConcurrentStreamsEnvironmentVariable);
   if (env_var_max_concurrent_handshakes.has_value()) {
     size_t effective_max_concurrent_handshakes = 100;

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.cc

@@ -347,22 +347,22 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
     return TSI_FAILED_PRECONDITION;
   }
   if (grpc_gcp_Identity_attributes_size(identity) != 0) {
-    size_t iter = kUpb_Map_Begin;
-    grpc_gcp_Identity_AttributesEntry* peer_attributes_entry =
-        grpc_gcp_Identity_attributes_nextmutable(peer_identity, &iter);
-    while (peer_attributes_entry != nullptr) {
-      upb_StringView key = grpc_gcp_Identity_AttributesEntry_key(
-          const_cast<grpc_gcp_Identity_AttributesEntry*>(
-              peer_attributes_entry));
-      upb_StringView val = grpc_gcp_Identity_AttributesEntry_value(
-          const_cast<grpc_gcp_Identity_AttributesEntry*>(
-              peer_attributes_entry));
-      grpc_gcp_AltsContext_peer_attributes_set(context, key, val,
-                                               context_arena.ptr());
-      peer_attributes_entry =
-          grpc_gcp_Identity_attributes_nextmutable(peer_identity, &iter);
+    // TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto
+    // v30.0.
+    const upb_Map* upb_map =
+        _grpc_gcp_Identity_attributes_upb_map(peer_identity);
+    if (upb_map) {
+      size_t iter = kUpb_Map_Begin;
+      upb_MessageValue k, v;
+      while (upb_Map_Next(upb_map, &k, &v, &iter)) {
+        upb_StringView key = k.str_val;
+        upb_StringView val = v.str_val;
+        grpc_gcp_AltsContext_peer_attributes_set(context, key, val,
+                                                 context_arena.ptr());
+      }
     }
   }
+
   size_t serialized_ctx_length;
   char* serialized_ctx = grpc_gcp_AltsContext_serialize(
       context, context_arena.ptr(), &serialized_ctx_length);