grpc 1.63.0 → 1.65.2

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

@@ -15,19 +15,23 @@
 #ifndef GRPC_SRC_CORE_LIB_TRANSPORT_CALL_SPINE_H
 #define GRPC_SRC_CORE_LIB_TRANSPORT_CALL_SPINE_H
 
-#include <grpc/support/port_platform.h>
+#include "absl/log/check.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
+#include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/promise/detail/status.h"
-#include "src/core/lib/promise/for_each.h"
 #include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/latch.h"
 #include "src/core/lib/promise/party.h"
 #include "src/core/lib/promise/pipe.h"
 #include "src/core/lib/promise/prioritized_race.h"
+#include "src/core/lib/promise/promise.h"
 #include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/promise/try_seq.h"
+#include "src/core/lib/transport/call_arena_allocator.h"
+#include "src/core/lib/transport/call_filters.h"
 #include "src/core/lib/transport/message.h"
 #include "src/core/lib/transport/metadata.h"
 
@@ -36,19 +40,23 @@ namespace grpc_core {
 // The common middle part of a call - a reference is held by each of
 // CallInitiator and CallHandler - which provide interfaces that are appropriate
 // for each side of a call.
-// The spine will ultimately host the pipes, filters, and context for one part
-// of a call: ie top-half client channel, sub channel call, server call.
-// TODO(ctiller): eventually drop this when we don't need to reference into
-// legacy promise calls anymore
-class CallSpineInterface {
+// Hosts context, call filters, and the arena.
+class CallSpine final : public Party {
  public:
-  virtual ~CallSpineInterface() = default;
-  virtual Pipe<ClientMetadataHandle>& client_initial_metadata() = 0;
-  virtual Pipe<ServerMetadataHandle>& server_initial_metadata() = 0;
-  virtual Pipe<MessageHandle>& client_to_server_messages() = 0;
-  virtual Pipe<MessageHandle>& server_to_client_messages() = 0;
-  virtual Pipe<ServerMetadataHandle>& server_trailing_metadata() = 0;
-  virtual Latch<ServerMetadataHandle>& cancel_latch() = 0;
+  static RefCountedPtr<CallSpine> Create(
+      ClientMetadataHandle client_initial_metadata,
+      grpc_event_engine::experimental::EventEngine* event_engine,
+      RefCountedPtr<Arena> arena) {
+    Arena* arena_ptr = arena.get();
+    return RefCountedPtr<CallSpine>(arena_ptr->New<CallSpine>(
+        std::move(client_initial_metadata), event_engine, std::move(arena)));
+  }
+
+  ~CallSpine() override {}
+
+  CallFilters& call_filters() { return call_filters_; }
+  Arena* arena() { return arena_.get(); }
+
   // Add a callback to be called when server trailing metadata is received.
   void OnDone(absl::AnyInvocable<void()> fn) {
     if (on_done_ == nullptr) {
@@ -63,37 +71,62 @@ class CallSpineInterface {
   void CallOnDone() {
     if (on_done_ != nullptr) std::exchange(on_done_, nullptr)();
   }
-  virtual Party& party() = 0;
-  virtual Arena* arena() = 0;
-  virtual void IncrementRefCount() = 0;
-  virtual void Unref() = 0;
-
-  // Cancel the call with the given metadata.
-  // Regarding the `MUST_USE_RESULT absl::nullopt_t`:
-  // Most cancellation calls right now happen in pipe interceptors;
-  // there `nullopt` indicates terminate processing of this pipe and close with
-  // error.
-  // It's convenient then to have the Cancel operation (setting the latch to
-  // terminate the call) be the last thing that occurs in a pipe interceptor,
-  // and this construction supports that (and has helped the author not write
-  // some bugs).
-  GRPC_MUST_USE_RESULT absl::nullopt_t Cancel(ServerMetadataHandle metadata) {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == &party());
-    auto& c = cancel_latch();
-    if (c.is_set()) return absl::nullopt;
-    c.Set(std::move(metadata));
-    CallOnDone();
-    client_initial_metadata().sender.CloseWithError();
-    server_initial_metadata().sender.CloseWithError();
-    client_to_server_messages().sender.CloseWithError();
-    server_to_client_messages().sender.CloseWithError();
-    server_trailing_metadata().sender.CloseWithError();
-    return absl::nullopt;
-  }
-
-  auto WaitForCancel() {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == &party());
-    return cancel_latch().Wait();
+
+  auto PullServerInitialMetadata() {
+    return call_filters().PullServerInitialMetadata();
+  }
+
+  auto PullServerTrailingMetadata() {
+    return call_filters().PullServerTrailingMetadata();
+  }
+
+  auto PushClientToServerMessage(MessageHandle message) {
+    return call_filters().PushClientToServerMessage(std::move(message));
+  }
+
+  auto PullClientToServerMessage() {
+    return call_filters().PullClientToServerMessage();
+  }
+
+  auto PushServerToClientMessage(MessageHandle message) {
+    return call_filters().PushServerToClientMessage(std::move(message));
+  }
+
+  auto PullServerToClientMessage() {
+    return call_filters().PullServerToClientMessage();
+  }
+
+  void PushServerTrailingMetadata(ServerMetadataHandle md) {
+    call_filters().PushServerTrailingMetadata(std::move(md));
+  }
+
+  void FinishSends() { call_filters().FinishClientToServerSends(); }
+
+  auto PullClientInitialMetadata() {
+    return call_filters().PullClientInitialMetadata();
+  }
+
+  auto PushServerInitialMetadata(absl::optional<ServerMetadataHandle> md) {
+    bool has_md = md.has_value();
+    return If(
+        has_md,
+        [this, md = std::move(md)]() mutable {
+          return call_filters().PushServerInitialMetadata(std::move(*md));
+        },
+        [this]() {
+          call_filters().NoServerInitialMetadata();
+          return Immediate<StatusFlag>(Success{});
+        });
+  }
+
+  auto WasCancelled() { return call_filters().WasCancelled(); }
+
+  ClientMetadata& UnprocessedClientInitialMetadata() {
+    return *call_filters().unprocessed_client_initial_metadata();
+  }
+
+  grpc_event_engine::experimental::EventEngine* event_engine() const override {
+    return event_engine_;
   }
 
   // Wrap a promise so that if it returns failure it automatically cancels
@@ -101,12 +134,12 @@ class CallSpineInterface {
   // The resulting (returned) promise will resolve to Empty.
   template <typename Promise>
   auto CancelIfFails(Promise promise) {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == &party());
+    DCHECK(GetContext<Activity>() == this);
     using P = promise_detail::PromiseLike<Promise>;
     using ResultType = typename P::Result;
     return Map(std::move(promise), [this](ResultType r) {
       if (!IsStatusOk(r)) {
-        std::ignore = Cancel(StatusCast<ServerMetadataHandle>(r));
+        PushServerTrailingMetadata(StatusCast<ServerMetadataHandle>(r));
       }
       return r;
     });
@@ -116,13 +149,14 @@ class CallSpineInterface {
   // that detail.
   template <typename PromiseFactory>
   void SpawnInfallible(absl::string_view name, PromiseFactory promise_factory) {
-    party().Spawn(name, std::move(promise_factory), [](Empty) {});
+    Spawn(name, std::move(promise_factory), [](Empty) {});
   }
 
   // Spawn a promise that returns some status-like type; if the status
   // represents failure automatically cancel the rest of the call.
   template <typename PromiseFactory>
-  void SpawnGuarded(absl::string_view name, PromiseFactory promise_factory) {
+  void SpawnGuarded(absl::string_view name, PromiseFactory promise_factory,
+                    DebugLocation whence = {}) {
     using FactoryType =
         promise_detail::OncePromiseFactory<void, PromiseFactory>;
     using PromiseType = typename FactoryType::Promise;
@@ -131,61 +165,55 @@ class CallSpineInterface {
         std::is_same<bool,
                      decltype(IsStatusOk(std::declval<ResultType>()))>::value,
         "SpawnGuarded promise must return a status-like object");
-    party().Spawn(name, std::move(promise_factory), [this](ResultType r) {
+    Spawn(name, std::move(promise_factory), [this, whence](ResultType r) {
       if (!IsStatusOk(r)) {
-        if (grpc_trace_promise_primitives.enabled()) {
-          gpr_log(GPR_DEBUG, "SpawnGuarded sees failure: %s",
-                  r.ToString().c_str());
-        }
-        std::ignore = Cancel(StatusCast<ServerMetadataHandle>(std::move(r)));
+        GRPC_TRACE_LOG(promise_primitives, INFO)
+            << "SpawnGuarded sees failure: " << r
+            << " (source: " << whence.file() << ":" << whence.line() << ")";
+        auto status = StatusCast<ServerMetadataHandle>(std::move(r));
+        status->Set(GrpcCallWasCancelled(), true);
+        PushServerTrailingMetadata(std::move(status));
       }
     });
   }
 
- private:
-  absl::AnyInvocable<void()> on_done_{nullptr};
-};
-
-class CallSpine final : public CallSpineInterface, public Party {
- public:
-  static RefCountedPtr<CallSpine> Create(
-      grpc_event_engine::experimental::EventEngine* event_engine,
-      Arena* arena) {
-    return RefCountedPtr<CallSpine>(arena->New<CallSpine>(event_engine, arena));
+  // Wrap a promise so that if the call completes that promise is cancelled.
+  template <typename Promise>
+  auto UntilCallCompletes(Promise promise) {
+    using Result = PromiseResult<Promise>;
+    return PrioritizedRace(std::move(promise), Map(WasCancelled(), [](bool) {
+                             return FailureStatusCast<Result>(Failure{});
+                           }));
   }
 
-  Pipe<ClientMetadataHandle>& client_initial_metadata() override {
-    return client_initial_metadata_;
-  }
-  Pipe<ServerMetadataHandle>& server_initial_metadata() override {
-    return server_initial_metadata_;
-  }
-  Pipe<MessageHandle>& client_to_server_messages() override {
-    return client_to_server_messages_;
-  }
-  Pipe<MessageHandle>& server_to_client_messages() override {
-    return server_to_client_messages_;
-  }
-  Pipe<ServerMetadataHandle>& server_trailing_metadata() override {
-    return server_trailing_metadata_;
+  template <typename PromiseFactory>
+  void SpawnGuardedUntilCallCompletes(absl::string_view name,
+                                      PromiseFactory promise_factory) {
+    SpawnGuarded(name, [this, promise_factory]() mutable {
+      return UntilCallCompletes(promise_factory());
+    });
   }
-  Latch<ServerMetadataHandle>& cancel_latch() override { return cancel_latch_; }
-  Party& party() override { return *this; }
-  Arena* arena() override { return arena_; }
-  void IncrementRefCount() override { Party::IncrementRefCount(); }
-  void Unref() override { Party::Unref(); }
 
  private:
   friend class Arena;
-  CallSpine(grpc_event_engine::experimental::EventEngine* event_engine,
-            Arena* arena)
-      : Party(1), arena_(arena), event_engine_(event_engine) {}
+  CallSpine(ClientMetadataHandle client_initial_metadata,
+            grpc_event_engine::experimental::EventEngine* event_engine,
+            RefCountedPtr<Arena> arena)
+      : Party(1),
+        arena_(std::move(arena)),
+        call_filters_(std::move(client_initial_metadata)),
+        event_engine_(event_engine) {}
 
   class ScopedContext : public ScopedActivity,
-                        public promise_detail::Context<Arena> {
+                        public promise_detail::Context<Arena>,
+                        public promise_detail::Context<
+                            grpc_event_engine::experimental::EventEngine> {
    public:
     explicit ScopedContext(CallSpine* spine)
-        : ScopedActivity(&spine->party()), Context<Arena>(spine->arena()) {}
+        : ScopedActivity(spine),
+          Context<Arena>(spine->arena_.get()),
+          Context<grpc_event_engine::experimental::EventEngine>(
+              spine->event_engine()) {}
   };
 
   bool RunParty() override {
@@ -194,109 +222,55 @@ class CallSpine final : public CallSpineInterface, public Party {
   }
 
   void PartyOver() override {
-    Arena* a = arena();
+    auto arena = arena_;
     {
       ScopedContext context(this);
       CancelRemainingParticipants();
-      a->DestroyManagedNewObjects();
+      arena->DestroyManagedNewObjects();
     }
     this->~CallSpine();
-    a->Destroy();
   }
 
-  grpc_event_engine::experimental::EventEngine* event_engine() const override {
-    return event_engine_;
-  }
-
-  Arena* arena_;
-  // Initial metadata from client to server
-  Pipe<ClientMetadataHandle> client_initial_metadata_{arena()};
-  // Initial metadata from server to client
-  Pipe<ServerMetadataHandle> server_initial_metadata_{arena()};
-  // Messages travelling from the application to the transport.
-  Pipe<MessageHandle> client_to_server_messages_{arena()};
-  // Messages travelling from the transport to the application.
-  Pipe<MessageHandle> server_to_client_messages_{arena()};
-  // Trailing metadata from server to client
-  Pipe<ServerMetadataHandle> server_trailing_metadata_{arena()};
-  // Latch that can be set to terminate the call
-  Latch<ServerMetadataHandle> cancel_latch_;
+  const RefCountedPtr<Arena> arena_;
+  // Call filters/pipes part of the spine
+  CallFilters call_filters_;
   // Event engine associated with this call
   grpc_event_engine::experimental::EventEngine* const event_engine_;
+  absl::AnyInvocable<void()> on_done_{nullptr};
 };
 
 class CallInitiator {
  public:
-  explicit CallInitiator(RefCountedPtr<CallSpineInterface> spine)
+  CallInitiator() = default;
+  explicit CallInitiator(RefCountedPtr<CallSpine> spine)
       : spine_(std::move(spine)) {}
 
-  auto PushClientInitialMetadata(ClientMetadataHandle md) {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
-    return Map(spine_->client_initial_metadata().sender.Push(std::move(md)),
-               [](bool ok) { return StatusFlag(ok); });
+  template <typename Promise>
+  auto CancelIfFails(Promise promise) {
+    return spine_->CancelIfFails(std::move(promise));
   }
 
   auto PullServerInitialMetadata() {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
-    return Map(spine_->server_initial_metadata().receiver.Next(),
-               [](NextResult<ServerMetadataHandle> md)
-                   -> ValueOrFailure<absl::optional<ServerMetadataHandle>> {
-                 if (!md.has_value()) {
-                   if (md.cancelled()) return Failure{};
-                   return absl::optional<ServerMetadataHandle>();
-                 }
-                 return absl::optional<ServerMetadataHandle>(std::move(*md));
-               });
-  }
-
-  auto PullServerTrailingMetadata() {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
-    return PrioritizedRace(
-        Seq(spine_->server_trailing_metadata().receiver.Next(),
-            [spine = spine_](NextResult<ServerMetadataHandle> md) mutable {
-              return [md = std::move(md),
-                      spine]() mutable -> Poll<ServerMetadataHandle> {
-                // If the pipe was closed at cancellation time, we'll see no
-                // value here. Return pending and allow the cancellation to win
-                // the race.
-                if (!md.has_value()) return Pending{};
-                spine->server_trailing_metadata().sender.Close();
-                return std::move(*md);
-              };
-            }),
-        Map(spine_->WaitForCancel(),
-            [spine = spine_](ServerMetadataHandle md) -> ServerMetadataHandle {
-              spine->server_trailing_metadata().sender.CloseWithError();
-              return md;
-            }));
-  }
-
-  auto PullMessage() {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
-    return spine_->server_to_client_messages().receiver.Next();
+    return spine_->PullServerInitialMetadata();
   }
 
   auto PushMessage(MessageHandle message) {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
-    return Map(
-        spine_->client_to_server_messages().sender.Push(std::move(message)),
-        [](bool r) { return StatusFlag(r); });
+    return spine_->PushClientToServerMessage(std::move(message));
   }
 
-  void FinishSends() {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
-    spine_->client_to_server_messages().sender.Close();
-  }
+  void FinishSends() { spine_->FinishSends(); }
 
-  template <typename Promise>
-  auto CancelIfFails(Promise promise) {
-    return spine_->CancelIfFails(std::move(promise));
+  auto PullMessage() { return spine_->PullServerToClientMessage(); }
+
+  auto PullServerTrailingMetadata() {
+    return spine_->PullServerTrailingMetadata();
   }
 
-  void Cancel() {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
-    std::ignore =
-        spine_->Cancel(ServerMetadataFromStatus(absl::CancelledError()));
+  void Cancel(absl::Status error = absl::CancelledError()) {
+    CHECK(!error.ok());
+    auto status = ServerMetadataFromStatus(error);
+    status->Set(GrpcCallWasCancelled(), true);
+    spine_->PushServerTrailingMetadata(std::move(status));
   }
 
   void OnDone(absl::AnyInvocable<void()> fn) { spine_->OnDone(std::move(fn)); }
@@ -306,6 +280,12 @@ class CallInitiator {
     spine_->SpawnGuarded(name, std::move(promise_factory));
   }
 
+  template <typename PromiseFactory>
+  void SpawnGuardedUntilCallCompletes(absl::string_view name,
+                                      PromiseFactory promise_factory) {
+    spine_->SpawnGuardedUntilCallCompletes(name, std::move(promise_factory));
+  }
+
   template <typename PromiseFactory>
   void SpawnInfallible(absl::string_view name, PromiseFactory promise_factory) {
     spine_->SpawnInfallible(name, std::move(promise_factory));
@@ -313,70 +293,90 @@ class CallInitiator {
 
   template <typename PromiseFactory>
   auto SpawnWaitable(absl::string_view name, PromiseFactory promise_factory) {
-    return spine_->party().SpawnWaitable(name, std::move(promise_factory));
+    return spine_->SpawnWaitable(name, std::move(promise_factory));
   }
 
   Arena* arena() { return spine_->arena(); }
 
+  grpc_event_engine::experimental::EventEngine* event_engine() const {
+    return spine_->event_engine();
+  }
+
  private:
-  RefCountedPtr<CallSpineInterface> spine_;
+  RefCountedPtr<CallSpine> spine_;
 };
 
 class CallHandler {
  public:
-  explicit CallHandler(RefCountedPtr<CallSpineInterface> spine)
+  explicit CallHandler(RefCountedPtr<CallSpine> spine)
       : spine_(std::move(spine)) {}
 
   auto PullClientInitialMetadata() {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
-    return Map(spine_->client_initial_metadata().receiver.Next(),
-               [](NextResult<ClientMetadataHandle> md)
-                   -> ValueOrFailure<ClientMetadataHandle> {
-                 if (!md.has_value()) return Failure{};
-                 return std::move(*md);
-               });
+    return spine_->PullClientInitialMetadata();
   }
 
   auto PushServerInitialMetadata(absl::optional<ServerMetadataHandle> md) {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
-    return If(
-        md.has_value(),
-        [&md, this]() {
-          return Map(
-              spine_->server_initial_metadata().sender.Push(std::move(*md)),
-              [](bool ok) { return StatusFlag(ok); });
-        },
-        [this]() {
-          spine_->server_initial_metadata().sender.Close();
-          return []() -> StatusFlag { return Success{}; };
-        });
+    return spine_->PushServerInitialMetadata(std::move(md));
   }
 
-  auto PushServerTrailingMetadata(ServerMetadataHandle md) {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
-    spine_->server_initial_metadata().sender.Close();
-    spine_->server_to_client_messages().sender.Close();
-    spine_->client_to_server_messages().receiver.CloseWithError();
-    spine_->CallOnDone();
-    return Map(spine_->server_trailing_metadata().sender.Push(std::move(md)),
-               [](bool ok) { return StatusFlag(ok); });
+  void PushServerTrailingMetadata(ServerMetadataHandle status) {
+    spine_->PushServerTrailingMetadata(std::move(status));
   }
 
-  auto PullMessage() {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
-    return spine_->client_to_server_messages().receiver.Next();
+  void OnDone(absl::AnyInvocable<void()> fn) { spine_->OnDone(std::move(fn)); }
+
+  template <typename Promise>
+  auto CancelIfFails(Promise promise) {
+    return spine_->CancelIfFails(std::move(promise));
   }
 
   auto PushMessage(MessageHandle message) {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
-    return Map(
-        spine_->server_to_client_messages().sender.Push(std::move(message)),
-        [](bool ok) { return StatusFlag(ok); });
+    return spine_->PushServerToClientMessage(std::move(message));
+  }
+
+  auto PullMessage() { return spine_->PullClientToServerMessage(); }
+
+  auto WasCancelled() { return spine_->WasCancelled(); }
+
+  template <typename PromiseFactory>
+  void SpawnGuarded(absl::string_view name, PromiseFactory promise_factory,
+                    DebugLocation whence = {}) {
+    spine_->SpawnGuarded(name, std::move(promise_factory), whence);
+  }
+
+  template <typename PromiseFactory>
+  void SpawnGuardedUntilCallCompletes(absl::string_view name,
+                                      PromiseFactory promise_factory) {
+    spine_->SpawnGuardedUntilCallCompletes(name, std::move(promise_factory));
+  }
+
+  template <typename PromiseFactory>
+  void SpawnInfallible(absl::string_view name, PromiseFactory promise_factory) {
+    spine_->SpawnInfallible(name, std::move(promise_factory));
+  }
+
+  template <typename PromiseFactory>
+  auto SpawnWaitable(absl::string_view name, PromiseFactory promise_factory) {
+    return spine_->SpawnWaitable(name, std::move(promise_factory));
   }
 
-  void Cancel(ServerMetadataHandle status) {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
-    std::ignore = spine_->Cancel(std::move(status));
+  Arena* arena() { return spine_->arena(); }
+
+  grpc_event_engine::experimental::EventEngine* event_engine() const {
+    return spine_->event_engine();
+  }
+
+ private:
+  RefCountedPtr<CallSpine> spine_;
+};
+
+class UnstartedCallHandler {
+ public:
+  explicit UnstartedCallHandler(RefCountedPtr<CallSpine> spine)
+      : spine_(std::move(spine)) {}
+
+  void PushServerTrailingMetadata(ServerMetadataHandle status) {
+    spine_->PushServerTrailingMetadata(std::move(status));
   }
 
   void OnDone(absl::AnyInvocable<void()> fn) { spine_->OnDone(std::move(fn)); }
@@ -387,8 +387,15 @@ class CallHandler {
   }
 
   template <typename PromiseFactory>
-  void SpawnGuarded(absl::string_view name, PromiseFactory promise_factory) {
-    spine_->SpawnGuarded(name, std::move(promise_factory));
+  void SpawnGuarded(absl::string_view name, PromiseFactory promise_factory,
+                    DebugLocation whence = {}) {
+    spine_->SpawnGuarded(name, std::move(promise_factory), whence);
+  }
+
+  template <typename PromiseFactory>
+  void SpawnGuardedUntilCallCompletes(absl::string_view name,
+                                      PromiseFactory promise_factory) {
+    spine_->SpawnGuardedUntilCallCompletes(name, std::move(promise_factory));
   }
 
   template <typename PromiseFactory>
@@ -398,22 +405,39 @@ class CallHandler {
 
   template <typename PromiseFactory>
   auto SpawnWaitable(absl::string_view name, PromiseFactory promise_factory) {
-    return spine_->party().SpawnWaitable(name, std::move(promise_factory));
+    return spine_->SpawnWaitable(name, std::move(promise_factory));
+  }
+
+  ClientMetadata& UnprocessedClientInitialMetadata() {
+    return spine_->UnprocessedClientInitialMetadata();
+  }
+
+  // Helper for the very common situation in tests where we want to start a call
+  // with an empty filter stack.
+  CallHandler StartWithEmptyFilterStack() {
+    return StartCall(CallFilters::StackBuilder().Build());
+  }
+
+  CallHandler StartCall(RefCountedPtr<CallFilters::Stack> call_filters) {
+    spine_->call_filters().SetStack(std::move(call_filters));
+    return CallHandler(std::move(spine_));
   }
 
   Arena* arena() { return spine_->arena(); }
 
  private:
-  RefCountedPtr<CallSpineInterface> spine_;
+  RefCountedPtr<CallSpine> spine_;
 };
 
 struct CallInitiatorAndHandler {
   CallInitiator initiator;
-  CallHandler handler;
+  UnstartedCallHandler handler;
 };
 
-CallInitiatorAndHandler MakeCall(
-    grpc_event_engine::experimental::EventEngine* event_engine, Arena* arena);
+CallInitiatorAndHandler MakeCallPair(
+    ClientMetadataHandle client_initial_metadata,
+    grpc_event_engine::experimental::EventEngine* event_engine,
+    RefCountedPtr<Arena> arena);
 
 template <typename CallHalf>
 auto OutgoingMessages(CallHalf h) {
@@ -426,8 +450,7 @@ auto OutgoingMessages(CallHalf h) {
 
 // Forward a call from `call_handler` to `call_initiator` (with initial metadata
 // `client_initial_metadata`)
-void ForwardCall(CallHandler call_handler, CallInitiator call_initiator,
-                 ClientMetadataHandle client_initial_metadata);
+void ForwardCall(CallHandler call_handler, CallInitiator call_initiator);
 
 }  // namespace grpc_core