grpc 1.70.1 → 1.71.0

data/src/core/lib/transport/call_spine.h

@@ -200,47 +200,64 @@ class CallSpine final : public Party {
 
   // Spawned operations: these are callable from /outside/ the call; they spawn
   // an operation into the call and execute that operation.
+  //
+  // Server -> client operations are serialized in the order they are spawned.
+  // Client -> server operations are serialized in the order they are spawned.
+  //
+  // It's required that at most one thread call a server->client operation at a
+  // time, and likewise for client->server operations. There is no requirement
+  // that there be synchronization between the two directionalities.
+  //
+  // No ordering is given between the `Spawn` and the basic operations.
 
   void SpawnPushServerInitialMetadata(ServerMetadataHandle md) {
-    SpawnInfallible(
-        "push-server-initial-metadata",
+    server_to_client_serializer()->Spawn(
         [md = std::move(md), self = RefAsSubclass<CallSpine>()]() mutable {
           self->CancelIfFailed(self->PushServerInitialMetadata(std::move(md)));
         });
   }
 
-  auto SpawnPushServerToClientMessage(MessageHandle msg) {
-    return SpawnWaitable(
-        "push-message",
+  void SpawnPushServerToClientMessage(MessageHandle msg) {
+    server_to_client_serializer()->Spawn(
         [msg = std::move(msg), self = RefAsSubclass<CallSpine>()]() mutable {
-          return self->CancelIfFails(
-              self->PushServerToClientMessage(std::move(msg)));
+          return Map(self->CancelIfFails(
+                         self->PushServerToClientMessage(std::move(msg))),
+                     [](auto) { return Empty{}; });
         });
   }
 
-  auto SpawnPushClientToServerMessage(MessageHandle msg) {
-    return SpawnWaitable(
-        "push-message",
+  void SpawnPushClientToServerMessage(MessageHandle msg) {
+    client_to_server_serializer()->Spawn(
         [msg = std::move(msg), self = RefAsSubclass<CallSpine>()]() mutable {
-          return self->CancelIfFails(
-              self->PushClientToServerMessage(std::move(msg)));
+          return Map(self->CancelIfFails(
+                         self->PushClientToServerMessage(std::move(msg))),
+                     [](auto) { return Empty{}; });
         });
   }
 
   void SpawnFinishSends() {
-    SpawnInfallible("finish-sends", [self = RefAsSubclass<CallSpine>()]() {
+    client_to_server_serializer()->Spawn([self = RefAsSubclass<CallSpine>()]() {
       self->FinishSends();
       return Empty{};
     });
   }
 
   void SpawnPushServerTrailingMetadata(ServerMetadataHandle md) {
-    SpawnInfallible(
-        "push-server-trailing-metadata",
-        [md = std::move(md), self = RefAsSubclass<CallSpine>()]() mutable {
-          self->PushServerTrailingMetadata(std::move(md));
-          return Empty{};
-        });
+    if (md->get(GrpcCallWasCancelled()).value_or(false)) {
+      // Cancellation doesn't serialize with the rest of ops
+      SpawnInfallible(
+          "push-server-trailing-metadata",
+          [md = std::move(md), self = RefAsSubclass<CallSpine>()]() mutable {
+            self->PushServerTrailingMetadata(std::move(md));
+            return Empty{};
+          });
+    } else {
+      server_to_client_serializer()->Spawn(
+          [md = std::move(md), self = RefAsSubclass<CallSpine>()]() mutable {
+            self->PushServerTrailingMetadata(std::move(md));
+            return Empty{};
+          });
+    }
   }
 
   void SpawnCancel() {
@@ -274,11 +291,27 @@ class CallSpine final : public Party {
       : Party(std::move(arena)),
         call_filters_(std::move(client_initial_metadata)) {}
 
+  SpawnSerializer* client_to_server_serializer() {
+    if (client_to_server_serializer_ == nullptr) {
+      client_to_server_serializer_ = MakeSpawnSerializer();
+    }
+    return client_to_server_serializer_;
+  }
+
+  SpawnSerializer* server_to_client_serializer() {
+    if (server_to_client_serializer_ == nullptr) {
+      server_to_client_serializer_ = MakeSpawnSerializer();
+    }
+    return server_to_client_serializer_;
+  }
+
   // Call filters/pipes part of the spine
   CallFilters call_filters_;
   absl::AnyInvocable<void(bool)> on_done_{nullptr};
   // Call spines that should be cancelled if this spine is cancelled
   absl::InlinedVector<RefCountedPtr<CallSpine>, 3> child_calls_;
+  SpawnSerializer* client_to_server_serializer_ = nullptr;
+  SpawnSerializer* server_to_client_serializer_ = nullptr;
 };
 
 class CallHandler;
@@ -304,8 +337,8 @@ class CallInitiator {
     return spine_->PushClientToServerMessage(std::move(message));
   }
 
-  auto SpawnPushMessage(MessageHandle message) {
-    return spine_->SpawnPushClientToServerMessage(std::move(message));
+  void SpawnPushMessage(MessageHandle message) {
+    spine_->SpawnPushClientToServerMessage(std::move(message));
   }
 
   void FinishSends() { spine_->FinishSends(); }
@@ -340,6 +373,11 @@ class CallInitiator {
     return spine_->OnDone(std::move(fn));
   }
 
+  template <typename Promise>
+  auto UntilCallCompletes(Promise promise) {
+    return spine_->UntilCallCompletes(std::move(promise));
+  }
+
   template <typename PromiseFactory>
   void SpawnGuarded(absl::string_view name, PromiseFactory promise_factory) {
     spine_->SpawnGuarded(name, std::move(promise_factory));
@@ -413,8 +451,8 @@ class CallHandler {
     return spine_->PushServerToClientMessage(std::move(message));
   }
 
-  auto SpawnPushMessage(MessageHandle message) {
-    return spine_->SpawnPushServerToClientMessage(std::move(message));
+  void SpawnPushMessage(MessageHandle message) {
+    spine_->SpawnPushServerToClientMessage(std::move(message));
   }
 
   auto PullMessage() { return spine_->PullClientToServerMessage(); }
@@ -425,6 +463,11 @@ class CallHandler {
     return spine_->call_filters().WasCancelledPushed();
   }
 
+  template <typename Promise>
+  auto UntilCallCompletes(Promise promise) {
+    return spine_->UntilCallCompletes(std::move(promise));
+  }
+
   template <typename PromiseFactory>
   void SpawnGuarded(absl::string_view name, PromiseFactory promise_factory,
                     DebugLocation whence = {}) {

data/src/core/lib/transport/call_state.h

@@ -17,7 +17,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/types/optional.h"
+#include <optional>
+
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
@@ -487,7 +488,7 @@ CallState::PollPullClientToServerMessageAvailable() {
     case ClientToServerPullState::kIdle:
       client_to_server_pull_state_ = ClientToServerPullState::kReading;
       client_to_server_pull_waiter_.Wake();
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case ClientToServerPullState::kReading:
       break;
     case ClientToServerPullState::kProcessingClientToServerMessage:
@@ -879,7 +880,7 @@ CallState::PollPullServerToClientMessageAvailable() {
       return server_to_client_pull_waiter_.pending();
     case ServerToClientPullState::kStarted:
       server_to_client_pull_state_ = ServerToClientPullState::kStartedReading;
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case ServerToClientPullState::kStartedReading:
       if (server_to_client_push_state_ ==
           ServerToClientPushState::kTrailersOnly) {
@@ -889,7 +890,7 @@ CallState::PollPullServerToClientMessageAvailable() {
     case ServerToClientPullState::kIdle:
       server_to_client_pull_state_ = ServerToClientPullState::kReading;
       server_to_client_pull_waiter_.Wake();
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case ServerToClientPullState::kReading:
       break;
     case ServerToClientPullState::kProcessingServerToClientMessage:
@@ -1038,7 +1039,7 @@ CallState::PollServerTrailingMetadataAvailable() {
               ServerTrailingMetadataState::kNotPushed) {
             break;  // Ready for processing
           }
-          ABSL_FALLTHROUGH_INTENDED;
+          [[fallthrough]];
         case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
         case ServerToClientPushState::kPushedServerInitialMetadata:
         case ServerToClientPushState::
@@ -1102,12 +1103,11 @@ CallState::PollWasCancelled() {
       << GRPC_DUMP_ARGS(this, server_trailing_metadata_state_);
   switch (server_trailing_metadata_state_) {
     case ServerTrailingMetadataState::kNotPushed:
-    case ServerTrailingMetadataState::kPushed:
-    case ServerTrailingMetadataState::kPushedCancel: {
       return server_trailing_metadata_waiter_.pending();
-    }
+    case ServerTrailingMetadataState::kPushed:
     case ServerTrailingMetadataState::kPulled:
       return false;
+    case ServerTrailingMetadataState::kPushedCancel:
     case ServerTrailingMetadataState::kPulledCancel:
       return true;
   }

data/src/core/lib/transport/connectivity_state.cc

@@ -59,8 +59,7 @@ class AsyncConnectivityStateWatcherInterface::Notifier {
       : watcher_(std::move(watcher)), state_(state), status_(status) {
     if (work_serializer != nullptr) {
       work_serializer->Run(
-          [this]() { SendNotification(this, absl::OkStatus()); },
-          DEBUG_LOCATION);
+          [this]() { SendNotification(this, absl::OkStatus()); });
     } else {
       GRPC_CLOSURE_INIT(&closure_, SendNotification, this,
                         grpc_schedule_on_exec_ctx);
@@ -101,13 +100,13 @@ ConnectivityStateTracker::~ConnectivityStateTracker() {
   grpc_connectivity_state current_state =
       state_.load(std::memory_order_relaxed);
   if (current_state == GRPC_CHANNEL_SHUTDOWN) return;
-  for (const auto& p : watchers_) {
+  for (const auto& watcher : watchers_) {
     GRPC_TRACE_LOG(connectivity_state, INFO)
         << "ConnectivityStateTracker " << name_ << "[" << this
-        << "]: notifying watcher " << p.first << ": "
+        << "]: notifying watcher " << watcher.get() << ": "
         << ConnectivityStateName(current_state) << " -> "
         << ConnectivityStateName(GRPC_CHANNEL_SHUTDOWN);
-    p.second->Notify(GRPC_CHANNEL_SHUTDOWN, absl::Status());
+    watcher->Notify(GRPC_CHANNEL_SHUTDOWN, absl::Status());
   }
 }
 
@@ -130,7 +129,7 @@ void ConnectivityStateTracker::AddWatcher(
   // If we're in state SHUTDOWN, don't add the watcher, so that it will
   // be orphaned immediately.
   if (current_state != GRPC_CHANNEL_SHUTDOWN) {
-    watchers_.insert(std::make_pair(watcher.get(), std::move(watcher)));
+    watchers_.insert(std::move(watcher));
   }
 }
 
@@ -155,13 +154,13 @@ void ConnectivityStateTracker::SetState(grpc_connectivity_state state,
       << status.ToString() << ")";
   state_.store(state, std::memory_order_relaxed);
   status_ = status;
-  for (const auto& p : watchers_) {
+  for (const auto& watcher : watchers_) {
     GRPC_TRACE_LOG(connectivity_state, INFO)
         << "ConnectivityStateTracker " << name_ << "[" << this
-        << "]: notifying watcher " << p.first << ": "
+        << "]: notifying watcher " << watcher.get() << ": "
         << ConnectivityStateName(current_state) << " -> "
         << ConnectivityStateName(state);
-    p.second->Notify(state, status);
+    watcher->Notify(state, status);
   }
   // If the new state is SHUTDOWN, orphan all of the watchers.  This
   // avoids the need for the callers to explicitly cancel them.

data/src/core/lib/transport/connectivity_state.h

@@ -27,6 +27,7 @@
 #include <memory>
 #include <utility>
 
+#include "absl/container/flat_hash_set.h"
 #include "absl/status/status.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/util/orphanable.h"
@@ -132,10 +133,7 @@ class ConnectivityStateTracker {
   const char* name_;
   std::atomic<grpc_connectivity_state> state_{grpc_connectivity_state()};
   absl::Status status_;
-  // TODO(roth): Once we can use C++-14 heterogeneous lookups, this can
-  // be a set instead of a map.
-  std::map<ConnectivityStateWatcherInterface*,
-           OrphanablePtr<ConnectivityStateWatcherInterface>>
+  absl::flat_hash_set<OrphanablePtr<ConnectivityStateWatcherInterface>>
       watchers_;
 };
 

data/src/core/lib/transport/http2_errors.h

@@ -19,8 +19,10 @@
 #ifndef GRPC_SRC_CORE_LIB_TRANSPORT_HTTP2_ERRORS_H
 #define GRPC_SRC_CORE_LIB_TRANSPORT_HTTP2_ERRORS_H
 
+#include <cstdint>
+
 // error codes for RST_STREAM from http2 draft 14 section 7
-typedef enum {
+enum grpc_http2_error_code : uint32_t {
   GRPC_HTTP2_NO_ERROR = 0x0,
   GRPC_HTTP2_PROTOCOL_ERROR = 0x1,
   GRPC_HTTP2_INTERNAL_ERROR = 0x2,
@@ -35,7 +37,7 @@ typedef enum {
   GRPC_HTTP2_ENHANCE_YOUR_CALM = 0xb,
   GRPC_HTTP2_INADEQUATE_SECURITY = 0xc,
   // force use of a default clause
-  GRPC_HTTP2__ERROR_DO_NOT_USE = -1
-} grpc_http2_error_code;
+  GRPC_HTTP2__ERROR_DO_NOT_USE = 0xffffffffu
+};
 
 #endif  // GRPC_SRC_CORE_LIB_TRANSPORT_HTTP2_ERRORS_H

data/src/core/lib/transport/interception_chain.h

@@ -159,9 +159,8 @@ class InterceptionChainBuilder final {
   // the future, and building is a builder responsibility.
   // Instead, we declare a relatively closed set of destinations here, and
   // hide the adaptors inside the builder at build time.
-  using FinalDestination =
-      absl::variant<RefCountedPtr<UnstartedCallDestination>,
-                    RefCountedPtr<CallDestination>>;
+  using FinalDestination = std::variant<RefCountedPtr<UnstartedCallDestination>,
+                                        RefCountedPtr<CallDestination>>;
 
   explicit InterceptionChainBuilder(ChannelArgs args,
                                     const Blackboard* old_blackboard = nullptr,
@@ -201,14 +200,30 @@ class InterceptionChainBuilder final {
 
   // Add a filter that just mutates client initial metadata.
   template <typename F>
-  void AddOnClientInitialMetadata(F f) {
+  InterceptionChainBuilder& AddOnClientInitialMetadata(F f) {
     stack_builder().AddOnClientInitialMetadata(std::move(f));
+    return *this;
   }
 
   // Add a filter that just mutates server trailing metadata.
   template <typename F>
-  void AddOnServerTrailingMetadata(F f) {
+  InterceptionChainBuilder& AddOnServerTrailingMetadata(F f) {
     stack_builder().AddOnServerTrailingMetadata(std::move(f));
+    return *this;
+  }
+
+  // Immediately: Call AddOnServerTrailingMetadata
+  // Then, or every interceptor added to the filter from this point on:
+  // Perform an AddOnServerTrailingMetadata() immediately after
+  // the interceptor was added - but only if other filters or interceptors
+  // are added below it.
+  template <typename F>
+  InterceptionChainBuilder& AddOnServerTrailingMetadataForEachInterceptor(F f) {
+    AddOnServerTrailingMetadata(f);
+    on_new_interception_tail_.emplace_back([f](InterceptionChainBuilder* b) {
+      b->AddOnServerTrailingMetadata(f);
+    });
+    return *this;
   }
 
   void Fail(absl::Status status) {
@@ -224,7 +239,10 @@ class InterceptionChainBuilder final {
 
  private:
   CallFilters::StackBuilder& stack_builder() {
-    if (!stack_builder_.has_value()) stack_builder_.emplace();
+    if (!stack_builder_.has_value()) {
+      stack_builder_.emplace();
+      for (auto& f : on_new_interception_tail_) f(this);
+    }
     return *stack_builder_;
   }
 
@@ -248,8 +266,10 @@ class InterceptionChainBuilder final {
   void AddInterceptor(absl::StatusOr<RefCountedPtr<Interceptor>> interceptor);
 
   ChannelArgs args_;
-  absl::optional<CallFilters::StackBuilder> stack_builder_;
+  std::optional<CallFilters::StackBuilder> stack_builder_;
   RefCountedPtr<Interceptor> top_interceptor_;
+  std::vector<absl::AnyInvocable<void(InterceptionChainBuilder*)>>
+      on_new_interception_tail_;
   absl::Status status_;
   std::map<size_t, size_t> filter_type_counts_;
   static std::atomic<size_t> next_filter_id_;

data/src/core/lib/transport/metadata.h

@@ -17,6 +17,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/transport/metadata_batch.h"
 
 namespace grpc_core {
@@ -31,6 +32,93 @@ using ServerMetadataHandle = Arena::PoolPtr<ServerMetadata>;
 using ClientMetadata = grpc_metadata_batch;
 using ClientMetadataHandle = Arena::PoolPtr<ClientMetadata>;
 
+template <typename T>
+class ServerMetadataOrHandle {
+ public:
+  using ValueType = Arena::PoolPtr<T>;
+
+  static ServerMetadataOrHandle Ok(ValueType value) {
+    return ServerMetadataOrHandle{nullptr, std::move(value)};
+  }
+  static ServerMetadataOrHandle Failure(ServerMetadataHandle server_metadata) {
+    return ServerMetadataOrHandle{std::move(server_metadata), nullptr};
+  }
+
+  bool ok() const { return server_metadata_ == nullptr; }
+  ServerMetadataHandle& metadata() {
+    CHECK(!ok());
+    return server_metadata_;
+  }
+  ValueType& operator*() {
+    CHECK(ok());
+    return value_;
+  }
+  const ServerMetadataHandle& metadata() const {
+    CHECK(!ok());
+    return server_metadata_;
+  }
+  const ValueType& operator*() const {
+    CHECK(ok());
+    return value_;
+  }
+
+ private:
+  ServerMetadataOrHandle(ServerMetadataHandle server_metadata, ValueType value)
+      : server_metadata_(std::move(server_metadata)),
+        value_(std::move(value)) {}
+
+  ServerMetadataHandle server_metadata_;
+  ValueType value_;
+};
+
+template <typename T>
+struct FailureStatusCastImpl<ServerMetadataOrHandle<T>, ServerMetadataHandle> {
+  static ServerMetadataOrHandle<T> Cast(ServerMetadataHandle t) {
+    return ServerMetadataOrHandle<T>::Failure(std::move(t));
+  }
+};
+
+template <typename T>
+struct FailureStatusCastImpl<ServerMetadataOrHandle<T>, ServerMetadataHandle&> {
+  static ServerMetadataOrHandle<T> Cast(ServerMetadataHandle& t) {
+    return ServerMetadataOrHandle<T>::Failure(std::move(t));
+  }
+};
+
+template <typename T>
+inline bool IsStatusOk(const ServerMetadataOrHandle<T>& x) {
+  return x.ok();
+}
+
+namespace promise_detail {
+template <typename T>
+struct AllowGenericTrySeqTraits<ServerMetadataOrHandle<T>> {
+  static constexpr bool value = false;
+};
+template <typename T>
+struct TrySeqTraitsWithSfinae<ServerMetadataOrHandle<T>> {
+  using UnwrappedType = Arena::PoolPtr<T>;
+  using WrappedType = ServerMetadataOrHandle<T>;
+  template <typename Next>
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static auto CallFactory(
+      Next* next, ServerMetadataOrHandle<T>&& status) {
+    return next->Make(std::move(*status));
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static bool IsOk(
+      const ServerMetadataOrHandle<T>& status) {
+    return status.ok();
+  }
+  static std::string ErrorString(const ServerMetadataOrHandle<T>& status) {
+    return status.metadata()->DebugString();
+  }
+  template <typename R>
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static R ReturnValue(
+      ServerMetadataOrHandle<T>&& status) {
+    return FailureStatusCast<R>(status.metadata());
+  }
+};
+}  // namespace promise_detail
+
 // TODO(ctiller): separate when we have different types for client/server
 // metadata.
 template <typename Sink>

data/src/core/lib/transport/metadata_batch.cc

@@ -114,9 +114,9 @@ void UnknownMap::Remove(absl::string_view key) {
                  unknown_.end());
 }
 
-absl::optional<absl::string_view> UnknownMap::GetStringValue(
+std::optional<absl::string_view> UnknownMap::GetStringValue(
     absl::string_view key, std::string* backing) const {
-  absl::optional<absl::string_view> out;
+  std::optional<absl::string_view> out;
   for (const auto& p : unknown_) {
     if (p.first.as_string_view() == key) {
       if (!out.has_value()) {

data/src/core/lib/transport/metadata_batch.h

@@ -25,6 +25,7 @@
 #include <stdlib.h>
 
 #include <cstdint>
+#include <optional>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -35,7 +36,6 @@
 #include "absl/meta/type_traits.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/promise/poll.h"
@@ -369,12 +369,73 @@ struct SimpleIntBasedMetadata : public SimpleIntBasedMetadataBase<Int> {
 };
 
 // grpc-status metadata trait.
-struct GrpcStatusMetadata
-    : public SimpleIntBasedMetadata<grpc_status_code, GRPC_STATUS_UNKNOWN> {
+struct GrpcStatusMetadata {
+  using ValueType = grpc_status_code;
+  using MementoType = grpc_status_code;
+  static ValueType MementoToValue(MementoType value) { return value; }
+  static Slice Encode(ValueType x) { return Slice::FromInt64(x); }
+  static std::string DisplayValue(ValueType x) {
+    switch (x) {
+      case GRPC_STATUS_OK:
+        return "OK";
+      case GRPC_STATUS_CANCELLED:
+        return "CANCELLED";
+      case GRPC_STATUS_UNKNOWN:
+        return "UNKNOWN";
+      case GRPC_STATUS_INVALID_ARGUMENT:
+        return "INVALID_ARGUMENT";
+      case GRPC_STATUS_DEADLINE_EXCEEDED:
+        return "DEADLINE_EXCEEDED";
+      case GRPC_STATUS_NOT_FOUND:
+        return "NOT_FOUND";
+      case GRPC_STATUS_ALREADY_EXISTS:
+        return "ALREADY_EXISTS";
+      case GRPC_STATUS_PERMISSION_DENIED:
+        return "PERMISSION_DENIED";
+      case GRPC_STATUS_RESOURCE_EXHAUSTED:
+        return "RESOURCE_EXHAUSTED";
+      case GRPC_STATUS_FAILED_PRECONDITION:
+        return "FAILED_PRECONDITION";
+      case GRPC_STATUS_ABORTED:
+        return "ABORTED";
+      case GRPC_STATUS_OUT_OF_RANGE:
+        return "OUT_OF_RANGE";
+      case GRPC_STATUS_UNIMPLEMENTED:
+        return "UNIMPLEMENTED";
+      case GRPC_STATUS_INTERNAL:
+        return "INTERNAL";
+      case GRPC_STATUS_UNAVAILABLE:
+        return "UNAVAILABLE";
+      case GRPC_STATUS_DATA_LOSS:
+        return "DATA_LOSS";
+      case GRPC_STATUS_UNAUTHENTICATED:
+        return "UNAUTHENTICATED";
+      default:
+        return absl::StrCat("UNKNOWN(", static_cast<int>(x), ")");
+    }
+  }
+  static auto DisplayMemento(MementoType x) { return DisplayValue(x); }
   static constexpr bool kRepeatable = false;
   static constexpr bool kTransferOnTrailersOnly = false;
   using CompressionTraits = SmallIntegralValuesCompressor<16>;
   static absl::string_view key() { return "grpc-status"; }
+  static grpc_status_code ParseMemento(Slice value, bool,
+                                       MetadataParseErrorFn on_error) {
+    int64_t wire_value;
+    if (!absl::SimpleAtoi(value.as_string_view(), &wire_value)) {
+      on_error("not an integer", value);
+      return GRPC_STATUS_UNKNOWN;
+    }
+    if (wire_value < 0) {
+      on_error("negative value", value);
+      return GRPC_STATUS_UNKNOWN;
+    }
+    if (wire_value >= GRPC_STATUS__DO_NOT_USE) {
+      on_error("out of range", value);
+      return GRPC_STATUS_UNKNOWN;
+    }
+    return static_cast<grpc_status_code>(wire_value);
+  }
 };
 
 // grpc-previous-rpc-attempts metadata trait.
@@ -772,10 +833,10 @@ class GetStringValueHelper {
   GPR_ATTRIBUTE_NOINLINE absl::enable_if_t<
       Trait::kRepeatable == false &&
           std::is_same<Slice, typename Trait::ValueType>::value,
-      absl::optional<absl::string_view>>
+      std::optional<absl::string_view>>
   Found(Trait) {
     const auto* value = container_->get_pointer(Trait());
-    if (value == nullptr) return absl::nullopt;
+    if (value == nullptr) return std::nullopt;
     return value->as_string_view();
   }
 
@@ -783,10 +844,10 @@ class GetStringValueHelper {
   GPR_ATTRIBUTE_NOINLINE absl::enable_if_t<
       Trait::kRepeatable == true &&
           !std::is_same<Slice, typename Trait::ValueType>::value,
-      absl::optional<absl::string_view>>
+      std::optional<absl::string_view>>
   Found(Trait) {
     const auto* value = container_->get_pointer(Trait());
-    if (value == nullptr) return absl::nullopt;
+    if (value == nullptr) return std::nullopt;
     backing_->clear();
     for (const auto& v : *value) {
       if (!backing_->empty()) backing_->push_back(',');
@@ -800,15 +861,15 @@ class GetStringValueHelper {
   GPR_ATTRIBUTE_NOINLINE absl::enable_if_t<
       Trait::kRepeatable == false &&
           !std::is_same<Slice, typename Trait::ValueType>::value,
-      absl::optional<absl::string_view>>
+      std::optional<absl::string_view>>
   Found(Trait) {
     const auto* value = container_->get_pointer(Trait());
-    if (value == nullptr) return absl::nullopt;
+    if (value == nullptr) return std::nullopt;
     *backing_ = std::string(Trait::Encode(*value).as_string_view());
     return *backing_;
   }
 
-  GPR_ATTRIBUTE_NOINLINE absl::optional<absl::string_view> NotFound(
+  GPR_ATTRIBUTE_NOINLINE std::optional<absl::string_view> NotFound(
       absl::string_view key) {
     return container_->unknown_.GetStringValue(key, backing_);
   }
@@ -1113,8 +1174,8 @@ class UnknownMap {
 
   void Append(absl::string_view key, Slice value);
   void Remove(absl::string_view key);
-  absl::optional<absl::string_view> GetStringValue(absl::string_view key,
-                                                   std::string* backing) const;
+  std::optional<absl::string_view> GetStringValue(absl::string_view key,
+                                                  std::string* backing) const;
 
   BackingType::const_iterator begin() const { return unknown_.cbegin(); }
   BackingType::const_iterator end() const { return unknown_.cend(); }
@@ -1405,9 +1466,9 @@ class MetadataMap {
   // Returns nullopt if the metadata is not present.
   // Causes a compilation error if Which is not an element of Traits.
   template <typename Which>
-  absl::optional<typename Which::ValueType> get(Which) const {
+  std::optional<typename Which::ValueType> get(Which) const {
     if (auto* p = table_.template get<Value<Which>>()) return p->value;
-    return absl::nullopt;
+    return std::nullopt;
   }
 
   // Set the value of some known metadata.
@@ -1438,8 +1499,8 @@ class MetadataMap {
   void Remove(const char* key) { Remove(absl::string_view(key)); }
 
   // Retrieve some metadata by name
-  absl::optional<absl::string_view> GetStringValue(absl::string_view name,
-                                                   std::string* buffer) const {
+  std::optional<absl::string_view> GetStringValue(absl::string_view name,
+                                                  std::string* buffer) const {
     metadata_detail::GetStringValueHelper<Derived> helper(
         static_cast<const Derived*>(this), buffer);
     return metadata_detail::NameLookup<Traits...>::Lookup(name, &helper);
@@ -1452,10 +1513,10 @@ class MetadataMap {
   //  m.Remove(T());
   template <typename Which>
   absl::enable_if_t<Which::kRepeatable == false,
-                    absl::optional<typename Which::ValueType>>
+                    std::optional<typename Which::ValueType>>
   Take(Which which) {
     if (auto* p = get_pointer(which)) {
-      absl::optional<typename Which::ValueType> value(std::move(*p));
+      std::optional<typename Which::ValueType> value(std::move(*p));
       Remove(which);
       return value;
     }