grpc 1.81.1 → 1.83.0

data/src/core/lib/security/authorization/stdout_logger.h

@@ -28,30 +28,31 @@
 namespace grpc_core {
 namespace experimental {
 
-class StdoutAuditLogger : public AuditLogger {
+class StdoutAuditLogger final : public AuditLogger {
  public:
   StdoutAuditLogger() = default;
   absl::string_view name() const override { return "stdout_logger"; }
   void Log(const AuditContext&) override;
 };
 
-class StdoutAuditLoggerFactory : public AuditLoggerFactory {
+class StdoutAuditLoggerFactory final : public AuditLoggerFactory {
  public:
-  class Config : public AuditLoggerFactory::Config {
+  class Config final : public AuditLoggerFactory::Config {
    public:
     Config() = default;
     absl::string_view name() const override;
     std::string ToString() const override;
   };
+
   StdoutAuditLoggerFactory() = default;
 
   absl::string_view name() const override;
 
-  absl::StatusOr<std::unique_ptr<AuditLoggerFactory::Config>>
+  absl::StatusOr<std::shared_ptr<const AuditLoggerFactory::Config>>
   ParseAuditLoggerConfig(const Json& json) override;
 
   std::unique_ptr<AuditLogger> CreateAuditLogger(
-      std::unique_ptr<AuditLoggerFactory::Config>) override;
+      std::shared_ptr<const AuditLoggerFactory::Config> config) override;
 };
 
 }  // namespace experimental

data/src/core/lib/surface/call.cc

@@ -173,6 +173,11 @@ Call::ParentCall* Call::parent_call() {
 }
 
 absl::Status Call::InitParent(Call* parent, uint32_t propagation_mask) {
+  // Virtual RPCs: Provide a link back to the parent session arena to fetch
+  // context.
+  auto* parent_ctx = arena()->New<ParentCallContext>();
+  parent_ctx->arena = parent->arena()->Ref();
+  arena()->SetContext<ParentCallContext>(parent_ctx);
   child_ = arena()->New<ChildCall>(parent);
 
   parent->InternalRef("child");
@@ -243,14 +248,6 @@ void Call::MaybeUnpublishFromParent() {
 }
 
 void Call::CancelWithStatus(grpc_status_code status, const char* description) {
-  if (!IsErrorFlattenEnabled()) {
-    CancelWithError(grpc_error_set_int(
-        grpc_error_set_str(
-            absl::Status(static_cast<absl::StatusCode>(status), description),
-            StatusStrProperty::kGrpcMessage, description),
-        StatusIntProperty::kRpcStatus, status));
-    return;
-  }
   if (status == GRPC_STATUS_OK) {
     VLOG(2) << "CancelWithStatus() called with OK status, using UNKNOWN";
     status = GRPC_STATUS_UNKNOWN;
@@ -629,7 +626,7 @@ const char* grpc_call_error_to_string(grpc_call_error error) {
     case GRPC_CALL_OK:
       return "GRPC_CALL_OK";
   }
-  GPR_UNREACHABLE_CODE(return "GRPC_CALL_ERROR_UNKNOW");
+  GPR_UNREACHABLE_CODE(return "GRPC_CALL_ERROR_UNKNOWN");
 }
 
 void grpc_call_run_in_event_engine(const grpc_call* call,

data/src/core/lib/surface/call.h

@@ -70,6 +70,8 @@ typedef struct grpc_call_create_args {
 
   grpc_core::Timestamp send_deadline;
   bool registered_method;  // client_only
+
+  std::optional<absl::FunctionRef<void(grpc_core::Arena*)>> arena_init_function;
 } grpc_call_create_args;
 
 namespace grpc_core {
@@ -79,6 +81,15 @@ struct ArenaContextType<census_context> {
   static void Destroy(census_context*) {}
 };
 
+struct ParentCallContext {
+  RefCountedPtr<Arena> arena;
+};
+
+template <>
+struct ArenaContextType<ParentCallContext> {
+  static void Destroy(ParentCallContext* p) { p->~ParentCallContext(); }
+};
+
 class Call : public CppImplOf<Call, grpc_call>,
              public grpc_event_engine::experimental::EventEngine::
                  Closure /* for deadlines */,

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

@@ -22,6 +22,8 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/port_platform.h>
 
+#include <optional>
+
 #include "src/core/channelz/channel_trace.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -112,7 +114,8 @@ grpc_call* grpc_channel_create_call(grpc_channel* channel,
           ? std::optional<grpc_core::Slice>(grpc_core::CSliceRef(*host))
           : std::nullopt,
       grpc_core::Timestamp::FromTimespecRoundUp(deadline),
-      /*registered_method=*/false);
+      /*registered_method=*/false,
+      /*arena_init_function=*/std::nullopt);
 }
 
 void* grpc_channel_register_call(grpc_channel* channel, const char* method,
@@ -148,7 +151,23 @@ grpc_call* grpc_channel_create_registered_call(
           ? std::optional<grpc_core::Slice>(rc->authority->Ref())
           : std::nullopt,
       grpc_core::Timestamp::FromTimespecRoundUp(deadline),
-      /*registered_method=*/true);
+      /*registered_method=*/true,
+      /*arena_init_function=*/std::nullopt);
+}
+
+grpc_call* grpc_channel_create_call_with_arena_init(
+    grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
+    grpc_completion_queue* completion_queue, grpc_core::Slice method,
+    std::optional<grpc_core::Slice> authority, gpr_timespec deadline,
+    bool registered_method,
+    std::optional<absl::FunctionRef<void(grpc_core::Arena*)>>
+        arena_init_function) {
+  grpc_core::ExecCtx exec_ctx;
+  return grpc_core::Channel::FromC(channel)->CreateCall(
+      parent_call, propagation_mask, completion_queue, nullptr,
+      std::move(method), std::move(authority),
+      grpc_core::Timestamp::FromTimespecRoundUp(deadline), registered_method,
+      arena_init_function);
 }
 
 char* grpc_channel_get_target(grpc_channel* channel) {

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

@@ -73,12 +73,12 @@ class Channel : public UnstartedCallDestination,
   virtual bool IsLame() const = 0;
 
   // TODO(roth): This should return a C++ type.
-  virtual grpc_call* CreateCall(grpc_call* parent_call,
-                                uint32_t propagation_mask,
-                                grpc_completion_queue* cq,
-                                grpc_pollset_set* pollset_set_alternative,
-                                Slice path, std::optional<Slice> authority,
-                                Timestamp deadline, bool registered_method) = 0;
+  virtual grpc_call* CreateCall(
+      grpc_call* parent_call, uint32_t propagation_mask,
+      grpc_completion_queue* cq, grpc_pollset_set* pollset_set_alternative,
+      Slice path, std::optional<Slice> authority, Timestamp deadline,
+      bool registered_method,
+      std::optional<absl::FunctionRef<void(Arena*)>> arena_init_function) = 0;
 
   virtual grpc_event_engine::experimental::EventEngine* event_engine()
       const = 0;
@@ -178,4 +178,12 @@ inline grpc_core::channelz::ChannelNode* grpc_channel_get_channelz_node(
 void grpc_channel_ping(grpc_channel* channel, grpc_completion_queue* cq,
                        void* tag, void* reserved);
 
+grpc_call* grpc_channel_create_call_with_arena_init(
+    grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
+    grpc_completion_queue* completion_queue, grpc_core::Slice method,
+    std::optional<grpc_core::Slice> authority, gpr_timespec deadline,
+    bool registered_method,
+    std::optional<absl::FunctionRef<void(grpc_core::Arena*)>>
+        arena_init_function);
+
 #endif  // GRPC_SRC_CORE_LIB_SURFACE_CHANNEL_H

data/src/core/lib/surface/filter_stack_call.cc

@@ -111,6 +111,9 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
   RefCountedPtr<Arena> arena = channel->call_arena_allocator()->MakeArena();
   arena->SetContext<grpc_event_engine::experimental::EventEngine>(
       args->channel->event_engine());
+  if (args->arena_init_function.has_value()) {
+    (*args->arena_init_function)(arena.get());
+  }
   call = new (arena->Alloc(call_alloc_size)) FilterStackCall(arena, *args);
   GRPC_DCHECK(FromC(call->c_ptr()) == call);
   GRPC_DCHECK(FromCallStack(call->call_stack()) == call);
@@ -458,32 +461,10 @@ void FilterStackCall::RecvTrailingFilter(grpc_metadata_batch* b,
   } else {
     std::optional<grpc_status_code> grpc_status = b->Take(GrpcStatusMetadata());
     if (grpc_status.has_value()) {
-      grpc_error_handle error;
-      if (IsErrorFlattenEnabled()) {
-        auto grpc_message = b->Take(GrpcMessageMetadata());
-        absl::string_view message;
-        if (grpc_message.has_value()) message = grpc_message->as_string_view();
-        error =
-            absl::Status(static_cast<absl::StatusCode>(*grpc_status), message);
-      } else {
-        grpc_status_code status_code = *grpc_status;
-        if (status_code != GRPC_STATUS_OK) {
-          Slice peer = GetPeerString();
-          error = grpc_error_set_int(
-              GRPC_ERROR_CREATE(absl::StrCat("Error received from peer ",
-                                             peer.as_string_view())),
-              StatusIntProperty::kRpcStatus,
-              static_cast<intptr_t>(status_code));
-        }
-        auto grpc_message = b->Take(GrpcMessageMetadata());
-        if (grpc_message.has_value()) {
-          error = grpc_error_set_str(error, StatusStrProperty::kGrpcMessage,
-                                     grpc_message->as_string_view());
-        } else if (!error.ok()) {
-          error =
-              grpc_error_set_str(error, StatusStrProperty::kGrpcMessage, "");
-        }
-      }
+      auto grpc_message = b->Take(GrpcMessageMetadata());
+      absl::string_view message;
+      if (grpc_message.has_value()) message = grpc_message->as_string_view();
+      absl::Status error(static_cast<absl::StatusCode>(*grpc_status), message);
       SetFinalStatus(error);
     } else if (!is_client()) {
       SetFinalStatus(absl::OkStatus());
@@ -929,10 +910,10 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
               Slice(grpc_slice_copy(
                   *op->data.send_status_from_server.status_details)));
           if (!status_error.ok()) {
-            status_error = grpc_error_set_str(
-                status_error, StatusStrProperty::kGrpcMessage,
+            status_error = AddMessageDetail(
                 StringViewFromSlice(
-                    *op->data.send_status_from_server.status_details));
+                    *op->data.send_status_from_server.status_details),
+                status_error);
           }
         }
 

data/src/core/lib/surface/legacy_channel.cc

@@ -160,13 +160,12 @@ bool LegacyChannel::IsLame() const {
   return elem->filter == &LameClientFilter::kFilter;
 }
 
-grpc_call* LegacyChannel::CreateCall(grpc_call* parent_call,
-                                     uint32_t propagation_mask,
-                                     grpc_completion_queue* cq,
-                                     grpc_pollset_set* pollset_set_alternative,
-                                     Slice path, std::optional<Slice> authority,
-                                     Timestamp deadline,
-                                     bool registered_method) {
+grpc_call* LegacyChannel::CreateCall(
+    grpc_call* parent_call, uint32_t propagation_mask,
+    grpc_completion_queue* cq, grpc_pollset_set* pollset_set_alternative,
+    Slice path, std::optional<Slice> authority, Timestamp deadline,
+    bool registered_method,
+    std::optional<absl::FunctionRef<void(Arena*)>> arena_init_function) {
   GRPC_CHECK(is_client_);
   GRPC_CHECK(!(cq != nullptr && pollset_set_alternative != nullptr));
   grpc_call_create_args args;
@@ -181,6 +180,7 @@ grpc_call* LegacyChannel::CreateCall(grpc_call* parent_call,
   args.authority = std::move(authority);
   args.send_deadline = deadline;
   args.registered_method = registered_method;
+  args.arena_init_function = arena_init_function;
   grpc_call* call;
   GRPC_LOG_IF_ERROR("call_create", grpc_call_create(&args, &call));
   return call;

data/src/core/lib/surface/legacy_channel.h

@@ -62,7 +62,9 @@ class LegacyChannel final : public Channel {
                         grpc_completion_queue* cq,
                         grpc_pollset_set* pollset_set_alternative, Slice path,
                         std::optional<Slice> authority, Timestamp deadline,
-                        bool registered_method) override;
+                        bool registered_method,
+                        std::optional<absl::FunctionRef<void(Arena*)>>
+                            arena_init_function) override;
 
   void StartCall(UnstartedCallHandler) override {
     Crash("StartCall() not supported on LegacyChannel");

data/src/core/lib/surface/version.cc

@@ -22,6 +22,6 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-const char* grpc_version_string(void) { return "54.0.0"; }
+const char* grpc_version_string(void) { return "56.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "graphic"; }
+const char* grpc_g_stands_for(void) { return "garden"; }

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

@@ -33,23 +33,23 @@ namespace grpc_core {
 
 BdpEstimator::BdpEstimator(absl::string_view name)
     : accumulator_(0),
-      estimate_(65536),
+      estimate_(kInitialBdpDefault),
       ping_start_time_(gpr_time_0(GPR_CLOCK_MONOTONIC)),
-      inter_ping_delay_(Duration::Milliseconds(100)),  // start at 100ms
+      inter_ping_delay_(Duration::Milliseconds(kDefaultInterPingDelayMillis)),
       stable_estimate_count_(0),
       ping_state_(PingState::UNSCHEDULED),
       bw_est_(0),
-      name_(name) {}
+      peer_name_(name) {}
 
 Timestamp BdpEstimator::CompletePing() {
-  gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
-  gpr_timespec dt_ts = gpr_time_sub(now, ping_start_time_);
-  double dt = static_cast<double>(dt_ts.tv_sec) +
-              (1e-9 * static_cast<double>(dt_ts.tv_nsec));
-  double bw = dt > 0 ? (static_cast<double>(accumulator_) / dt) : 0;
-  Duration start_inter_ping_delay = inter_ping_delay_;
+  const gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
+  const gpr_timespec dt_ts = gpr_time_sub(now, ping_start_time_);
+  const double dt = static_cast<double>(dt_ts.tv_sec) +
+                    (1e-9 * static_cast<double>(dt_ts.tv_nsec));
+  const double bw = (dt > 0) ? (static_cast<double>(accumulator_) / dt) : 0;
+  const Duration start_inter_ping_delay = inter_ping_delay_;
   GRPC_TRACE_LOG(bdp_estimator, INFO)
-      << "bdp[" << name_ << "]:complete acc=" << accumulator_
+      << "bdp[" << peer_name_ << "]:complete acc=" << accumulator_
       << " est=" << estimate_ << " dt=" << dt << " bw=" << bw / 125000.0
       << "Mbs bw_est=" << bw_est_ / 125000.0 << "Mbs";
   GRPC_CHECK(ping_state_ == PingState::STARTED);
@@ -57,10 +57,10 @@ Timestamp BdpEstimator::CompletePing() {
     estimate_ = std::max(accumulator_, estimate_ * 2);
     bw_est_ = bw;
     GRPC_TRACE_LOG(bdp_estimator, INFO)
-        << "bdp[" << name_ << "]: estimate increased to " << estimate_;
+        << "bdp[" << peer_name_ << "]: estimate increased to " << estimate_;
     inter_ping_delay_ /= 2;  // if the ping estimate changes,
                              // exponentially get faster at probing
-  } else if (inter_ping_delay_ < Duration::Seconds(10)) {
+  } else if (inter_ping_delay_ < Duration::Seconds(kMaxInterPingDelaySeconds)) {
     stable_estimate_count_++;
     if (stable_estimate_count_ >= 2) {
       // If the ping estimate is steady, slowly ramp down the probe time.
@@ -72,7 +72,7 @@ Timestamp BdpEstimator::CompletePing() {
   if (start_inter_ping_delay != inter_ping_delay_) {
     stable_estimate_count_ = 0;
     GRPC_TRACE_LOG(bdp_estimator, INFO)
-        << "bdp[" << name_ << "]:update_inter_time to "
+        << "bdp[" << peer_name_ << "]:update_inter_time to "
         << inter_ping_delay_.millis() << "ms";
   }
   ping_state_ = PingState::UNSCHEDULED;

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

@@ -23,6 +23,7 @@
 #include <grpc/support/time.h>
 #include <inttypes.h>
 
+#include <cstdint>
 #include <string>
 
 #include "src/core/lib/debug/trace.h"
@@ -33,6 +34,10 @@
 
 namespace grpc_core {
 
+constexpr int64_t kInitialBdpDefault = 65536;
+constexpr uint32_t kDefaultInterPingDelayMillis = 100;
+constexpr uint32_t kMaxInterPingDelaySeconds = 10;
+
 class BdpEstimator {
  public:
   explicit BdpEstimator(absl::string_view name);
@@ -48,7 +53,7 @@ class BdpEstimator {
   // transport (but not necessarily started)
   void SchedulePing() {
     GRPC_TRACE_LOG(bdp_estimator, INFO)
-        << "bdp[" << name_ << "]:sched acc=" << accumulator_
+        << "bdp[" << peer_name_ << "]:sched acc=" << accumulator_
         << " est=" << estimate_;
     GRPC_CHECK(ping_state_ == PingState::UNSCHEDULED);
     ping_state_ = PingState::SCHEDULED;
@@ -56,11 +61,10 @@ class BdpEstimator {
   }
 
   // Start a ping: call after calling grpc_bdp_estimator_schedule_ping and
-  // once
-  // the ping is on the wire
+  // once the ping is on the wire.
   void StartPing() {
     GRPC_TRACE_LOG(bdp_estimator, INFO)
-        << "bdp[" << name_ << "]:start acc=" << accumulator_
+        << "bdp[" << peer_name_ << "]:start acc=" << accumulator_
         << " est=" << estimate_;
     GRPC_CHECK(ping_state_ == PingState::SCHEDULED);
     ping_state_ = PingState::STARTED;
@@ -83,7 +87,7 @@ class BdpEstimator {
   int stable_estimate_count_;
   PingState ping_state_;
   double bw_est_;
-  absl::string_view name_;
+  absl::string_view peer_name_;
 };
 
 }  // namespace grpc_core

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

@@ -63,159 +63,47 @@ void grpc_error_get_status(grpc_error_handle error,
                            grpc_status_code* code, std::string* message,
                            Http2ErrorCode* http_error,
                            const char** error_string) {
-  if (grpc_core::IsErrorFlattenEnabled()) {
-    auto http_error_code = GetHttp2Error(error);
-    if (code != nullptr) {
-      // If the top-level status code is UNKNOWN and there is an HTTP2 error
-      // code attribute set, convert from that.  Otherwise, use the top-level
-      // status code.
-      if (error.code() == absl::StatusCode::kUnknown &&
-          http_error_code.has_value()) {
-        *code = grpc_http2_error_to_grpc_status(*http_error_code, deadline);
-      } else {
-        *code = static_cast<grpc_status_code>(error.code());
-      }
-    }
-    if (message != nullptr) *message = std::string(error.message());
-    if (error_string != nullptr && !error.ok()) {
-      *error_string = gpr_strdup(grpc_core::StatusToString(error).c_str());
-    }
-    if (http_error != nullptr) {
-      // If the HTTP2 error code attribute is present, use it.  Otherwise,
-      // if the status code is something other than UNKNOWN, convert from
-      // that.  Otherwise, set a default based on whether the status
-      // code is OK.
-      if (http_error_code.has_value()) {
-        *http_error = *http_error_code;
-      } else if (error.code() != absl::StatusCode::kUnknown) {
-        *http_error = grpc_status_to_http2_error(
-            static_cast<grpc_status_code>(error.code()));
-      } else {
-        *http_error = error.ok() ? Http2ErrorCode::kNoError
-                                 : Http2ErrorCode::kInternalError;
-      }
-    }
-    return;
-  }
-
-  // Fast path: We expect no error.
-  if (GPR_LIKELY(error.ok())) {
-    if (code != nullptr) *code = GRPC_STATUS_OK;
-    if (message != nullptr) {
-      // Normally, we call grpc_error_get_str(
-      //   error, grpc_core::StatusStrProperty::kGrpcMessage, message).
-      // We can fastpath since we know that:
-      // 1) Error is null
-      // 2) which == grpc_core::StatusStrProperty::kGrpcMessage
-      // 3) The resulting message is statically known.
-      // 4) Said resulting message is "".
-      // This means 3 movs, instead of 10s of instructions and a strlen.
-      *message = "";
-    }
-    if (http_error != nullptr) {
-      *http_error = Http2ErrorCode::kNoError;
+  auto http_error_code = GetHttp2Error(error);
+  if (code != nullptr) {
+    // If the top-level status code is UNKNOWN and there is an HTTP2 error
+    // code attribute set, convert from that.  Otherwise, use the top-level
+    // status code.
+    if (error.code() == absl::StatusCode::kUnknown &&
+        http_error_code.has_value()) {
+      *code = grpc_http2_error_to_grpc_status(*http_error_code, deadline);
+    } else {
+      *code = static_cast<grpc_status_code>(error.code());
     }
-    return;
   }
-
-  // Start with the parent error and recurse through the tree of children
-  // until we find the first one that has a status code.
-  grpc_error_handle found_error = recursively_find_error_with_field(
-      error, grpc_core::StatusIntProperty::kRpcStatus);
-  if (found_error.ok()) {
-    /// If no grpc-status exists, retry through the tree to find a http2 error
-    /// code
-    found_error = recursively_find_error_with_field(
-        error, grpc_core::StatusIntProperty::kHttp2Error);
-  }
-
-  // If we found an error with a status code above, use that; otherwise,
-  // fall back to using the parent error.
-  if (found_error.ok()) found_error = error;
-
-  grpc_status_code status = GRPC_STATUS_UNKNOWN;
-  intptr_t integer;
-  if (grpc_error_get_int(found_error, grpc_core::StatusIntProperty::kRpcStatus,
-                         &integer)) {
-    status = static_cast<grpc_status_code>(integer);
-  } else if (grpc_error_get_int(found_error,
-                                grpc_core::StatusIntProperty::kHttp2Error,
-                                &integer)) {
-    status = grpc_http2_error_to_grpc_status(
-        static_cast<Http2ErrorCode>(integer), deadline);
-  } else {
-    status = static_cast<grpc_status_code>(found_error.code());
-  }
-  if (code != nullptr) *code = status;
-
-  if (error_string != nullptr && status != GRPC_STATUS_OK) {
+  if (message != nullptr) *message = std::string(error.message());
+  if (error_string != nullptr && !error.ok()) {
     *error_string = gpr_strdup(grpc_core::StatusToString(error).c_str());
   }
-
   if (http_error != nullptr) {
-    if (grpc_error_get_int(
-            found_error, grpc_core::StatusIntProperty::kHttp2Error, &integer)) {
-      *http_error = static_cast<Http2ErrorCode>(integer);
-    } else if (grpc_error_get_int(found_error,
-                                  grpc_core::StatusIntProperty::kRpcStatus,
-                                  &integer)) {
-      *http_error =
-          grpc_status_to_http2_error(static_cast<grpc_status_code>(integer));
+    // If the HTTP2 error code attribute is present, use it.  Otherwise,
+    // if the status code is something other than UNKNOWN, convert from
+    // that.  Otherwise, set a default based on whether the status
+    // code is OK.
+    if (http_error_code.has_value()) {
+      *http_error = *http_error_code;
+    } else if (error.code() != absl::StatusCode::kUnknown) {
+      *http_error = grpc_status_to_http2_error(
+          static_cast<grpc_status_code>(error.code()));
     } else {
-      *http_error = found_error.ok() ? Http2ErrorCode::kNoError
-                                     : Http2ErrorCode::kInternalError;
-    }
-  }
-
-  // If the error has a status message, use it.  Otherwise, fall back to
-  // the error description.
-  if (message != nullptr) {
-    if (!grpc_error_get_str(
-            found_error, grpc_core::StatusStrProperty::kGrpcMessage, message)) {
-      *message = found_error.message().empty()
-                     ? grpc_core::StatusToString(error)
-                     : std::string(found_error.message());
+      *http_error = error.ok() ? Http2ErrorCode::kNoError
+                               : Http2ErrorCode::kInternalError;
     }
   }
 }
 
 absl::Status grpc_error_to_absl_status(grpc_error_handle error) {
-  if (grpc_core::IsErrorFlattenEnabled()) return error;
-  grpc_status_code status;
-  // TODO(yashykt): This should be updated once we decide on how to use the
-  // absl::Status payload to capture all the contents of grpc_error.
-  std::string message;
-  grpc_error_get_status(error, grpc_core::Timestamp::InfFuture(), &status,
-                        &message, nullptr /* http_error */,
-                        nullptr /* error_string */);
-  return absl::Status(static_cast<absl::StatusCode>(status), message);
+  return error;
 }
 
 grpc_error_handle absl_status_to_grpc_error(absl::Status status) {
-  if (grpc_core::IsErrorFlattenEnabled()) return status;
-  // Special error checks
-  if (status.ok()) {
-    return absl::OkStatus();
-  }
-  return grpc_error_set_int(GRPC_ERROR_CREATE(status.message()),
-                            grpc_core::StatusIntProperty::kRpcStatus,
-                            static_cast<grpc_status_code>(status.code()));
+  return status;
 }
 
 bool grpc_error_has_clear_grpc_status(grpc_error_handle error) {
-  if (grpc_core::IsErrorFlattenEnabled()) {
-    return error.code() != absl::StatusCode::kUnknown;
-  }
-  intptr_t unused;
-  if (grpc_error_get_int(error, grpc_core::StatusIntProperty::kRpcStatus,
-                         &unused)) {
-    return true;
-  }
-  std::vector<absl::Status> children = grpc_core::StatusGetChildren(error);
-  for (const absl::Status& child : children) {
-    if (grpc_error_has_clear_grpc_status(child)) {
-      return true;
-    }
-  }
-  return false;
+  return error.code() != absl::StatusCode::kUnknown;
 }

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

@@ -29,6 +29,7 @@
 #include <utility>
 
 #include "src/core/lib/event_engine/extensions/chaotic_good_extension.h"
+#include "src/core/lib/event_engine/extensions/receive_coalescing_extension.h"
 #include "src/core/lib/event_engine/query_extensions.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/promise/activity.h"
@@ -221,14 +222,13 @@ class PromiseEndpoint {
                });
   }
 
-  // Enables RPC receive coalescing and alignment of memory holding received
-  // RPCs.
-  void EnforceRxMemoryAlignmentAndCoalescing() {
-    auto* chaotic_good_ext = grpc_event_engine::experimental::QueryExtension<
-        grpc_event_engine::experimental::ChaoticGoodExtension>(endpoint_.get());
-    if (chaotic_good_ext != nullptr) {
-      chaotic_good_ext->EnforceRxMemoryAlignment();
-      chaotic_good_ext->EnableRpcReceiveCoalescing();
+  // Enables RPC receive coalescing and memory alignment for received RPCs.
+  void EnableRpcReceiveCoalescing() {
+    auto* ext = grpc_event_engine::experimental::QueryExtension<
+        grpc_event_engine::experimental::ReceiveCoalescingExtension>(
+        endpoint_.get());
+    if (ext != nullptr) {
+      ext->EnableRpcReceiveCoalescing();
     }
   }