grpc 1.63.0 → 1.64.0.pre1

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

@@ -12,10 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/transport/call_filters.h"
 
+#include "absl/log/check.h"
+
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/transport/metadata.h"
 
@@ -43,7 +45,7 @@ Poll<ResultOr<T>> OperationExecutor<T>::Start(
   if (layout->promise_size == 0) {
     // No call state ==> instantaneously ready
     auto r = InitStep(std::move(input), call_data);
-    GPR_ASSERT(r.ready());
+    CHECK(r.ready());
     return r;
   }
   promise_data_ =
@@ -53,6 +55,7 @@ Poll<ResultOr<T>> OperationExecutor<T>::Start(
 
 template <typename T>
 Poll<ResultOr<T>> OperationExecutor<T>::InitStep(T input, void* call_data) {
+  CHECK(input != nullptr);
   while (true) {
     if (ops_ == end_ops_) {
       return ResultOr<T>{std::move(input), nullptr};
@@ -72,7 +75,7 @@ Poll<ResultOr<T>> OperationExecutor<T>::InitStep(T input, void* call_data) {
 
 template <typename T>
 Poll<ResultOr<T>> OperationExecutor<T>::Step(void* call_data) {
-  GPR_DEBUG_ASSERT(promise_data_ != nullptr);
+  DCHECK_NE(promise_data_, nullptr);
   auto p = ContinueStep(call_data);
   if (p.ready()) {
     gpr_free_aligned(promise_data_);
@@ -108,7 +111,7 @@ Poll<T> InfallibleOperationExecutor<T>::Start(
   if (layout->promise_size == 0) {
     // No call state ==> instantaneously ready
     auto r = InitStep(std::move(input), call_data);
-    GPR_ASSERT(r.ready());
+    CHECK(r.ready());
     return r;
   }
   promise_data_ =
@@ -136,7 +139,7 @@ Poll<T> InfallibleOperationExecutor<T>::InitStep(T input, void* call_data) {
 
 template <typename T>
 Poll<T> InfallibleOperationExecutor<T>::Step(void* call_data) {
-  GPR_DEBUG_ASSERT(promise_data_ != nullptr);
+  DCHECK_NE(promise_data_, nullptr);
   auto p = ContinueStep(call_data);
   if (p.ready()) {
     gpr_free_aligned(promise_data_);
@@ -181,7 +184,7 @@ CallFilters::~CallFilters() {
 }
 
 void CallFilters::SetStack(RefCountedPtr<Stack> stack) {
-  GPR_ASSERT(call_data_ == nullptr);
+  CHECK_EQ(call_data_, nullptr);
   stack_ = std::move(stack);
   call_data_ = gpr_malloc_aligned(stack_->data_.call_data_size,
                                   stack_->data_.call_data_alignment);
@@ -216,18 +219,19 @@ void CallFilters::CancelDueToFailedPipeOperation(SourceLocation but_where) {
 }
 
 void CallFilters::PushServerTrailingMetadata(ServerMetadataHandle md) {
+  CHECK(md != nullptr);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_promise_primitives)) {
-    gpr_log(GPR_DEBUG, "%s Push server trailing metadata: %s into %s",
-            GetContext<Activity>()->DebugTag().c_str(),
+    gpr_log(GPR_INFO, "%s PushServerTrailingMetadata[%p]: %s into %s",
+            GetContext<Activity>()->DebugTag().c_str(), this,
             md->DebugString().c_str(), DebugString().c_str());
   }
-  GPR_ASSERT(md != nullptr);
+  CHECK(md != nullptr);
   if (server_trailing_metadata_ != nullptr) return;
   server_trailing_metadata_ = std::move(md);
   client_initial_metadata_state_.CloseWithError();
   server_initial_metadata_state_.CloseSending();
   client_to_server_message_state_.CloseWithError();
-  server_to_client_message_state_.CloseWithError();
+  server_to_client_message_state_.CloseSending();
   server_trailing_metadata_waiter_.Wake();
 }
 
@@ -284,7 +288,7 @@ RefCountedPtr<CallFilters::Stack> CallFilters::StackBuilder::Build() {
 // CallFilters::PipeState
 
 void filters_detail::PipeState::Start() {
-  GPR_DEBUG_ASSERT(!started_);
+  DCHECK(!started_);
   started_ = true;
   wait_recv_.Wake();
 }
@@ -358,6 +362,10 @@ void filters_detail::PipeState::DropPush() {
     case ValueState::kReady:
     case ValueState::kProcessing:
     case ValueState::kWaiting:
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_promise_primitives)) {
+        gpr_log(GPR_INFO, "%p drop push in state %s", this,
+                DebugString().c_str());
+      }
       state_ = ValueState::kError;
       wait_recv_.Wake();
       break;
@@ -374,6 +382,10 @@ void filters_detail::PipeState::DropPull() {
     case ValueState::kReady:
     case ValueState::kProcessing:
     case ValueState::kWaiting:
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_promise_primitives)) {
+        gpr_log(GPR_INFO, "%p drop pull in state %s", this,
+                DebugString().c_str());
+      }
       state_ = ValueState::kError;
       wait_send_.Wake();
       break;
@@ -386,9 +398,12 @@ void filters_detail::PipeState::DropPull() {
 
 Poll<StatusFlag> filters_detail::PipeState::PollPush() {
   switch (state_) {
-    case ValueState::kIdle:
     // Read completed and new read started => we see waiting here
     case ValueState::kWaiting:
+      state_ = ValueState::kReady;
+      wait_recv_.Wake();
+      return wait_send_.pending();
+    case ValueState::kIdle:
     case ValueState::kClosed:
       return Success{};
     case ValueState::kQueued:

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

@@ -15,12 +15,14 @@
 #ifndef GRPC_SRC_CORE_LIB_TRANSPORT_CALL_FILTERS_H
 #define GRPC_SRC_CORE_LIB_TRANSPORT_CALL_FILTERS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <cstdint>
 #include <memory>
 #include <type_traits>
 
+#include "absl/log/check.h"
+
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/promise/latch.h"
@@ -155,6 +157,10 @@ struct CallConstructor<FilterType,
 // Only one pointer can be set.
 template <typename T>
 struct ResultOr {
+  ResultOr(T ok, ServerMetadataHandle error)
+      : ok(std::move(ok)), error(std::move(error)) {
+    CHECK((this->ok == nullptr) ^ (this->error == nullptr));
+  }
   T ok;
   ServerMetadataHandle error;
 };
@@ -922,7 +928,7 @@ struct StackData {
     filter_destructor.push_back(FilterDestructor{
         call_offset,
         [](void* call_data) {
-          static_cast<typename FilterType::Call*>(call_data)->~Call();
+          Destruct(static_cast<typename FilterType::Call*>(call_data));
         },
     });
   }
@@ -986,13 +992,13 @@ struct StackData {
 
   template <typename FilterType>
   void AddFinalizer(FilterType*, size_t, const NoInterceptor* p) {
-    GPR_DEBUG_ASSERT(p == &FilterType::Call::OnFinalize);
+    DCHECK(p == &FilterType::Call::OnFinalize);
   }
 
   template <typename FilterType>
   void AddFinalizer(FilterType* channel_data, size_t call_offset,
                     void (FilterType::Call::*p)(const grpc_call_final_info*)) {
-    GPR_DEBUG_ASSERT(p == &FilterType::Call::OnFinalize);
+    DCHECK(p == &FilterType::Call::OnFinalize);
     finalizers.push_back(Finalizer{
         channel_data,
         call_offset,
@@ -1007,7 +1013,7 @@ struct StackData {
   void AddFinalizer(FilterType* channel_data, size_t call_offset,
                     void (FilterType::Call::*p)(const grpc_call_final_info*,
                                                 FilterType*)) {
-    GPR_DEBUG_ASSERT(p == &FilterType::Call::OnFinalize);
+    DCHECK(p == &FilterType::Call::OnFinalize);
     finalizers.push_back(Finalizer{
         channel_data,
         call_offset,
@@ -1037,11 +1043,11 @@ class OperationExecutor {
   OperationExecutor(OperationExecutor&& other) noexcept
       : ops_(other.ops_), end_ops_(other.end_ops_) {
     // Movable iff we're not running.
-    GPR_DEBUG_ASSERT(other.promise_data_ == nullptr);
+    DCHECK_EQ(other.promise_data_, nullptr);
   }
   OperationExecutor& operator=(OperationExecutor&& other) noexcept {
-    GPR_DEBUG_ASSERT(other.promise_data_ == nullptr);
-    GPR_DEBUG_ASSERT(promise_data_ == nullptr);
+    DCHECK_EQ(other.promise_data_, nullptr);
+    DCHECK_EQ(promise_data_, nullptr);
     ops_ = other.ops_;
     end_ops_ = other.end_ops_;
     return *this;
@@ -1090,12 +1096,12 @@ class InfallibleOperationExecutor {
   InfallibleOperationExecutor(InfallibleOperationExecutor&& other) noexcept
       : ops_(other.ops_), end_ops_(other.end_ops_) {
     // Movable iff we're not running.
-    GPR_DEBUG_ASSERT(other.promise_data_ == nullptr);
+    DCHECK_EQ(other.promise_data_, nullptr);
   }
   InfallibleOperationExecutor& operator=(
       InfallibleOperationExecutor&& other) noexcept {
-    GPR_DEBUG_ASSERT(other.promise_data_ == nullptr);
-    GPR_DEBUG_ASSERT(promise_data_ == nullptr);
+    DCHECK_EQ(other.promise_data_, nullptr);
+    DCHECK_EQ(promise_data_, nullptr);
     ops_ = other.ops_;
     end_ops_ = other.end_ops_;
     return *this;
@@ -1310,44 +1316,6 @@ class CallFilters {
     filters_detail::StackData data_;
   };
 
-  class NextMessage {
-   public:
-    NextMessage() : has_value_(false), cancelled_(false) {}
-    explicit NextMessage(MessageHandle value)
-        : has_value_(true), value_(std::move(value)) {}
-    explicit NextMessage(bool cancelled)
-        : has_value_(false), cancelled_(cancelled) {}
-    NextMessage(const NextMessage&) = delete;
-    NextMessage& operator=(const NextMessage&) = delete;
-    NextMessage(NextMessage&& other) noexcept = default;
-    NextMessage& operator=(NextMessage&& other) = default;
-
-    using value_type = MessageHandle;
-
-    void reset() {
-      has_value_ = false;
-      cancelled_ = false;
-      value_.reset();
-    }
-    bool has_value() const { return has_value_; }
-    const MessageHandle& value() const {
-      GPR_DEBUG_ASSERT(has_value_);
-      return value_;
-    }
-    MessageHandle& value() {
-      GPR_DEBUG_ASSERT(has_value_);
-      return value_;
-    }
-    const MessageHandle& operator*() const { return value(); }
-    MessageHandle& operator*() { return value(); }
-    bool cancelled() const { return !has_value_ && cancelled_; }
-
-   private:
-    bool has_value_;
-    bool cancelled_;
-    MessageHandle value_;
-  };
-
   explicit CallFilters(ClientMetadataHandle client_initial_metadata);
   ~CallFilters();
 
@@ -1422,12 +1390,21 @@ class CallFilters {
      public:
       Push(CallFilters* filters, T x)
           : filters_(filters), value_(std::move(x)) {
+        CHECK(value_ != nullptr);
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_promise_primitives)) {
+          gpr_log(GPR_INFO, "BeginPush[%p|%p]: %s", &state(), this,
+                  state().DebugString().c_str());
+        }
+        CHECK_EQ(push_slot(), nullptr);
         state().BeginPush();
         push_slot() = this;
       }
       ~Push() {
         if (filters_ != nullptr) {
-          state().DropPush();
+          if (value_ != nullptr) {
+            state().DropPush();
+          }
+          CHECK(push_slot() == this);
           push_slot() = nullptr;
         }
       }
@@ -1438,16 +1415,56 @@ class CallFilters {
           : filters_(std::exchange(other.filters_, nullptr)),
             value_(std::move(other.value_)) {
         if (filters_ != nullptr) {
-          GPR_DEBUG_ASSERT(push_slot() == &other);
+          DCHECK(push_slot() == &other);
           push_slot() = this;
         }
       }
 
       Push& operator=(Push&&) = delete;
 
-      Poll<StatusFlag> operator()() { return state().PollPush(); }
+      Poll<StatusFlag> operator()() {
+        if (value_ == nullptr) {
+          CHECK_EQ(filters_, nullptr);
+          if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_promise_primitives)) {
+            gpr_log(GPR_INFO, "Push[|%p]: already done", this);
+          }
+          return Success{};
+        }
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_promise_primitives)) {
+          gpr_log(GPR_INFO, "Push[%p|%p]: %s", &state(), this,
+                  state().DebugString().c_str());
+        }
+        auto r = state().PollPush();
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_promise_primitives)) {
+          if (r.pending()) {
+            gpr_log(GPR_INFO, "Push[%p|%p]: pending; %s", &state(), this,
+                    state().DebugString().c_str());
+          } else if (r.value().ok()) {
+            gpr_log(GPR_INFO, "Push[%p|%p]: success; %s", &state(), this,
+                    state().DebugString().c_str());
+          } else {
+            gpr_log(GPR_INFO, "Push[%p|%p]: failure; %s", &state(), this,
+                    state().DebugString().c_str());
+          }
+        }
+        if (r.ready()) {
+          push_slot() = nullptr;
+          filters_ = nullptr;
+        }
+        return r;
+      }
 
-      T TakeValue() { return std::move(value_); }
+      T TakeValue() {
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_promise_primitives)) {
+          gpr_log(GPR_INFO, "Push[%p|%p]: take value; %s", &state(), this,
+                  state().DebugString().c_str());
+        }
+        CHECK(value_ != nullptr);
+        CHECK(filters_ != nullptr);
+        push_slot() = nullptr;
+        filters_ = nullptr;
+        return std::move(value_);
+      }
 
       absl::string_view DebugString() const {
         return value_ != nullptr ? " (not pulled)" : "";
@@ -1485,6 +1502,10 @@ class CallFilters {
       PullMaybe& operator=(PullMaybe&&) = delete;
 
       Poll<ValueOrFailure<absl::optional<T>>> operator()() {
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_promise_primitives)) {
+          gpr_log(GPR_INFO, "PullMaybe[%p|%p]: %s executor:%d", &state(), this,
+                  state().DebugString().c_str(), executor_.IsRunning());
+        }
         if (executor_.IsRunning()) {
           auto c = state().PollClosed();
           if (c.ready() && c.value()) {
@@ -1517,7 +1538,7 @@ class CallFilters {
           Poll<filters_detail::ResultOr<T>> p) {
         auto* r = p.value_if_ready();
         if (r == nullptr) return Pending{};
-        GPR_DEBUG_ASSERT(!executor_.IsRunning());
+        DCHECK(!executor_.IsRunning());
         state().AckPull();
         if (r->ok != nullptr) return std::move(r->ok);
         filters_->PushServerTrailingMetadata(std::move(r->error));
@@ -1544,23 +1565,36 @@ class CallFilters {
             executor_(std::move(other.executor_)) {}
       PullMessage& operator=(PullMessage&&) = delete;
 
-      Poll<NextMessage> operator()() {
+      Poll<ValueOrFailure<absl::optional<MessageHandle>>> operator()() {
+        CHECK(filters_ != nullptr);
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_promise_primitives)) {
+          gpr_log(GPR_INFO, "PullMessage[%p|%p]: %s executor:%d", &state(),
+                  this, state().DebugString().c_str(), executor_.IsRunning());
+        }
         if (executor_.IsRunning()) {
           auto c = state().PollClosed();
           if (c.ready() && c.value()) {
             filters_->CancelDueToFailedPipeOperation();
-            return NextMessage(true);
+            return Failure{};
           }
           return FinishOperationExecutor(executor_.Step(filters_->call_data_));
         }
         auto p = state().PollPull();
         auto* r = p.value_if_ready();
-        if (r == nullptr) return Pending{};
+        if (r == nullptr) {
+          if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_promise_primitives)) {
+            gpr_log(GPR_INFO, "PullMessage[%p] pending: %s executor:%d",
+                    &state(), state().DebugString().c_str(),
+                    executor_.IsRunning());
+          }
+          return Pending{};
+        }
         if (!r->ok()) {
           filters_->CancelDueToFailedPipeOperation();
-          return NextMessage(true);
+          return Failure{};
         }
-        if (!**r) return NextMessage(false);
+        if (!**r) return absl::nullopt;
+        CHECK(filters_ != nullptr);
         return FinishOperationExecutor(executor_.Start(
             layout(), push()->TakeValue(), filters_->call_data_));
       }
@@ -1573,15 +1607,19 @@ class CallFilters {
         return &(filters_->stack_->data_.*layout_ptr);
       }
 
-      Poll<NextMessage> FinishOperationExecutor(
-          Poll<filters_detail::ResultOr<T>> p) {
+      Poll<ValueOrFailure<absl::optional<MessageHandle>>>
+      FinishOperationExecutor(Poll<filters_detail::ResultOr<T>> p) {
         auto* r = p.value_if_ready();
         if (r == nullptr) return Pending{};
-        GPR_DEBUG_ASSERT(!executor_.IsRunning());
+        DCHECK(!executor_.IsRunning());
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_promise_primitives)) {
+          gpr_log(GPR_INFO, "PullMessage[%p|%p] executor done: %s", &state(),
+                  this, state().DebugString().c_str());
+        }
         state().AckPull();
-        if (r->ok != nullptr) return NextMessage(std::move(r->ok));
+        if (r->ok != nullptr) return std::move(r->ok);
         filters_->PushServerTrailingMetadata(std::move(r->error));
-        return NextMessage(true);
+        return Failure{};
       }
 
       CallFilters* filters_;
@@ -1622,7 +1660,7 @@ class CallFilters {
         filters_->CancelDueToFailedPipeOperation();
         return Failure{};
       }
-      GPR_ASSERT(filters_->client_initial_metadata_ != nullptr);
+      CHECK(filters_->client_initial_metadata_ != nullptr);
       return FinishOperationExecutor(executor_.Start(
           &filters_->stack_->data_.client_initial_metadata,
           std::move(filters_->client_initial_metadata_), filters_->call_data_));
@@ -1637,7 +1675,7 @@ class CallFilters {
         Poll<filters_detail::ResultOr<ClientMetadataHandle>> p) {
       auto* r = p.value_if_ready();
       if (r == nullptr) return Pending{};
-      GPR_DEBUG_ASSERT(!executor_.IsRunning());
+      DCHECK(!executor_.IsRunning());
       state().AckPull();
       if (r->ok != nullptr) return std::move(r->ok);
       filters_->PushServerTrailingMetadata(std::move(r->error));
@@ -1699,9 +1737,21 @@ class CallFilters {
         return std::move(filters_->server_trailing_metadata_);
       }
       // Otherwise we need to process it through all the filters.
-      return executor_.Start(&filters_->stack_->data_.server_trailing_metadata,
-                             std::move(filters_->server_trailing_metadata_),
-                             filters_->call_data_);
+      auto r = executor_.Start(
+          &filters_->stack_->data_.server_trailing_metadata,
+          std::move(filters_->server_trailing_metadata_), filters_->call_data_);
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_promise_primitives)) {
+        if (r.pending()) {
+          gpr_log(GPR_INFO,
+                  "%s PullServerTrailingMetadata[%p]: Pending(but executing)",
+                  GetContext<Activity>()->DebugTag().c_str(), filters_);
+        } else {
+          gpr_log(GPR_INFO, "%s PullServerTrailingMetadata[%p]: Ready: %s",
+                  GetContext<Activity>()->DebugTag().c_str(), filters_,
+                  r.value()->DebugString().c_str());
+        }
+      }
+      return r;
     }
 
    private:
@@ -1755,7 +1805,7 @@ inline auto CallFilters::PullClientInitialMetadata() {
 }
 
 inline auto CallFilters::PushServerInitialMetadata(ServerMetadataHandle md) {
-  GPR_ASSERT(md != nullptr);
+  CHECK(md != nullptr);
   return [p = ServerInitialMetadataPromises::Push{
               this, std::move(md)}]() mutable { return p(); };
 }
@@ -1765,7 +1815,7 @@ inline auto CallFilters::PullServerInitialMetadata() {
 }
 
 inline auto CallFilters::PushClientToServerMessage(MessageHandle message) {
-  GPR_ASSERT(message != nullptr);
+  CHECK(message != nullptr);
   return [p = ClientToServerMessagePromises::Push{
               this, std::move(message)}]() mutable { return p(); };
 }
@@ -1775,7 +1825,7 @@ inline auto CallFilters::PullClientToServerMessage() {
 }
 
 inline auto CallFilters::PushServerToClientMessage(MessageHandle message) {
-  GPR_ASSERT(message != nullptr);
+  CHECK(message != nullptr);
   return [p = ServerToClientMessagePromises::Push{
               this, std::move(message)}]() mutable { return p(); };
 }

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

@@ -12,12 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/transport/call_final_info.h"
 
 #include <utility>
 
+#include <grpc/support/port_platform.h>
+
 static void move64bits(uint64_t* from, uint64_t* to) {
   *to += *from;
   *from = 0;

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

@@ -15,11 +15,10 @@
 #ifndef GRPC_SRC_CORE_LIB_TRANSPORT_CALL_FINAL_INFO_H
 #define GRPC_SRC_CORE_LIB_TRANSPORT_CALL_FINAL_INFO_H
 
-#include <grpc/support/port_platform.h>
-
 #include <cstdint>
 
 #include <grpc/status.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
 struct grpc_transport_one_way_stats {

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

@@ -12,22 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "src/core/lib/transport/call_spine.h"
+
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/transport/call_spine.h"
+#include "src/core/lib/promise/for_each.h"
+#include "src/core/lib/promise/try_seq.h"
 
 namespace grpc_core {
 
-void ForwardCall(CallHandler call_handler, CallInitiator call_initiator,
-                 ClientMetadataHandle client_initial_metadata) {
-  // Send initial metadata.
-  call_initiator.SpawnGuarded(
-      "send_initial_metadata",
-      [client_initial_metadata = std::move(client_initial_metadata),
-       call_initiator]() mutable {
-        return call_initiator.PushClientInitialMetadata(
-            std::move(client_initial_metadata));
-      });
+void ForwardCall(CallHandler call_handler, CallInitiator call_initiator) {
   // Read messages from handler into initiator.
   call_handler.SpawnGuarded("read_messages", [call_handler,
                                               call_initiator]() mutable {
@@ -88,20 +82,25 @@ void ForwardCall(CallHandler call_handler, CallInitiator call_initiator,
             })),
         call_initiator.PullServerTrailingMetadata(),
         [call_handler](ServerMetadataHandle md) mutable {
-          call_handler.SpawnGuarded(
-              "recv_trailing_metadata",
-              [md = std::move(md), call_handler]() mutable {
-                return call_handler.PushServerTrailingMetadata(std::move(md));
+          call_handler.SpawnInfallible(
+              "recv_trailing", [call_handler, md = std::move(md)]() mutable {
+                call_handler.PushServerTrailingMetadata(std::move(md));
+                return Empty{};
               });
           return Empty{};
         });
   });
 }
 
-CallInitiatorAndHandler MakeCall(
-    grpc_event_engine::experimental::EventEngine* event_engine, Arena* arena) {
-  auto spine = CallSpine::Create(event_engine, arena);
-  return {CallInitiator(spine), CallHandler(spine)};
+CallInitiatorAndHandler MakeCallPair(
+    ClientMetadataHandle client_initial_metadata,
+    grpc_event_engine::experimental::EventEngine* event_engine, Arena* arena,
+    RefCountedPtr<CallArenaAllocator> call_arena_allocator_if_arena_is_owned,
+    grpc_call_context_element* legacy_context) {
+  auto spine = CallSpine::Create(
+      std::move(client_initial_metadata), event_engine, arena,
+      std::move(call_arena_allocator_if_arena_is_owned), legacy_context);
+  return {CallInitiator(spine), UnstartedCallHandler(spine)};
 }
 
 }  // namespace grpc_core