grpc 1.68.1 → 1.71.0

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

@@ -90,6 +90,8 @@ class HijackedCall final {
 
 class Interceptor : public UnstartedCallDestination {
  public:
+  using UnstartedCallDestination::UnstartedCallDestination;
+
   void StartCall(UnstartedCallHandler unstarted_call_handler) final {
     unstarted_call_handler.AddCallStack(filter_stack_);
     InterceptCall(std::move(unstarted_call_handler));
@@ -106,7 +108,7 @@ class Interceptor : public UnstartedCallDestination {
     return Map(call_handler.PullClientInitialMetadata(),
                [call_handler, destination = wrapped_destination_](
                    ValueOrFailure<ClientMetadataHandle> metadata) mutable
-               -> ValueOrFailure<HijackedCall> {
+                   -> ValueOrFailure<HijackedCall> {
                  if (!metadata.ok()) return Failure{};
                  return HijackedCall(std::move(metadata.value()),
                                      std::move(destination),
@@ -114,6 +116,13 @@ class Interceptor : public UnstartedCallDestination {
                });
   }
 
+  // Hijack a call with custom initial metadata.
+  // TODO(ctiller): Evaluate whether this or hijack or some other in-between
+  // API is what we need here (I think we need 2 or 3 more fully worked through
+  // samples) and then reduce this surface to one API.
+  CallInitiator MakeChildCall(ClientMetadataHandle metadata,
+                              RefCountedPtr<Arena> arena);
+
   // Consume this call - it will not be passed on to any further filters.
   CallHandler Consume(UnstartedCallHandler unstarted_call_handler) {
     return unstarted_call_handler.StartCall();
@@ -150,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,
@@ -192,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) {
@@ -215,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_;
   }
 
@@ -239,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

@@ -41,11 +41,20 @@ void DebugStringBuilder::AddAfterRedaction(absl::string_view key,
   if (IsAllowListed(key)) {
     Add(key, value);
   } else {
-    Add(key, absl::StrCat(value.size(), " bytes redacted by allow listing."));
+    // If the type of metadata is not in the allow list, we want to prevent it
+    // from getting logged. Custom metadata types may have sensitive information
+    // that should never be logged. Programatically, we have no way to know
+    // which data is sensitive and which is not. So we redact all values which
+    // are not in the allow list.
+    Add(key,
+        absl::StrCat(value.size(), " bytes redacted for security reasons."));
   }
 }
 
 bool DebugStringBuilder::IsAllowListed(const absl::string_view key) const {
+  // We have intentionally not allowed for any way to add to the allow list at
+  // run time, (using a flag or some other setting) because such workarounds
+  // may lead to security issues.
   static const absl::NoDestructor<absl::flat_hash_set<std::string>> allow_list(
       [] {
         absl::flat_hash_set<std::string> allow_list;
@@ -74,8 +83,8 @@ bool DebugStringBuilder::IsAllowListed(const absl::string_view key) const {
         allow_list.insert(std::string(LbTokenMetadata::key()));
         allow_list.insert(std::string(TeMetadata::key()));
         allow_list.insert(std::string(UserAgentMetadata::key()));
+        allow_list.insert(std::string(W3CTraceParentMetadata::key()));
         allow_list.insert(std::string(XEnvoyPeerMetadata::key()));
-
         // go/keep-sorted end
         // go/keep-sorted start
         allow_list.insert(std::string(GrpcCallWasCancelled::DebugKey()));
@@ -105,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.
@@ -468,6 +529,14 @@ struct LbCostBinMetadata {
                                   MetadataParseErrorFn on_error);
 };
 
+// traceparent metadata
+struct W3CTraceParentMetadata : public SimpleSliceBasedMetadata {
+  static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
+  using CompressionTraits = NoCompressionCompressor;
+  static absl::string_view key() { return "traceparent"; }
+};
+
 // Annotation added by a transport to note whether a failed request was never
 // placed on the wire, or never seen by a server.
 struct GrpcStreamNetworkState {
@@ -764,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();
   }
 
@@ -775,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(',');
@@ -792,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_);
   }
@@ -1105,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(); }
@@ -1397,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.
@@ -1430,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);
@@ -1444,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;
     }
@@ -1582,7 +1651,7 @@ using grpc_metadata_batch_base = grpc_core::MetadataMap<
     grpc_core::GrpcServerStatsBinMetadata, grpc_core::GrpcTraceBinMetadata,
     grpc_core::GrpcTagsBinMetadata, grpc_core::GrpcLbClientStatsMetadata,
     grpc_core::LbCostBinMetadata, grpc_core::LbTokenMetadata,
-    grpc_core::XEnvoyPeerMetadata,
+    grpc_core::XEnvoyPeerMetadata, grpc_core::W3CTraceParentMetadata,
     // Non-encodable things
     grpc_core::GrpcStreamNetworkState, grpc_core::PeerString,
     grpc_core::GrpcStatusContext, grpc_core::GrpcStatusFromWire,

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

@@ -42,7 +42,7 @@ struct StableValueCompressor {};
 template <typename T, T value>
 struct KnownValueCompressor {};
 
-// Values are uncompressible, but expect the key to be in most requests and try
+// Values are incompressable, but expect the key to be in most requests and try
 // and compress that.
 struct FrequentKeyWithNoValueCompressionCompressor {};
 
@@ -56,7 +56,7 @@ struct SmallIntegralValuesCompressor {};
 // Specialty compressor for grpc-timeout metadata.
 struct TimeoutCompressor {};
 
-// Specialty compressors for HTTP/2 psuedo headers.
+// Specialty compressors for HTTP/2 pseudo headers.
 struct HttpSchemeCompressor {};
 struct HttpMethodCompressor {};
 struct HttpStatusCompressor {};

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

@@ -109,19 +109,19 @@ Slice Timeout::Encode() const {
     case 5:
       *p++ = '0' + n / 10000;
       n %= 10000;
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 4:
       *p++ = '0' + n / 1000;
       n %= 1000;
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 3:
       *p++ = '0' + n / 100;
       n %= 100;
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 2:
       *p++ = '0' + n / 10;
       n %= 10;
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 1:
       *p++ = '0' + n;
   }
@@ -131,28 +131,28 @@ Slice Timeout::Encode() const {
       break;
     case Unit::kHundredMilliseconds:
       *p++ = '0';
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case Unit::kTenMilliseconds:
       *p++ = '0';
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case Unit::kMilliseconds:
       *p++ = 'm';
       break;
     case Unit::kHundredSeconds:
       *p++ = '0';
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case Unit::kTenSeconds:
       *p++ = '0';
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case Unit::kSeconds:
       *p++ = 'S';
       break;
     case Unit::kHundredMinutes:
       *p++ = '0';
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case Unit::kTenMinutes:
       *p++ = '0';
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case Unit::kMinutes:
       *p++ = 'M';
       break;
@@ -229,7 +229,7 @@ Timeout Timeout::FromHours(int64_t hours) {
   return Timeout(kMaxHours, Unit::kHours);
 }
 
-absl::optional<Duration> ParseTimeout(const Slice& text) {
+std::optional<Duration> ParseTimeout(const Slice& text) {
   int32_t x = 0;
   const uint8_t* p = text.begin();
   const uint8_t* end = text.end();
@@ -249,21 +249,21 @@ absl::optional<Duration> ParseTimeout(const Slice& text) {
     }
     x = x * 10 + digit;
   }
-  if (!have_digit) return absl::nullopt;
+  if (!have_digit) return std::nullopt;
   // skip whitespace
   for (; p != end && *p == ' '; p++) {
   }
-  if (p == end) return absl::nullopt;
+  if (p == end) return std::nullopt;
   // decode unit specifier
   Duration timeout;
   switch (*p) {
     case 'n':
-      timeout =
-          Duration::Milliseconds(x / GPR_NS_PER_MS + (x % GPR_NS_PER_MS != 0));
+      timeout = Duration::Milliseconds((x / GPR_NS_PER_MS) +
+                                       (x % GPR_NS_PER_MS != 0));
       break;
     case 'u':
-      timeout =
-          Duration::Milliseconds(x / GPR_US_PER_MS + (x % GPR_US_PER_MS != 0));
+      timeout = Duration::Milliseconds((x / GPR_US_PER_MS) +
+                                       (x % GPR_US_PER_MS != 0));
       break;
     case 'm':
       timeout = Duration::Milliseconds(x);
@@ -278,10 +278,10 @@ absl::optional<Duration> ParseTimeout(const Slice& text) {
       timeout = Duration::Hours(x);
       break;
     default:
-      return absl::nullopt;
+      return std::nullopt;
   }
   p++;
-  if (!IsAllSpace(p, end)) return absl::nullopt;
+  if (!IsAllSpace(p, end)) return std::nullopt;
   return timeout;
 }
 

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

@@ -22,7 +22,8 @@
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
-#include "absl/types/optional.h"
+#include <optional>
+
 #include "src/core/lib/slice/slice.h"
 #include "src/core/util/time.h"
 
@@ -63,7 +64,7 @@ class Timeout {
   Unit unit_ = Unit::kNanoseconds;
 };
 
-absl::optional<Duration> ParseTimeout(const Slice& text);
+std::optional<Duration> ParseTimeout(const Slice& text);
 
 }  // namespace grpc_core
 

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

@@ -49,7 +49,6 @@ void grpc_stream_destroy(grpc_stream_refcount* refcount) {
     // Throw this over to the executor (on a core-owned thread) and process it
     // there.
     grpc_event_engine::experimental::GetDefaultEventEngine()->Run([refcount] {
-      grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
       grpc_core::ExecCtx exec_ctx;
       grpc_core::ExecCtx::Run(DEBUG_LOCATION, &refcount->destroy,
                               absl::OkStatus());

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

@@ -29,6 +29,7 @@
 #include <string.h>
 
 #include <functional>
+#include <optional>
 #include <string>
 #include <utility>
 
@@ -36,7 +37,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/call_combiner.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -69,6 +69,13 @@
 
 #define GRPC_ARG_TRANSPORT "grpc.internal.transport"
 
+/** A comma separated list of supported transport protocols. If non-empty,
+ allows the client and server to attempt to negotiate transport protocols.
+ NOTE: This is an experimental feature. It is not fully implemented and is not
+ currently functional.
+ TODO(gtcooke94) - update with specific details when implementing. */
+#define GRPC_ARG_TRANSPORT_PROTOCOLS "grpc.internal.transport_protocols"
+
 namespace grpc_core {
 
 // Move only type that tracks call startup.
@@ -364,7 +371,7 @@ struct grpc_transport_stream_op_batch_payload {
     // Will be set by the transport to point to the byte stream containing a
     // received message. Will be nullopt if trailing metadata is received
     // instead of a message.
-    absl::optional<grpc_core::SliceBuffer>* recv_message = nullptr;
+    std::optional<grpc_core::SliceBuffer>* recv_message = nullptr;
     uint32_t* flags = nullptr;
     // Was this recv_message failed for reasons other than a clean end-of-stream
     bool* call_failed_before_recv_message = nullptr;
@@ -413,12 +420,10 @@ typedef struct grpc_transport_op {
   grpc_core::ConnectivityStateWatcherInterface* stop_connectivity_watch =
       nullptr;
   /// should the transport be disconnected
-  /// Error contract: the transport that gets this op must cause
-  ///                disconnect_with_error to be unref'ed after processing it
   grpc_error_handle disconnect_with_error;
-  /// what should the goaway contain?
-  /// Error contract: the transport that gets this op must cause
-  ///                goaway_error to be unref'ed after processing it
+  /// Start a graceful goaway with the specified error message. (The error code
+  /// is ignored since graceful GOAWAYs use a NO_ERROR error code.) Use
+  /// disconnect_with_error if graceful shutdown is not needed.
   grpc_error_handle goaway_error;
   void (*set_accept_stream_fn)(void* user_data, grpc_core::Transport* transport,
                                const void* server_data) = nullptr;