grpc 1.69.0 → 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));
@@ -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

@@ -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;
     }

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,11 +249,11 @@ 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) {
@@ -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;

data/src/core/load_balancing/backend_metric_parser.cc

@@ -31,23 +31,23 @@ namespace grpc_core {
 
 namespace {
 
-template <typename EntryType>
+// TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto v30.0.
 std::map<absl::string_view, double> ParseMap(
     xds_data_orca_v3_OrcaLoadReport* msg,
-    const EntryType* (*entry_func)(const xds_data_orca_v3_OrcaLoadReport*,
-                                   size_t*),
-    upb_StringView (*key_func)(const EntryType*),
-    double (*value_func)(const EntryType*),
+    const upb_Map* (*upb_map_func)(xds_data_orca_v3_OrcaLoadReport*),
     BackendMetricAllocatorInterface* allocator) {
+  const upb_Map* map = upb_map_func(msg);
   std::map<absl::string_view, double> result;
-  size_t i = kUpb_Map_Begin;
-  while (true) {
-    const auto* entry = entry_func(msg, &i);
-    if (entry == nullptr) break;
-    upb_StringView key_view = key_func(entry);
-    char* key = allocator->AllocateString(key_view.size);
-    memcpy(key, key_view.data, key_view.size);
-    result[absl::string_view(key, key_view.size)] = value_func(entry);
+  if (map) {
+    size_t i = kUpb_Map_Begin;
+    upb_MessageValue k, v;
+    while (upb_Map_Next(map, &k, &v, &i)) {
+      upb_StringView key_view = k.str_val;
+      double value = v.double_val;
+      char* key = allocator->AllocateString(key_view.size);
+      memcpy(key, key_view.data, key_view.size);
+      result[absl::string_view(key, key_view.size)] = value;
+    }
   }
   return result;
 }
@@ -73,21 +73,14 @@ const BackendMetricData* ParseBackendMetricData(
   backend_metric_data->qps =
       xds_data_orca_v3_OrcaLoadReport_rps_fractional(msg);
   backend_metric_data->eps = xds_data_orca_v3_OrcaLoadReport_eps(msg);
-  backend_metric_data->request_cost =
-      ParseMap<xds_data_orca_v3_OrcaLoadReport_RequestCostEntry>(
-          msg, xds_data_orca_v3_OrcaLoadReport_request_cost_next,
-          xds_data_orca_v3_OrcaLoadReport_RequestCostEntry_key,
-          xds_data_orca_v3_OrcaLoadReport_RequestCostEntry_value, allocator);
-  backend_metric_data->utilization =
-      ParseMap<xds_data_orca_v3_OrcaLoadReport_UtilizationEntry>(
-          msg, xds_data_orca_v3_OrcaLoadReport_utilization_next,
-          xds_data_orca_v3_OrcaLoadReport_UtilizationEntry_key,
-          xds_data_orca_v3_OrcaLoadReport_UtilizationEntry_value, allocator);
-  backend_metric_data->named_metrics =
-      ParseMap<xds_data_orca_v3_OrcaLoadReport_NamedMetricsEntry>(
-          msg, xds_data_orca_v3_OrcaLoadReport_named_metrics_next,
-          xds_data_orca_v3_OrcaLoadReport_NamedMetricsEntry_key,
-          xds_data_orca_v3_OrcaLoadReport_NamedMetricsEntry_value, allocator);
+  // TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto
+  // v30.0.
+  backend_metric_data->request_cost = ParseMap(
+      msg, _xds_data_orca_v3_OrcaLoadReport_request_cost_upb_map, allocator);
+  backend_metric_data->utilization = ParseMap(
+      msg, _xds_data_orca_v3_OrcaLoadReport_utilization_upb_map, allocator);
+  backend_metric_data->named_metrics = ParseMap(
+      msg, _xds_data_orca_v3_OrcaLoadReport_named_metrics_upb_map, allocator);
   return backend_metric_data;
 }
 

data/src/core/load_balancing/endpoint_list.cc

@@ -22,6 +22,7 @@
 #include <stdlib.h>
 
 #include <memory>
+#include <optional>
 #include <utility>
 #include <vector>
 
@@ -29,7 +30,6 @@
 #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/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -180,4 +180,14 @@ void EndpointList::ResetBackoffLocked() {
   }
 }
 
+void EndpointList::ReportTransientFailure(absl::Status status) {
+  if (!resolution_note_.empty()) {
+    status = absl::Status(status.code(), absl::StrCat(status.message(), " (",
+                                                      resolution_note_, ")"));
+  }
+  channel_control_helper()->UpdateState(
+      GRPC_CHANNEL_TRANSIENT_FAILURE, status,
+      MakeRefCounted<LoadBalancingPolicy::TransientFailurePicker>(status));
+}
+
 }  // namespace grpc_core