grpc 1.53.0 → 1.58.0

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

@@ -21,21 +21,16 @@
 #include "src/core/lib/channel/connected_channel.h"
 
 #include <inttypes.h>
-#include <string.h>
 
-#include <algorithm>
 #include <functional>
 #include <initializer_list>
 #include <memory>
 #include <string>
+#include <type_traits>
 #include <utility>
-#include <vector>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/container/inlined_vector.h"
 #include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
+#include "absl/status/statusor.h"
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
 
@@ -44,42 +39,50 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/channel/call_finalization.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gpr/alloc.h"
 #include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/gprpp/status_helper.h"
-#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
-#include "src/core/lib/promise/detail/basic_seq.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/loop.h"
+#include "src/core/lib/promise/map.h"
+#include "src/core/lib/promise/party.h"
 #include "src/core/lib/promise/pipe.h"
 #include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/promise.h"
+#include "src/core/lib/promise/race.h"
+#include "src/core/lib/promise/seq.h"
+#include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/call_trace.h"
 #include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/transport/batch_builder.h"
+#include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/lib/transport/transport_fwd.h"
 #include "src/core/lib/transport/transport_impl.h"
 
-#define MAX_BUFFER_LENGTH 8192
-
 typedef struct connected_channel_channel_data {
   grpc_transport* transport;
 } channel_data;
@@ -252,10 +255,24 @@ namespace {
     defined(GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL)
 class ConnectedChannelStream : public Orphanable {
  public:
+  explicit ConnectedChannelStream(grpc_transport* transport)
+      : transport_(transport), stream_(nullptr, StreamDeleter(this)) {
+    GRPC_STREAM_REF_INIT(
+        &stream_refcount_, 1,
+        [](void* p, grpc_error_handle) {
+          static_cast<ConnectedChannelStream*>(p)->BeginDestroy();
+        },
+        this, "ConnectedChannelStream");
+  }
+
   grpc_transport* transport() { return transport_; }
   grpc_closure* stream_destroyed_closure() { return &stream_destroyed_; }
 
-  void IncrementRefCount(const char* reason) {
+  BatchBuilder::Target batch_target() {
+    return BatchBuilder::Target{transport_, stream_.get(), &stream_refcount_};
+  }
+
+  void IncrementRefCount(const char* reason = "smartptr") {
 #ifndef NDEBUG
     grpc_stream_ref(&stream_refcount_, reason);
 #else
@@ -264,7 +281,7 @@ class ConnectedChannelStream : public Orphanable {
 #endif
   }
 
-  void Unref(const char* reason) {
+  void Unref(const char* reason = "smartptr") {
 #ifndef NDEBUG
     grpc_stream_unref(&stream_refcount_, reason);
 #else
@@ -273,234 +290,49 @@ class ConnectedChannelStream : public Orphanable {
 #endif
   }
 
+  RefCountedPtr<ConnectedChannelStream> InternalRef() {
+    IncrementRefCount("smartptr");
+    return RefCountedPtr<ConnectedChannelStream>(this);
+  }
+
   void Orphan() final {
-    bool finished;
-    {
-      MutexLock lock(mu());
-      if (grpc_call_trace.enabled()) {
-        gpr_log(GPR_INFO, "%s[connected] DropStream: %s finished=%s",
-                Activity::current()->DebugTag().c_str(),
-                ActiveOpsString().c_str(), finished_ ? "true" : "false");
-      }
-      finished = finished_;
+    bool finished = finished_.IsSet();
+    if (grpc_call_trace.enabled()) {
+      gpr_log(GPR_DEBUG, "%s[connected] Orphan stream, finished: %d",
+              party_->DebugTag().c_str(), finished);
     }
     // If we hadn't already observed the stream to be finished, we need to
     // cancel it at the transport.
     if (!finished) {
-      IncrementRefCount("shutdown client stream");
-      auto* cancel_op =
-          GetContext<Arena>()->New<grpc_transport_stream_op_batch>();
-      cancel_op->cancel_stream = true;
-      cancel_op->payload = batch_payload();
-      auto* s = stream();
-      cancel_op->on_complete = NewClosure(
-          [this](grpc_error_handle) { Unref("shutdown client stream"); });
-      batch_payload()->cancel_stream.cancel_error = absl::CancelledError();
-      grpc_transport_perform_stream_op(transport(), s, cancel_op);
+      party_->Spawn(
+          "finish",
+          [self = InternalRef()]() {
+            if (!self->finished_.IsSet()) {
+              self->finished_.Set();
+            }
+            return Empty{};
+          },
+          [](Empty) {});
+      GetContext<BatchBuilder>()->Cancel(batch_target(),
+                                         absl::CancelledError());
     }
-    Unref("orphan client stream");
+    Unref("orphan connected stream");
   }
 
- protected:
-  explicit ConnectedChannelStream(grpc_transport* transport)
-      : transport_(transport), stream_(nullptr, StreamDeleter(this)) {
-    call_context_->IncrementRefCount("connected_channel_stream");
-    GRPC_STREAM_REF_INIT(
-        &stream_refcount_, 1,
-        [](void* p, grpc_error_handle) {
-          static_cast<ConnectedChannelStream*>(p)->BeginDestroy();
-        },
-        this, "client_stream");
-  }
+  // Returns a promise that implements the receive message loop.
+  auto RecvMessages(PipeSender<MessageHandle>* incoming_messages,
+                    bool cancel_on_error);
+  // Returns a promise that implements the send message loop.
+  auto SendMessages(PipeReceiver<MessageHandle>* outgoing_messages);
 
-  grpc_stream* stream() { return stream_.get(); }
   void SetStream(grpc_stream* stream) { stream_.reset(stream); }
+  grpc_stream* stream() { return stream_.get(); }
   grpc_stream_refcount* stream_refcount() { return &stream_refcount_; }
-  Mutex* mu() const ABSL_LOCK_RETURNED(mu_) { return &mu_; }
-  grpc_transport_stream_op_batch_payload* batch_payload() {
-    return &batch_payload_;
-  }
-  bool finished() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) { return finished_; }
-  void set_finished() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) { finished_ = true; }
-  virtual std::string ActiveOpsString() const
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) = 0;
-
-  void SchedulePush(grpc_transport_stream_op_batch* batch)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
-    if (grpc_call_trace.enabled()) {
-      gpr_log(GPR_DEBUG, "%s[connected] Push batch to transport: %s",
-              Activity::current()->DebugTag().c_str(),
-              grpc_transport_stream_op_batch_string(batch).c_str());
-    }
-    if (push_batches_.empty()) {
-      IncrementRefCount("push");
-      ExecCtx::Run(DEBUG_LOCATION, &push_, absl::OkStatus());
-    }
-    push_batches_.push_back(batch);
-  }
-
-  void PollSendMessage(PipeReceiver<MessageHandle>* outgoing_messages,
-                       ClientMetadataHandle* client_trailing_metadata)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
-    if (absl::holds_alternative<Closed>(send_message_state_)) {
-      message_to_send_.reset();
-    }
-    if (absl::holds_alternative<Idle>(send_message_state_)) {
-      message_to_send_.reset();
-      send_message_state_.emplace<PipeReceiverNextType<MessageHandle>>(
-          outgoing_messages->Next());
-    }
-    if (auto* next = absl::get_if<PipeReceiverNextType<MessageHandle>>(
-            &send_message_state_)) {
-      auto r = (*next)();
-      if (auto* p = r.value_if_ready()) {
-        memset(&send_message_, 0, sizeof(send_message_));
-        send_message_.payload = batch_payload();
-        send_message_.on_complete = &send_message_batch_done_;
-        // No value => half close from above.
-        if (p->has_value()) {
-          message_to_send_ = std::move(*p);
-          send_message_state_ = SendMessageToTransport{};
-          send_message_.send_message = true;
-          batch_payload()->send_message.send_message =
-              (*message_to_send_)->payload();
-          batch_payload()->send_message.flags = (*message_to_send_)->flags();
-        } else {
-          if (grpc_call_trace.enabled()) {
-            gpr_log(GPR_INFO, "%s[connected] PollConnectedChannel: half close",
-                    Activity::current()->DebugTag().c_str());
-          }
-          GPR_ASSERT(!absl::holds_alternative<Closed>(send_message_state_));
-          send_message_state_ = Closed{};
-          send_message_.send_trailing_metadata = true;
-          if (client_trailing_metadata != nullptr) {
-            *client_trailing_metadata =
-                GetContext<Arena>()->MakePooled<ClientMetadata>(
-                    GetContext<Arena>());
-            batch_payload()->send_trailing_metadata.send_trailing_metadata =
-                client_trailing_metadata->get();
-            batch_payload()->send_trailing_metadata.sent = nullptr;
-          } else {
-            return;  // Skip rest of function for server
-          }
-        }
-        IncrementRefCount("send_message");
-        send_message_waker_ = Activity::current()->MakeOwningWaker();
-        SchedulePush(&send_message_);
-      }
-    }
-  }
-
-  void PollRecvMessage(PipeSender<MessageHandle>*& incoming_messages)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
-    if (auto* pending =
-            absl::get_if<PendingReceiveMessage>(&recv_message_state_)) {
-      if (pending->received) {
-        if (pending->payload.has_value()) {
-          if (grpc_call_trace.enabled()) {
-            gpr_log(GPR_INFO,
-                    "%s[connected] PollRecvMessage: received payload of "
-                    "%" PRIdPTR " bytes",
-                    recv_message_waker_.ActivityDebugTag().c_str(),
-                    pending->payload->Length());
-          }
-          recv_message_state_ =
-              incoming_messages->Push(GetContext<Arena>()->MakePooled<Message>(
-                  std::move(*pending->payload), pending->flags));
-        } else {
-          if (grpc_call_trace.enabled()) {
-            gpr_log(GPR_INFO,
-                    "%s[connected] PollRecvMessage: received no payload",
-                    recv_message_waker_.ActivityDebugTag().c_str());
-          }
-          recv_message_state_ = Closed{};
-          std::exchange(incoming_messages, nullptr)->Close();
-        }
-      }
-    }
-    if (absl::holds_alternative<Idle>(recv_message_state_)) {
-      if (grpc_call_trace.enabled()) {
-        gpr_log(GPR_INFO, "%s[connected] PollRecvMessage: requesting message",
-                Activity::current()->DebugTag().c_str());
-      }
-      PushRecvMessage();
-    }
-    if (auto* push = absl::get_if<PipeSender<MessageHandle>::PushType>(
-            &recv_message_state_)) {
-      auto r = (*push)();
-      if (bool* result = r.value_if_ready()) {
-        if (*result) {
-          if (!finished_) {
-            if (grpc_call_trace.enabled()) {
-              gpr_log(GPR_INFO,
-                      "%s[connected] PollRecvMessage: pushed message; "
-                      "requesting next",
-                      Activity::current()->DebugTag().c_str());
-            }
-            PushRecvMessage();
-          } else {
-            if (grpc_call_trace.enabled()) {
-              gpr_log(GPR_INFO,
-                      "%s[connected] PollRecvMessage: pushed message "
-                      "and finished; "
-                      "marking closed",
-                      Activity::current()->DebugTag().c_str());
-            }
-            recv_message_state_ = Closed{};
-            std::exchange(incoming_messages, nullptr)->Close();
-          }
-        } else {
-          if (grpc_call_trace.enabled()) {
-            gpr_log(GPR_INFO,
-                    "%s[connected] PollRecvMessage: failed to push "
-                    "message; marking "
-                    "closed",
-                    Activity::current()->DebugTag().c_str());
-          }
-          recv_message_state_ = Closed{};
-          std::exchange(incoming_messages, nullptr)->Close();
-        }
-      }
-    }
-  }
-
-  std::string SendMessageString() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
-    return Match(
-        send_message_state_, [](Idle) -> std::string { return "IDLE"; },
-        [](Closed) -> std::string { return "CLOSED"; },
-        [](const PipeReceiverNextType<MessageHandle>&) -> std::string {
-          return "WAITING";
-        },
-        [](SendMessageToTransport) -> std::string { return "SENDING"; });
-  }
 
-  std::string RecvMessageString() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
-    return Match(
-        recv_message_state_, [](Idle) -> std::string { return "IDLE"; },
-        [](Closed) -> std::string { return "CLOSED"; },
-        [](const PendingReceiveMessage&) -> std::string { return "WAITING"; },
-        [](const absl::optional<MessageHandle>& message) -> std::string {
-          return absl::StrCat(
-              "READY:", message.has_value()
-                            ? absl::StrCat((*message)->payload()->Length(), "b")
-                            : "EOS");
-        },
-        [](const PipeSender<MessageHandle>::PushType&) -> std::string {
-          return "PUSHING";
-        });
-  }
-
-  bool IsPromiseReceiving() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
-    return absl::holds_alternative<PipeSender<MessageHandle>::PushType>(
-               recv_message_state_) ||
-           absl::holds_alternative<PendingReceiveMessage>(recv_message_state_);
-  }
+  void set_finished() { finished_.Set(); }
+  auto WaitFinished() { return finished_.Wait(); }
 
  private:
-  struct SendMessageToTransport {};
-  struct Idle {};
-  struct Closed {};
-
   class StreamDeleter {
    public:
     explicit StreamDeleter(ConnectedChannelStream* impl) : impl_(impl) {}
@@ -516,11 +348,7 @@ class ConnectedChannelStream : public Orphanable {
   using StreamPtr = std::unique_ptr<grpc_stream, StreamDeleter>;
 
   void StreamDestroyed() {
-    call_context_->RunInContext([this] {
-      auto* cc = call_context_;
-      this->~ConnectedChannelStream();
-      cc->Unref("child_stream");
-    });
+    call_context_->RunInContext([this] { this->~ConnectedChannelStream(); });
   }
 
   void BeginDestroy() {
@@ -531,828 +359,502 @@ class ConnectedChannelStream : public Orphanable {
     }
   }
 
-  // Called from outside the activity to push work down to the transport.
-  void Push() {
-    PushBatches push_batches;
-    {
-      MutexLock lock(&mu_);
-      push_batches.swap(push_batches_);
-    }
-    for (auto* batch : push_batches) {
-      if (stream() != nullptr) {
-        grpc_transport_perform_stream_op(transport(), stream(), batch);
-      } else {
-        grpc_transport_stream_op_batch_finish_with_failure_from_transport(
-            batch, absl::CancelledError());
-      }
-    }
-    Unref("push");
-  }
-
-  void SendMessageBatchDone(grpc_error_handle error) {
-    {
-      MutexLock lock(&mu_);
-      if (error != absl::OkStatus()) {
-        // Note that we're in error here, the call will be closed by the
-        // transport in a moment, and we'll return from the promise with an
-        // error - so we don't need to do any extra work to close out pipes or
-        // the like.
-        send_message_state_ = Closed{};
-      }
-      if (!absl::holds_alternative<Closed>(send_message_state_)) {
-        send_message_state_ = Idle{};
-      }
-      send_message_waker_.Wakeup();
-    }
-    Unref("send_message");
-  }
-
-  void RecvMessageBatchDone(grpc_error_handle error) {
-    {
-      MutexLock lock(mu());
-      if (error != absl::OkStatus()) {
-        if (grpc_call_trace.enabled()) {
-          gpr_log(GPR_INFO, "%s[connected] RecvMessageBatchDone: error=%s",
-                  recv_message_waker_.ActivityDebugTag().c_str(),
-                  StatusToString(error).c_str());
-        }
-      } else if (absl::holds_alternative<Closed>(recv_message_state_)) {
-        if (grpc_call_trace.enabled()) {
-          gpr_log(GPR_INFO,
-                  "%s[connected] RecvMessageBatchDone: already closed, "
-                  "ignoring",
-                  recv_message_waker_.ActivityDebugTag().c_str());
-        }
-      } else {
-        if (grpc_call_trace.enabled()) {
-          gpr_log(GPR_INFO,
-                  "%s[connected] RecvMessageBatchDone: received message",
-                  recv_message_waker_.ActivityDebugTag().c_str());
-        }
-        auto pending =
-            absl::get_if<PendingReceiveMessage>(&recv_message_state_);
-        GPR_ASSERT(pending != nullptr);
-        GPR_ASSERT(pending->received == false);
-        pending->received = true;
-      }
-      recv_message_waker_.Wakeup();
-    }
-    Unref("recv_message");
-  }
-
-  void PushRecvMessage() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
-    recv_message_state_ = PendingReceiveMessage{};
-    auto& pending_recv_message =
-        absl::get<PendingReceiveMessage>(recv_message_state_);
-    memset(&recv_message_, 0, sizeof(recv_message_));
-    recv_message_.payload = batch_payload();
-    recv_message_.on_complete = nullptr;
-    recv_message_.recv_message = true;
-    batch_payload()->recv_message.recv_message = &pending_recv_message.payload;
-    batch_payload()->recv_message.flags = &pending_recv_message.flags;
-    batch_payload()->recv_message.call_failed_before_recv_message = nullptr;
-    batch_payload()->recv_message.recv_message_ready =
-        &recv_message_batch_done_;
-    IncrementRefCount("recv_message");
-    recv_message_waker_ = Activity::current()->MakeOwningWaker();
-    SchedulePush(&recv_message_);
-  }
-
-  mutable Mutex mu_;
   grpc_transport* const transport_;
-  CallContext* const call_context_{GetContext<CallContext>()};
+  RefCountedPtr<CallContext> const call_context_{
+      GetContext<CallContext>()->Ref()};
   grpc_closure stream_destroyed_ =
       MakeMemberClosure<ConnectedChannelStream,
                         &ConnectedChannelStream::StreamDestroyed>(
           this, DEBUG_LOCATION);
   grpc_stream_refcount stream_refcount_;
   StreamPtr stream_;
-  using PushBatches = absl::InlinedVector<grpc_transport_stream_op_batch*, 3>;
-  PushBatches push_batches_ ABSL_GUARDED_BY(mu_);
-  grpc_closure push_ =
-      MakeMemberClosure<ConnectedChannelStream, &ConnectedChannelStream::Push>(
-          this, DEBUG_LOCATION);
-
-  NextResult<MessageHandle> message_to_send_ ABSL_GUARDED_BY(mu_);
-  absl::variant<Idle, Closed, PipeReceiverNextType<MessageHandle>,
-                SendMessageToTransport>
-      send_message_state_ ABSL_GUARDED_BY(mu_);
-  grpc_transport_stream_op_batch send_message_;
-  grpc_closure send_message_batch_done_ =
-      MakeMemberClosure<ConnectedChannelStream,
-                        &ConnectedChannelStream::SendMessageBatchDone>(
-          this, DEBUG_LOCATION);
-
-  struct PendingReceiveMessage {
-    absl::optional<SliceBuffer> payload;
-    uint32_t flags;
-    bool received = false;
-  };
-  absl::variant<Idle, PendingReceiveMessage, Closed,
-                PipeSender<MessageHandle>::PushType>
-      recv_message_state_ ABSL_GUARDED_BY(mu_);
-  grpc_closure recv_message_batch_done_ =
-      MakeMemberClosure<ConnectedChannelStream,
-                        &ConnectedChannelStream::RecvMessageBatchDone>(
-          this, DEBUG_LOCATION);
-  grpc_transport_stream_op_batch recv_message_;
-
-  Waker send_message_waker_ ABSL_GUARDED_BY(mu_);
-  Waker recv_message_waker_ ABSL_GUARDED_BY(mu_);
-  bool finished_ ABSL_GUARDED_BY(mu_) = false;
-
-  grpc_transport_stream_op_batch_payload batch_payload_{
-      GetContext<grpc_call_context_element>()};
+  Arena* arena_ = GetContext<Arena>();
+  Party* const party_ = static_cast<Party*>(Activity::current());
+  ExternallyObservableLatch<void> finished_;
 };
-#endif
-
-#ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_CLIENT_CALL
-class ClientStream : public ConnectedChannelStream {
- public:
-  ClientStream(grpc_transport* transport, CallArgs call_args)
-      : ConnectedChannelStream(transport),
-        server_initial_metadata_pipe_(call_args.server_initial_metadata),
-        client_to_server_messages_(call_args.client_to_server_messages),
-        server_to_client_messages_(call_args.server_to_client_messages),
-        client_initial_metadata_(std::move(call_args.client_initial_metadata)) {
-    if (grpc_call_trace.enabled()) {
-      gpr_log(GPR_INFO, "%s[connected] InitImpl: intitial_metadata=%s",
-              Activity::current()->DebugTag().c_str(),
-              client_initial_metadata_->DebugString().c_str());
-    }
-  }
-
-  Poll<ServerMetadataHandle> PollOnce() {
-    MutexLock lock(mu());
-    GPR_ASSERT(!finished());
-
-    if (grpc_call_trace.enabled()) {
-      gpr_log(GPR_INFO, "%s[connected] PollConnectedChannel: %s",
-              Activity::current()->DebugTag().c_str(),
-              ActiveOpsString().c_str());
-    }
-
-    if (!std::exchange(requested_metadata_, true)) {
-      if (grpc_call_trace.enabled()) {
-        gpr_log(GPR_INFO,
-                "%s[connected] PollConnectedChannel: requesting metadata",
-                Activity::current()->DebugTag().c_str());
-      }
-      SetStream(static_cast<grpc_stream*>(
-          GetContext<Arena>()->Alloc(transport()->vtable->sizeof_stream)));
-      grpc_transport_init_stream(transport(), stream(), stream_refcount(),
-                                 nullptr, GetContext<Arena>());
-      grpc_transport_set_pops(transport(), stream(),
-                              GetContext<CallContext>()->polling_entity());
-      memset(&metadata_, 0, sizeof(metadata_));
-      metadata_.send_initial_metadata = true;
-      metadata_.recv_initial_metadata = true;
-      metadata_.recv_trailing_metadata = true;
-      metadata_.payload = batch_payload();
-      metadata_.on_complete = &metadata_batch_done_;
-      batch_payload()->send_initial_metadata.send_initial_metadata =
-          client_initial_metadata_.get();
-      batch_payload()->send_initial_metadata.peer_string =
-          GetContext<CallContext>()->peer_string_atm_ptr();
-      server_initial_metadata_ =
-          GetContext<Arena>()->MakePooled<ServerMetadata>(GetContext<Arena>());
-      batch_payload()->recv_initial_metadata.recv_initial_metadata =
-          server_initial_metadata_.get();
-      batch_payload()->recv_initial_metadata.recv_initial_metadata_ready =
-          &recv_initial_metadata_ready_;
-      batch_payload()->recv_initial_metadata.trailing_metadata_available =
-          nullptr;
-      batch_payload()->recv_initial_metadata.peer_string = nullptr;
-      server_trailing_metadata_ =
-          GetContext<Arena>()->MakePooled<ServerMetadata>(GetContext<Arena>());
-      batch_payload()->recv_trailing_metadata.recv_trailing_metadata =
-          server_trailing_metadata_.get();
-      batch_payload()->recv_trailing_metadata.collect_stats =
-          &GetContext<CallContext>()->call_stats()->transport_stream_stats;
-      batch_payload()->recv_trailing_metadata.recv_trailing_metadata_ready =
-          &recv_trailing_metadata_ready_;
-      IncrementRefCount("metadata_batch_done");
-      IncrementRefCount("initial_metadata_ready");
-      IncrementRefCount("trailing_metadata_ready");
-      initial_metadata_waker_ = Activity::current()->MakeOwningWaker();
-      trailing_metadata_waker_ = Activity::current()->MakeOwningWaker();
-      SchedulePush(&metadata_);
-    }
-    if (server_initial_metadata_state_ ==
-        ServerInitialMetadataState::kReceivedButNotPushed) {
-      server_initial_metadata_state_ = ServerInitialMetadataState::kPushing;
-      server_initial_metadata_push_promise_ =
-          server_initial_metadata_pipe_->Push(
-              std::move(server_initial_metadata_));
-    }
-    if (server_initial_metadata_state_ ==
-        ServerInitialMetadataState::kPushing) {
-      auto r = (*server_initial_metadata_push_promise_)();
-      if (r.ready()) {
-        server_initial_metadata_state_ = ServerInitialMetadataState::kPushed;
-        server_initial_metadata_push_promise_.reset();
-      }
-    }
-    PollSendMessage(client_to_server_messages_, &client_trailing_metadata_);
-    PollRecvMessage(server_to_client_messages_);
-    if (server_initial_metadata_state_ == ServerInitialMetadataState::kPushed &&
-        !IsPromiseReceiving() &&
-        std::exchange(queued_trailing_metadata_, false)) {
-      if (grpc_call_trace.enabled()) {
-        gpr_log(GPR_INFO,
-                "%s[connected] PollConnectedChannel: finished request, "
-                "returning: {%s}; "
-                "active_ops: %s",
-                Activity::current()->DebugTag().c_str(),
-                server_trailing_metadata_->DebugString().c_str(),
-                ActiveOpsString().c_str());
-      }
-      set_finished();
-      return ServerMetadataHandle(std::move(server_trailing_metadata_));
-    }
-    return Pending{};
-  }
-
-  void RecvInitialMetadataReady(grpc_error_handle error) {
-    GPR_ASSERT(error == absl::OkStatus());
-    {
-      MutexLock lock(mu());
-      server_initial_metadata_state_ =
-          ServerInitialMetadataState::kReceivedButNotPushed;
-      initial_metadata_waker_.Wakeup();
-    }
-    Unref("initial_metadata_ready");
-  }
-
-  void RecvTrailingMetadataReady(grpc_error_handle error) {
-    GPR_ASSERT(error == absl::OkStatus());
-    {
-      MutexLock lock(mu());
-      queued_trailing_metadata_ = true;
-      if (grpc_call_trace.enabled()) {
-        gpr_log(GPR_DEBUG,
-                "%s[connected] RecvTrailingMetadataReady: "
-                "queued_trailing_metadata_ "
-                "set to true; active_ops: %s",
-                trailing_metadata_waker_.ActivityDebugTag().c_str(),
-                ActiveOpsString().c_str());
-      }
-      trailing_metadata_waker_.Wakeup();
-    }
-    Unref("trailing_metadata_ready");
-  }
 
-  void MetadataBatchDone(grpc_error_handle error) {
-    GPR_ASSERT(error == absl::OkStatus());
-    Unref("metadata_batch_done");
-  }
-
- private:
-  enum class ServerInitialMetadataState : uint8_t {
-    // Initial metadata has not been received from the server.
-    kNotReceived,
-    // Initial metadata has been received from the server via the transport, but
-    // has not yet been pushed onto the pipe to publish it up the call stack.
-    kReceivedButNotPushed,
-    // Initial metadata has been received from the server via the transport and
-    // has been pushed on the pipe to publish it up the call stack.
-    // It's still in the pipe and has not been removed by the call at the top
-    // yet.
-    kPushing,
-    // Initial metadata has been received from the server via the transport and
-    // has been pushed on the pipe to publish it up the call stack AND removed
-    // by the call at the top.
-    kPushed,
-  };
-
-  std::string ActiveOpsString() const override
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
-    std::vector<std::string> ops;
-    if (finished()) ops.push_back("FINISHED");
-    // Outstanding Operations on Transport
-    std::vector<std::string> waiting;
-    if (initial_metadata_waker_ != Waker()) {
-      waiting.push_back("initial_metadata");
-    }
-    if (trailing_metadata_waker_ != Waker()) {
-      waiting.push_back("trailing_metadata");
-    }
-    if (!waiting.empty()) {
-      ops.push_back(absl::StrCat("waiting:", absl::StrJoin(waiting, ",")));
-    }
-    // Results from transport
-    std::vector<std::string> queued;
-    if (server_initial_metadata_state_ ==
-        ServerInitialMetadataState::kReceivedButNotPushed) {
-      queued.push_back("initial_metadata");
-    }
-    if (queued_trailing_metadata_) queued.push_back("trailing_metadata");
-    if (!queued.empty()) {
-      ops.push_back(absl::StrCat("queued:", absl::StrJoin(queued, ",")));
-    }
-    // Send message
-    std::string send_message_state = SendMessageString();
-    if (send_message_state != "WAITING") {
-      ops.push_back(absl::StrCat("send_message:", send_message_state));
-    }
-    // Receive message
-    std::string recv_message_state = RecvMessageString();
-    if (recv_message_state != "IDLE") {
-      ops.push_back(absl::StrCat("recv_message:", recv_message_state));
-    }
-    return absl::StrJoin(ops, " ");
-  }
-
-  bool requested_metadata_ = false;
-  ServerInitialMetadataState server_initial_metadata_state_
-      ABSL_GUARDED_BY(mu()) = ServerInitialMetadataState::kNotReceived;
-  bool queued_trailing_metadata_ ABSL_GUARDED_BY(mu()) = false;
-  Waker initial_metadata_waker_ ABSL_GUARDED_BY(mu());
-  Waker trailing_metadata_waker_ ABSL_GUARDED_BY(mu());
-  PipeSender<ServerMetadataHandle>* server_initial_metadata_pipe_;
-  PipeReceiver<MessageHandle>* client_to_server_messages_;
-  PipeSender<MessageHandle>* server_to_client_messages_;
-  grpc_closure recv_initial_metadata_ready_ =
-      MakeMemberClosure<ClientStream, &ClientStream::RecvInitialMetadataReady>(
-          this, DEBUG_LOCATION);
-  grpc_closure recv_trailing_metadata_ready_ =
-      MakeMemberClosure<ClientStream, &ClientStream::RecvTrailingMetadataReady>(
-          this, DEBUG_LOCATION);
-  ClientMetadataHandle client_initial_metadata_;
-  ClientMetadataHandle client_trailing_metadata_;
-  ServerMetadataHandle server_initial_metadata_;
-  ServerMetadataHandle server_trailing_metadata_;
-  absl::optional<PipeSender<ServerMetadataHandle>::PushType>
-      server_initial_metadata_push_promise_;
-  grpc_transport_stream_op_batch metadata_;
-  grpc_closure metadata_batch_done_ =
-      MakeMemberClosure<ClientStream, &ClientStream::MetadataBatchDone>(
-          this, DEBUG_LOCATION);
-};
-
-class ClientConnectedCallPromise {
- public:
-  ClientConnectedCallPromise(grpc_transport* transport, CallArgs call_args)
-      : impl_(GetContext<Arena>()->New<ClientStream>(transport,
-                                                     std::move(call_args))) {}
-
-  ClientConnectedCallPromise(const ClientConnectedCallPromise&) = delete;
-  ClientConnectedCallPromise& operator=(const ClientConnectedCallPromise&) =
-      delete;
-  ClientConnectedCallPromise(ClientConnectedCallPromise&& other) noexcept
-      : impl_(std::exchange(other.impl_, nullptr)) {}
-  ClientConnectedCallPromise& operator=(
-      ClientConnectedCallPromise&& other) noexcept {
-    impl_ = std::move(other.impl_);
-    return *this;
-  }
-
-  static ArenaPromise<ServerMetadataHandle> Make(grpc_transport* transport,
-                                                 CallArgs call_args,
-                                                 NextPromiseFactory) {
-    return ClientConnectedCallPromise(transport, std::move(call_args));
-  }
-
-  Poll<ServerMetadataHandle> operator()() { return impl_->PollOnce(); }
-
- private:
-  OrphanablePtr<ClientStream> impl_;
-};
-#endif
+auto ConnectedChannelStream::RecvMessages(
+    PipeSender<MessageHandle>* incoming_messages, bool cancel_on_error) {
+  return Loop([self = InternalRef(), cancel_on_error,
+               incoming_messages = std::move(*incoming_messages)]() mutable {
+    return Seq(
+        GetContext<BatchBuilder>()->ReceiveMessage(self->batch_target()),
+        [cancel_on_error, &incoming_messages](
+            absl::StatusOr<absl::optional<MessageHandle>> status) mutable {
+          bool has_message = status.ok() && status->has_value();
+          auto publish_message = [&incoming_messages, &status]() {
+            auto pending_message = std::move(**status);
+            if (grpc_call_trace.enabled()) {
+              gpr_log(GPR_INFO,
+                      "%s[connected] RecvMessage: received payload of %" PRIdPTR
+                      " bytes",
+                      Activity::current()->DebugTag().c_str(),
+                      pending_message->payload()->Length());
+            }
+            return Map(incoming_messages.Push(std::move(pending_message)),
+                       [](bool ok) -> LoopCtl<absl::Status> {
+                         if (!ok) {
+                           if (grpc_call_trace.enabled()) {
+                             gpr_log(GPR_INFO,
+                                     "%s[connected] RecvMessage: failed to "
+                                     "push message towards the application",
+                                     Activity::current()->DebugTag().c_str());
+                           }
+                           return absl::OkStatus();
+                         }
+                         return Continue{};
+                       });
+          };
+          auto publish_close = [cancel_on_error, &incoming_messages,
+                                &status]() mutable {
+            if (grpc_call_trace.enabled()) {
+              gpr_log(GPR_INFO,
+                      "%s[connected] RecvMessage: reached end of stream with "
+                      "status:%s",
+                      Activity::current()->DebugTag().c_str(),
+                      status.status().ToString().c_str());
+            }
+            if (cancel_on_error && !status.ok()) {
+              incoming_messages.CloseWithError();
+            }
+            return Immediate(LoopCtl<absl::Status>(status.status()));
+          };
+          return If(has_message, std::move(publish_message),
+                    std::move(publish_close));
+        });
+  });
+}
 
-#ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL
-class ServerStream final : public ConnectedChannelStream {
- public:
-  ServerStream(grpc_transport* transport,
-               NextPromiseFactory next_promise_factory)
-      : ConnectedChannelStream(transport) {
-    SetStream(static_cast<grpc_stream*>(
-        GetContext<Arena>()->Alloc(transport->vtable->sizeof_stream)));
-    grpc_transport_init_stream(
-        transport, stream(), stream_refcount(),
-        GetContext<CallContext>()->server_call_context()->server_stream_data(),
-        GetContext<Arena>());
-    grpc_transport_set_pops(transport, stream(),
-                            GetContext<CallContext>()->polling_entity());
-
-    // Fetch initial metadata
-    auto& gim = call_state_.emplace<GettingInitialMetadata>(this);
-    gim.recv_initial_metadata_ready_waker =
-        Activity::current()->MakeOwningWaker();
-    memset(&gim.recv_initial_metadata, 0, sizeof(gim.recv_initial_metadata));
-    gim.recv_initial_metadata.payload = batch_payload();
-    gim.recv_initial_metadata.on_complete = nullptr;
-    gim.recv_initial_metadata.recv_initial_metadata = true;
-    gim.next_promise_factory = std::move(next_promise_factory);
-    batch_payload()->recv_initial_metadata.recv_initial_metadata =
-        gim.client_initial_metadata.get();
-    batch_payload()->recv_initial_metadata.recv_initial_metadata_ready =
-        &gim.recv_initial_metadata_ready;
-    SchedulePush(&gim.recv_initial_metadata);
-
-    // Fetch trailing metadata (to catch cancellations)
-    auto& gtm =
-        client_trailing_metadata_state_.emplace<WaitingForTrailingMetadata>();
-    gtm.recv_trailing_metadata_ready =
-        MakeMemberClosure<ServerStream,
-                          &ServerStream::RecvTrailingMetadataReady>(this);
-    memset(&gtm.recv_trailing_metadata, 0, sizeof(gtm.recv_trailing_metadata));
-    gtm.recv_trailing_metadata.payload = batch_payload();
-    gtm.recv_trailing_metadata.recv_trailing_metadata = true;
-    batch_payload()->recv_trailing_metadata.recv_trailing_metadata =
-        gtm.result.get();
-    batch_payload()->recv_trailing_metadata.collect_stats =
-        &GetContext<CallContext>()->call_stats()->transport_stream_stats;
-    batch_payload()->recv_trailing_metadata.recv_trailing_metadata_ready =
-        &gtm.recv_trailing_metadata_ready;
-    SchedulePush(&gtm.recv_trailing_metadata);
-    gtm.waker = Activity::current()->MakeOwningWaker();
-  }
+auto ConnectedChannelStream::SendMessages(
+    PipeReceiver<MessageHandle>* outgoing_messages) {
+  return ForEach(std::move(*outgoing_messages),
+                 [self = InternalRef()](MessageHandle message) {
+                   return GetContext<BatchBuilder>()->SendMessage(
+                       self->batch_target(), std::move(message));
+                 });
+}
+#endif  // defined(GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_CLIENT_CALL) ||
+        // defined(GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL)
 
-  Poll<ServerMetadataHandle> PollOnce() {
-    MutexLock lock(mu());
-
-    auto poll_send_initial_metadata = [this]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(
-                                          mu()) {
-      if (auto* promise =
-              absl::get_if<PipeReceiverNextType<ServerMetadataHandle>>(
-                  &server_initial_metadata_)) {
-        auto r = (*promise)();
-        if (auto* md = r.value_if_ready()) {
-          if (grpc_call_trace.enabled()) {
-            gpr_log(
-                GPR_INFO, "%s[connected] got initial metadata %s",
-                Activity::current()->DebugTag().c_str(),
-                (md->has_value() ? (**md)->DebugString() : "<trailers-only>")
-                    .c_str());
+#ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_CLIENT_CALL
+ArenaPromise<ServerMetadataHandle> MakeClientCallPromise(
+    grpc_transport* transport, CallArgs call_args, NextPromiseFactory) {
+  OrphanablePtr<ConnectedChannelStream> stream(
+      GetContext<Arena>()->New<ConnectedChannelStream>(transport));
+  stream->SetStream(static_cast<grpc_stream*>(
+      GetContext<Arena>()->Alloc(transport->vtable->sizeof_stream)));
+  grpc_transport_init_stream(transport, stream->stream(),
+                             stream->stream_refcount(), nullptr,
+                             GetContext<Arena>());
+  auto* party = static_cast<Party*>(Activity::current());
+  party->Spawn(
+      "set_polling_entity", call_args.polling_entity->Wait(),
+      [transport,
+       stream = stream->InternalRef()](grpc_polling_entity polling_entity) {
+        grpc_transport_set_pops(transport, stream->stream(), &polling_entity);
+      });
+  // Start a loop to send messages from client_to_server_messages to the
+  // transport. When the pipe closes and the loop completes, send a trailing
+  // metadata batch to close the stream.
+  party->Spawn(
+      "send_messages",
+      TrySeq(stream->SendMessages(call_args.client_to_server_messages),
+             [stream = stream->InternalRef()]() {
+               return GetContext<BatchBuilder>()->SendClientTrailingMetadata(
+                   stream->batch_target());
+             }),
+      [](absl::Status) {});
+  // Start a promise to receive server initial metadata and then forward it up
+  // through the receiving pipe.
+  auto server_initial_metadata =
+      GetContext<Arena>()->MakePooled<ServerMetadata>(GetContext<Arena>());
+  party->Spawn(
+      "recv_initial_metadata",
+      TrySeq(GetContext<BatchBuilder>()->ReceiveServerInitialMetadata(
+                 stream->batch_target()),
+             [pipe = call_args.server_initial_metadata](
+                 ServerMetadataHandle server_initial_metadata) {
+               if (grpc_call_trace.enabled()) {
+                 gpr_log(GPR_DEBUG,
+                         "%s[connected] Publish client initial metadata: %s",
+                         Activity::current()->DebugTag().c_str(),
+                         server_initial_metadata->DebugString().c_str());
+               }
+               return Map(pipe->Push(std::move(server_initial_metadata)),
+                          [](bool r) {
+                            if (r) return absl::OkStatus();
+                            return absl::CancelledError();
+                          });
+             }),
+      [](absl::Status) {});
+
+  // Build up the rest of the main call promise:
+
+  // Create a promise that will send initial metadata and then signal completion
+  // of that via the token.
+  auto send_initial_metadata = Seq(
+      GetContext<BatchBuilder>()->SendClientInitialMetadata(
+          stream->batch_target(), std::move(call_args.client_initial_metadata)),
+      [sent_initial_metadata_token =
+           std::move(call_args.client_initial_metadata_outstanding)](
+          absl::Status status) mutable {
+        sent_initial_metadata_token.Complete(status.ok());
+        return status;
+      });
+  // Create a promise that will receive server trailing metadata.
+  // If this fails, we massage the error into metadata that we can report
+  // upwards.
+  auto server_trailing_metadata =
+      GetContext<Arena>()->MakePooled<ServerMetadata>(GetContext<Arena>());
+  auto recv_trailing_metadata =
+      Map(GetContext<BatchBuilder>()->ReceiveServerTrailingMetadata(
+              stream->batch_target()),
+          [](absl::StatusOr<ServerMetadataHandle> status) mutable {
+            if (!status.ok()) {
+              auto server_trailing_metadata =
+                  GetContext<Arena>()->MakePooled<ServerMetadata>(
+                      GetContext<Arena>());
+              grpc_status_code status_code = GRPC_STATUS_UNKNOWN;
+              std::string message;
+              grpc_error_get_status(status.status(), Timestamp::InfFuture(),
+                                    &status_code, &message, nullptr, nullptr);
+              server_trailing_metadata->Set(GrpcStatusMetadata(), status_code);
+              server_trailing_metadata->Set(GrpcMessageMetadata(),
+                                            Slice::FromCopiedString(message));
+              return server_trailing_metadata;
+            } else {
+              return std::move(*status);
+            }
+          });
+  // Finally the main call promise.
+  // Concurrently: send initial metadata and receive messages, until BOTH
+  // complete (or one fails).
+  // Next: receive trailing metadata, and return that up the stack.
+  auto recv_messages =
+      stream->RecvMessages(call_args.server_to_client_messages, false);
+  return Map(
+      [send_initial_metadata = std::move(send_initial_metadata),
+       recv_messages = std::move(recv_messages),
+       recv_trailing_metadata = std::move(recv_trailing_metadata),
+       done_send_initial_metadata = false, done_recv_messages = false,
+       done_recv_trailing_metadata =
+           false]() mutable -> Poll<ServerMetadataHandle> {
+        if (!done_send_initial_metadata) {
+          auto p = send_initial_metadata();
+          if (auto* r = p.value_if_ready()) {
+            done_send_initial_metadata = true;
+            if (!r->ok()) return StatusCast<ServerMetadataHandle>(*r);
           }
-          memset(&send_initial_metadata_, 0, sizeof(send_initial_metadata_));
-          send_initial_metadata_.send_initial_metadata = true;
-          send_initial_metadata_.payload = batch_payload();
-          send_initial_metadata_.on_complete = &send_initial_metadata_done_;
-          batch_payload()->send_initial_metadata.send_initial_metadata =
-              server_initial_metadata_
-                  .emplace<ServerMetadataHandle>(std::move(**md))
-                  .get();
-          batch_payload()->send_initial_metadata.peer_string = nullptr;
-          SchedulePush(&send_initial_metadata_);
-          return true;
-        } else {
-          return false;
         }
-      } else {
-        return true;
-      }
-    };
-
-    if (grpc_call_trace.enabled()) {
-      gpr_log(GPR_INFO, "%s[connected] PollConnectedChannel: %s",
-              Activity::current()->DebugTag().c_str(),
-              ActiveOpsString().c_str());
-    }
-
-    poll_send_initial_metadata();
-
-    if (auto* p = absl::get_if<GotClientHalfClose>(
-            &client_trailing_metadata_state_)) {
-      pipes_.client_to_server.sender.Close();
-      if (!p->result.ok()) {
-        // client cancelled, we should cancel too
-        if (absl::holds_alternative<absl::monostate>(call_state_) ||
-            absl::holds_alternative<GotInitialMetadata>(call_state_) ||
-            absl::holds_alternative<MessageLoop>(call_state_)) {
-          if (!absl::holds_alternative<ServerMetadataHandle>(
-                  server_initial_metadata_)) {
-            // pretend we've sent initial metadata to stop that op from
-            // progressing if it's stuck somewhere above us in the stack
-            server_initial_metadata_.emplace<ServerMetadataHandle>();
+        if (!done_recv_messages) {
+          auto p = recv_messages();
+          if (auto* r = p.value_if_ready()) {
+            // NOTE: ignore errors here, they'll be collected in the
+            // recv_trailing_metadata.
+            done_recv_messages = true;
+          } else {
+            return Pending{};
           }
-          // cancel the call - this status will be returned to the server bottom
-          // promise
-          call_state_.emplace<Complete>(
-              Complete{ServerMetadataFromStatus(p->result)});
-        }
-      }
-    }
-
-    if (auto* p = absl::get_if<GotInitialMetadata>(&call_state_)) {
-      incoming_messages_ = &pipes_.client_to_server.sender;
-      auto promise = p->next_promise_factory(CallArgs{
-          std::move(p->client_initial_metadata),
-          &pipes_.server_initial_metadata.sender,
-          &pipes_.client_to_server.receiver, &pipes_.server_to_client.sender});
-      call_state_.emplace<MessageLoop>(
-          MessageLoop{&pipes_.server_to_client.receiver, std::move(promise)});
-      server_initial_metadata_
-          .emplace<PipeReceiverNextType<ServerMetadataHandle>>(
-              pipes_.server_initial_metadata.receiver.Next());
-    }
-    if (incoming_messages_ != nullptr) {
-      PollRecvMessage(incoming_messages_);
-    }
-    if (auto* p = absl::get_if<MessageLoop>(&call_state_)) {
-      if (absl::holds_alternative<ServerMetadataHandle>(
-              server_initial_metadata_)) {
-        PollSendMessage(p->outgoing_messages, nullptr);
-      }
-      auto poll = p->promise();
-      if (auto* r = poll.value_if_ready()) {
-        if (grpc_call_trace.enabled()) {
-          gpr_log(GPR_INFO, "%s[connected] got trailing metadata %s; %s",
-                  Activity::current()->DebugTag().c_str(),
-                  (*r)->DebugString().c_str(), ActiveOpsString().c_str());
         }
-        auto& completing = call_state_.emplace<Completing>();
-        completing.server_trailing_metadata = std::move(*r);
-        completing.on_complete =
-            MakeMemberClosure<ServerStream,
-                              &ServerStream::SendTrailingMetadataDone>(this);
-        completing.waker = Activity::current()->MakeOwningWaker();
-        auto& op = completing.send_trailing_metadata;
-        memset(&op, 0, sizeof(op));
-        op.payload = batch_payload();
-        op.on_complete = &completing.on_complete;
-        // If we've gotten initial server metadata, we can send trailing
-        // metadata.
-        // Otherwise we need to cancel the call.
-        // There could be an unlucky ordering, so we poll here to make sure.
-        if (poll_send_initial_metadata()) {
-          op.send_trailing_metadata = true;
-          batch_payload()->send_trailing_metadata.send_trailing_metadata =
-              completing.server_trailing_metadata.get();
-          batch_payload()->send_trailing_metadata.sent = &completing.sent;
-        } else {
-          op.cancel_stream = true;
-          const auto status_code =
-              completing.server_trailing_metadata->get(GrpcStatusMetadata())
-                  .value_or(GRPC_STATUS_UNKNOWN);
-          batch_payload()->cancel_stream.cancel_error = grpc_error_set_int(
-              absl::Status(static_cast<absl::StatusCode>(status_code),
-                           completing.server_trailing_metadata
-                               ->GetOrCreatePointer(GrpcMessageMetadata())
-                               ->as_string_view()),
-              StatusIntProperty::kRpcStatus, status_code);
+        if (!done_recv_trailing_metadata) {
+          auto p = recv_trailing_metadata();
+          if (auto* r = p.value_if_ready()) {
+            done_recv_trailing_metadata = true;
+            return std::move(*r);
+          }
         }
-        SchedulePush(&op);
-      }
-    }
-    if (auto* p = absl::get_if<Complete>(&call_state_)) {
-      set_finished();
-      return std::move(p->result);
-    }
-    return Pending{};
-  }
-
- private:
-  // Call state: we've asked the transport for initial metadata and are
-  // waiting for it before proceeding.
-  struct GettingInitialMetadata {
-    explicit GettingInitialMetadata(ServerStream* stream)
-        : recv_initial_metadata_ready(
-              MakeMemberClosure<ServerStream,
-                                &ServerStream::RecvInitialMetadataReady>(
-                  stream)) {}
-    // The batch we're using to get initial metadata.
-    grpc_transport_stream_op_batch recv_initial_metadata;
-    // Waker to re-enter the activity once the transport returns.
-    Waker recv_initial_metadata_ready_waker;
-    // Initial metadata storage for the transport.
-    ClientMetadataHandle client_initial_metadata =
-        GetContext<Arena>()->MakePooled<ClientMetadata>(GetContext<Arena>());
-    // Closure for the transport to call when it's ready.
-    grpc_closure recv_initial_metadata_ready;
-    // Next promise factory to use once we have initial metadata.
-    NextPromiseFactory next_promise_factory;
-  };
-
-  // Call state: transport has returned initial metadata, we're waiting to
-  // re-enter the activity to process it.
-  struct GotInitialMetadata {
-    ClientMetadataHandle client_initial_metadata;
-    NextPromiseFactory next_promise_factory;
-  };
-
-  // Call state: we're sending/receiving messages and processing the filter
-  // stack.
-  struct MessageLoop {
-    PipeReceiver<MessageHandle>* outgoing_messages;
-    ArenaPromise<ServerMetadataHandle> promise;
-  };
-
-  // Call state: promise stack has returned trailing metadata, we're sending it
-  // to the transport to communicate.
-  struct Completing {
-    ServerMetadataHandle server_trailing_metadata;
-    grpc_transport_stream_op_batch send_trailing_metadata;
-    grpc_closure on_complete;
-    bool sent = false;
-    Waker waker;
-  };
-
-  // Call state: server metadata has been communicated to the transport and sent
-  // to the client.
-  // The metadata will be returned down to the server call to tick the
-  // cancellation bit or not on the originating batch.
-  struct Complete {
-    ServerMetadataHandle result;
-  };
+        return Pending{};
+      },
+      [stream = std::move(stream)](ServerMetadataHandle result) {
+        stream->set_finished();
+        return result;
+      });
+}
+#endif
 
-  // Trailing metadata state: we've asked the transport for trailing metadata
-  // and are waiting for it before proceeding.
-  struct WaitingForTrailingMetadata {
-    ClientMetadataHandle result =
-        GetContext<Arena>()->MakePooled<ClientMetadata>(GetContext<Arena>());
-    grpc_transport_stream_op_batch recv_trailing_metadata;
-    grpc_closure recv_trailing_metadata_ready;
-    Waker waker;
+#ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL
+ArenaPromise<ServerMetadataHandle> MakeServerCallPromise(
+    grpc_transport* transport, CallArgs,
+    NextPromiseFactory next_promise_factory) {
+  OrphanablePtr<ConnectedChannelStream> stream(
+      GetContext<Arena>()->New<ConnectedChannelStream>(transport));
+
+  stream->SetStream(static_cast<grpc_stream*>(
+      GetContext<Arena>()->Alloc(transport->vtable->sizeof_stream)));
+  grpc_transport_init_stream(
+      transport, stream->stream(), stream->stream_refcount(),
+      GetContext<CallContext>()->server_call_context()->server_stream_data(),
+      GetContext<Arena>());
+  auto* party = static_cast<Party*>(Activity::current());
+
+  // Arifacts we need for the lifetime of the call.
+  struct CallData {
+    Pipe<MessageHandle> server_to_client;
+    Pipe<MessageHandle> client_to_server;
+    Pipe<ServerMetadataHandle> server_initial_metadata;
+    Latch<ServerMetadataHandle> failure_latch;
+    Latch<grpc_polling_entity> polling_entity_latch;
+    bool sent_initial_metadata = false;
+    bool sent_trailing_metadata = false;
   };
-
-  // We've received trailing metadata from the transport - which indicates reads
-  // are closed.
-  // We convert to an absl::Status here and use that to drive a decision to
-  // cancel the call (on error) or not.
-  struct GotClientHalfClose {
-    absl::Status result;
+  auto* call_data = GetContext<Arena>()->New<CallData>();
+  GetContext<CallFinalization>()->Add(
+      [call_data](const grpc_call_final_info*) { call_data->~CallData(); });
+
+  party->Spawn(
+      "set_polling_entity", call_data->polling_entity_latch.Wait(),
+      [transport,
+       stream = stream->InternalRef()](grpc_polling_entity polling_entity) {
+        grpc_transport_set_pops(transport, stream->stream(), &polling_entity);
+      });
+
+  auto server_to_client_empty =
+      call_data->server_to_client.receiver.AwaitEmpty();
+
+  // Create a promise that will receive client initial metadata, and then run
+  // the main stem of the call (calling next_promise_factory up through the
+  // filters).
+  // Race the main call with failure_latch, allowing us to forcefully complete
+  // the call in the case of a failure.
+  auto recv_initial_metadata_then_run_promise =
+      TrySeq(GetContext<BatchBuilder>()->ReceiveClientInitialMetadata(
+                 stream->batch_target()),
+             [next_promise_factory = std::move(next_promise_factory),
+              server_to_client_empty = std::move(server_to_client_empty),
+              call_data](ClientMetadataHandle client_initial_metadata) {
+               auto call_promise = next_promise_factory(CallArgs{
+                   std::move(client_initial_metadata),
+                   ClientInitialMetadataOutstandingToken::Empty(),
+                   &call_data->polling_entity_latch,
+                   &call_data->server_initial_metadata.sender,
+                   &call_data->client_to_server.receiver,
+                   &call_data->server_to_client.sender,
+               });
+               return Race(call_data->failure_latch.Wait(),
+                           [call_promise = std::move(call_promise),
+                            server_to_client_empty =
+                                std::move(server_to_client_empty)]() mutable
+                           -> Poll<ServerMetadataHandle> {
+                             // TODO(ctiller): this is deeply weird and we need
+                             // to clean this up.
+                             //
+                             // The following few lines check to ensure that
+                             // there's no message currently pending in the
+                             // outgoing message queue, and if (and only if)
+                             // that's true decides to poll the main promise to
+                             // see if there's a result.
+                             //
+                             // This essentially introduces a polling priority
+                             // scheme that makes the current promise structure
+                             // work out the way we want when talking to
+                             // transports.
+                             //
+                             // The problem is that transports are going to need
+                             // to replicate this structure when they convert to
+                             // promises, and that becomes troubling as we'll be
+                             // replicating weird throughout the stack.
+                             //
+                             // Instead we likely need to change the way we're
+                             // composing promises through the stack.
+                             //
+                             // Proposed is to change filters from a promise
+                             // that takes ClientInitialMetadata and returns
+                             // ServerTrailingMetadata with three pipes for
+                             // ServerInitialMetadata and
+                             // ClientToServerMessages, ServerToClientMessages.
+                             // Instead we'll have five pipes, moving
+                             // ClientInitialMetadata and ServerTrailingMetadata
+                             // to pipes that can be intercepted.
+                             //
+                             // The effect of this change will be to cripple the
+                             // things that can be done in a filter (but cripple
+                             // in line with what most filters actually do).
+                             // We'll likely need to add a `CallContext::Cancel`
+                             // to allow filters to cancel a request, but this
+                             // would also have the advantage of centralizing
+                             // our cancellation machinery which seems like an
+                             // additional win - with the net effect that the
+                             // shape of the call gets made explicit at the top
+                             // & bottom of the stack.
+                             //
+                             // There's a small set of filters (retry, this one,
+                             // lame client, clinet channel) that terminate
+                             // stacks and need a richer set of semantics, but
+                             // that ends up being fine because we can spawn
+                             // tasks in parties to handle those edge cases, and
+                             // keep the majority of filters simple: they just
+                             // call InterceptAndMap on a handful of filters at
+                             // call initialization time and then proceed to
+                             // actually filter.
+                             //
+                             // So that's the plan, why isn't it enacted here?
+                             //
+                             // Well, the plan ends up being easy to implement
+                             // in the promise based world (I did a prototype on
+                             // a branch in an afternoon). It's heinous to
+                             // implement in promise_based_filter, and that code
+                             // is load bearing for us at the time of writing.
+                             // It's not worth delaying promises for a further N
+                             // months (N ~ 6) to make that change.
+                             //
+                             // Instead, we'll move forward with this, get
+                             // promise_based_filter out of the picture, and
+                             // then during the mop-up phase for promises tweak
+                             // the compute structure to move to the magical
+                             // five pipes (I'm reminded of an old Onion
+                             // article), and end up in a good happy place.
+                             if (server_to_client_empty().pending()) {
+                               return Pending{};
+                             }
+                             return call_promise();
+                           });
+             });
+
+  // Promise factory that accepts a ServerMetadataHandle, and sends it as the
+  // trailing metadata for this call.
+  auto send_trailing_metadata = [call_data, stream = stream->InternalRef()](
+                                    ServerMetadataHandle
+                                        server_trailing_metadata) {
+    bool is_cancellation =
+        server_trailing_metadata->get(GrpcCallWasCancelled()).value_or(false);
+    return GetContext<BatchBuilder>()->SendServerTrailingMetadata(
+        stream->batch_target(), std::move(server_trailing_metadata),
+        is_cancellation ||
+            !std::exchange(call_data->sent_initial_metadata, true));
   };
 
-  void RecvInitialMetadataReady(absl::Status status) {
-    MutexLock lock(mu());
-    auto& getting = absl::get<GettingInitialMetadata>(call_state_);
-    auto waker = std::move(getting.recv_initial_metadata_ready_waker);
-    if (grpc_call_trace.enabled()) {
-      gpr_log(GPR_DEBUG, "%sGOT INITIAL METADATA: err=%s %s",
-              waker.ActivityDebugTag().c_str(), status.ToString().c_str(),
-              getting.client_initial_metadata->DebugString().c_str());
-    }
-    GotInitialMetadata got{std::move(getting.client_initial_metadata),
-                           std::move(getting.next_promise_factory)};
-    call_state_.emplace<GotInitialMetadata>(std::move(got));
-    waker.Wakeup();
-  }
-
-  void SendTrailingMetadataDone(absl::Status result) {
-    MutexLock lock(mu());
-    auto& completing = absl::get<Completing>(call_state_);
-    auto md = std::move(completing.server_trailing_metadata);
-    auto waker = std::move(completing.waker);
-    if (grpc_call_trace.enabled()) {
-      gpr_log(GPR_DEBUG, "%sSEND TRAILING METADATA DONE: err=%s sent=%s %s",
-              waker.ActivityDebugTag().c_str(), result.ToString().c_str(),
-              completing.sent ? "true" : "false", md->DebugString().c_str());
-    }
-    md->Set(GrpcStatusFromWire(), completing.sent);
-    if (!result.ok()) {
-      md->Clear();
-      md->Set(GrpcStatusMetadata(),
-              static_cast<grpc_status_code>(result.code()));
-      md->Set(GrpcMessageMetadata(), Slice::FromCopiedString(result.message()));
-      md->Set(GrpcStatusFromWire(), false);
-    }
-    call_state_.emplace<Complete>(Complete{std::move(md)});
-    waker.Wakeup();
-  }
-
-  std::string ActiveOpsString() const override
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
-    std::vector<std::string> ops;
-    ops.push_back(absl::StrCat(
-        "call_state:",
-        Match(
-            call_state_,
-            [](const absl::monostate&) { return "absl::monostate"; },
-            [](const GettingInitialMetadata&) { return "GETTING"; },
-            [](const GotInitialMetadata&) { return "GOT"; },
-            [](const MessageLoop&) { return "RUNNING"; },
-            [](const Completing&) { return "COMPLETING"; },
-            [](const Complete&) { return "COMPLETE"; })));
-    ops.push_back(
-        absl::StrCat("client_trailing_metadata_state:",
-                     Match(
-                         client_trailing_metadata_state_,
-                         [](const absl::monostate&) -> std::string {
-                           return "absl::monostate";
-                         },
-                         [](const WaitingForTrailingMetadata&) -> std::string {
-                           return "WAITING";
-                         },
-                         [](const GotClientHalfClose& got) -> std::string {
-                           return absl::StrCat("GOT:", got.result.ToString());
-                         })));
-    // Send initial metadata
-    ops.push_back(absl::StrCat(
-        "server_initial_metadata_state:",
-        Match(
-            server_initial_metadata_,
-            [](const absl::monostate&) { return "absl::monostate"; },
-            [](const PipeReceiverNextType<ServerMetadataHandle>&) {
-              return "WAITING";
-            },
-            [](const ServerMetadataHandle&) { return "GOT"; })));
-    // Send message
-    std::string send_message_state = SendMessageString();
-    if (send_message_state != "WAITING") {
-      ops.push_back(absl::StrCat("send_message:", send_message_state));
-    }
-    // Receive message
-    std::string recv_message_state = RecvMessageString();
-    if (recv_message_state != "IDLE") {
-      ops.push_back(absl::StrCat("recv_message:", recv_message_state));
-    }
-    return absl::StrJoin(ops, " ");
-  }
+  // Runs the receive message loop, either until all the messages
+  // are received or the server call is complete.
+  party->Spawn(
+      "recv_messages",
+      Race(
+          Map(stream->WaitFinished(), [](Empty) { return absl::OkStatus(); }),
+          Map(stream->RecvMessages(&call_data->client_to_server.sender, true),
+              [failure_latch = &call_data->failure_latch](absl::Status status) {
+                if (!status.ok() && !failure_latch->is_set()) {
+                  failure_latch->Set(ServerMetadataFromStatus(status));
+                }
+                return status;
+              })),
+      [](absl::Status) {});
+
+  // Run a promise that will send initial metadata (if that pipe sends some).
+  // And then run the send message loop until that completes.
+
+  auto send_initial_metadata = Seq(
+      Race(Map(stream->WaitFinished(),
+               [](Empty) { return NextResult<ServerMetadataHandle>(true); }),
+           call_data->server_initial_metadata.receiver.Next()),
+      [call_data, stream = stream->InternalRef()](
+          NextResult<ServerMetadataHandle> next_result) mutable {
+        auto md = !call_data->sent_initial_metadata && next_result.has_value()
+                      ? std::move(next_result.value())
+                      : nullptr;
+        if (md != nullptr) {
+          call_data->sent_initial_metadata = true;
+          auto* party = static_cast<Party*>(Activity::current());
+          party->Spawn("connected/send_initial_metadata",
+                       GetContext<BatchBuilder>()->SendServerInitialMetadata(
+                           stream->batch_target(), std::move(md)),
+                       [](absl::Status) {});
+          return Immediate(absl::OkStatus());
+        }
+        return Immediate(absl::CancelledError());
+      });
+  party->Spawn(
+      "send_initial_metadata_then_messages",
+      Race(Map(stream->WaitFinished(), [](Empty) { return absl::OkStatus(); }),
+           TrySeq(std::move(send_initial_metadata),
+                  stream->SendMessages(&call_data->server_to_client.receiver))),
+      [](absl::Status) {});
+
+  // Spawn a job to fetch the "client trailing metadata" - if this is OK then
+  // it's client done, otherwise it's a signal of cancellation from the client
+  // which we'll use failure_latch to signal.
+
+  party->Spawn(
+      "recv_trailing_metadata",
+      Seq(GetContext<BatchBuilder>()->ReceiveClientTrailingMetadata(
+              stream->batch_target()),
+          [failure_latch = &call_data->failure_latch](
+              absl::StatusOr<ClientMetadataHandle> status) mutable {
+            if (grpc_call_trace.enabled()) {
+              gpr_log(
+                  GPR_DEBUG,
+                  "%s[connected] Got trailing metadata; status=%s metadata=%s",
+                  Activity::current()->DebugTag().c_str(),
+                  status.status().ToString().c_str(),
+                  status.ok() ? (*status)->DebugString().c_str() : "<none>");
+            }
+            ClientMetadataHandle trailing_metadata;
+            if (status.ok()) {
+              trailing_metadata = std::move(*status);
+            } else {
+              trailing_metadata =
+                  GetContext<Arena>()->MakePooled<ClientMetadata>(
+                      GetContext<Arena>());
+              grpc_status_code status_code = GRPC_STATUS_UNKNOWN;
+              std::string message;
+              grpc_error_get_status(status.status(), Timestamp::InfFuture(),
+                                    &status_code, &message, nullptr, nullptr);
+              trailing_metadata->Set(GrpcStatusMetadata(), status_code);
+              trailing_metadata->Set(GrpcMessageMetadata(),
+                                     Slice::FromCopiedString(message));
+            }
+            if (trailing_metadata->get(GrpcStatusMetadata())
+                    .value_or(GRPC_STATUS_UNKNOWN) != GRPC_STATUS_OK) {
+              if (!failure_latch->is_set()) {
+                failure_latch->Set(std::move(trailing_metadata));
+              }
+            }
+            return Empty{};
+          }),
+      [](Empty) {});
 
-  void SendInitialMetadataDone() {}
+  // Finally assemble the main call promise:
+  // Receive initial metadata from the client and start the promise up the
+  // filter stack.
+  // Upon completion, send trailing metadata to the client and then return it
+  // (allowing the call code to decide on what signalling to give the
+  // application).
 
-  void RecvTrailingMetadataReady(absl::Status error) {
-    MutexLock lock(mu());
-    auto& state =
-        absl::get<WaitingForTrailingMetadata>(client_trailing_metadata_state_);
-    if (grpc_call_trace.enabled()) {
-      gpr_log(GPR_INFO,
-              "%sRecvTrailingMetadataReady: error:%s metadata:%s state:%s",
-              state.waker.ActivityDebugTag().c_str(), error.ToString().c_str(),
-              state.result->DebugString().c_str(), ActiveOpsString().c_str());
+  struct CleanupPollingEntityLatch {
+    void operator()(Latch<grpc_polling_entity>* latch) {
+      if (!latch->is_set()) latch->Set(grpc_polling_entity());
     }
-    auto waker = std::move(state.waker);
-    ServerMetadataHandle result = std::move(state.result);
-    if (error.ok()) {
-      auto* message = result->get_pointer(GrpcMessageMetadata());
-      error = absl::Status(
-          static_cast<absl::StatusCode>(
-              result->get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN)),
-          message == nullptr ? "" : message->as_string_view());
+  };
+  auto cleanup_polling_entity_latch =
+      std::unique_ptr<Latch<grpc_polling_entity>, CleanupPollingEntityLatch>(
+          &call_data->polling_entity_latch);
+  struct CleanupSendInitialMetadata {
+    void operator()(CallData* call_data) {
+      call_data->server_initial_metadata.receiver.CloseWithError();
     }
-    client_trailing_metadata_state_.emplace<GotClientHalfClose>(
-        GotClientHalfClose{error});
-    waker.Wakeup();
-  }
-
-  struct Pipes {
-    Pipe<MessageHandle> server_to_client;
-    Pipe<MessageHandle> client_to_server;
-    Pipe<ServerMetadataHandle> server_initial_metadata;
   };
-
-  using CallState =
-      absl::variant<absl::monostate, GettingInitialMetadata, GotInitialMetadata,
-                    MessageLoop, Completing, Complete>;
-  CallState call_state_ ABSL_GUARDED_BY(mu()) = absl::monostate{};
-  using ClientTrailingMetadataState =
-      absl::variant<absl::monostate, WaitingForTrailingMetadata,
-                    GotClientHalfClose>;
-  ClientTrailingMetadataState client_trailing_metadata_state_
-      ABSL_GUARDED_BY(mu()) = absl::monostate{};
-  absl::variant<absl::monostate, PipeReceiverNextType<ServerMetadataHandle>,
-                ServerMetadataHandle>
-      ABSL_GUARDED_BY(mu()) server_initial_metadata_ = absl::monostate{};
-  PipeSender<MessageHandle>* incoming_messages_ = nullptr;
-  grpc_transport_stream_op_batch send_initial_metadata_;
-  grpc_closure send_initial_metadata_done_ =
-      MakeMemberClosure<ServerStream, &ServerStream::SendInitialMetadataDone>(
-          this);
-  Pipes pipes_ ABSL_GUARDED_BY(mu());
-};
-
-class ServerConnectedCallPromise {
- public:
-  ServerConnectedCallPromise(grpc_transport* transport,
-                             NextPromiseFactory next_promise_factory)
-      : impl_(GetContext<Arena>()->New<ServerStream>(
-            transport, std::move(next_promise_factory))) {}
-
-  ServerConnectedCallPromise(const ServerConnectedCallPromise&) = delete;
-  ServerConnectedCallPromise& operator=(const ServerConnectedCallPromise&) =
-      delete;
-  ServerConnectedCallPromise(ServerConnectedCallPromise&& other) noexcept
-      : impl_(std::exchange(other.impl_, nullptr)) {}
-  ServerConnectedCallPromise& operator=(
-      ServerConnectedCallPromise&& other) noexcept {
-    impl_ = std::move(other.impl_);
-    return *this;
-  }
-
-  static ArenaPromise<ServerMetadataHandle> Make(grpc_transport* transport,
-                                                 CallArgs,
-                                                 NextPromiseFactory next) {
-    return ServerConnectedCallPromise(transport, std::move(next));
-  }
-
-  Poll<ServerMetadataHandle> operator()() { return impl_->PollOnce(); }
-
- private:
-  OrphanablePtr<ServerStream> impl_;
-};
+  auto cleanup_send_initial_metadata =
+      std::unique_ptr<CallData, CleanupSendInitialMetadata>(call_data);
+
+  return Map(
+      Seq(std::move(recv_initial_metadata_then_run_promise),
+          std::move(send_trailing_metadata)),
+      [cleanup_polling_entity_latch = std::move(cleanup_polling_entity_latch),
+       cleanup_send_initial_metadata = std::move(cleanup_send_initial_metadata),
+       stream = std::move(stream)](ServerMetadataHandle md) {
+        stream->set_finished();
+        return md;
+      });
+}
 #endif
 
 template <ArenaPromise<ServerMetadataHandle> (*make_call_promise)(
     grpc_transport*, CallArgs, NextPromiseFactory)>
 grpc_channel_filter MakeConnectedFilter() {
   // Create a vtable that contains both the legacy call methods (for filter
-  // stack based calls) and the new promise based method for creating promise
-  // based calls (the latter iff make_call_promise != nullptr).
-  // In this way the filter can be inserted into either kind of channel stack,
-  // and only if all the filters in the stack are promise based will the call
-  // be promise based.
+  // stack based calls) and the new promise based method for creating
+  // promise based calls (the latter iff make_call_promise != nullptr). In
+  // this way the filter can be inserted into either kind of channel stack,
+  // and only if all the filters in the stack are promise based will the
+  // call be promise based.
   auto make_call_wrapper = +[](grpc_channel_element* elem, CallArgs call_args,
                                NextPromiseFactory next) {
     grpc_transport* transport =
@@ -1370,12 +872,11 @@ grpc_channel_filter MakeConnectedFilter() {
       sizeof(channel_data),
       connected_channel_init_channel_elem,
       +[](grpc_channel_stack* channel_stack, grpc_channel_element* elem) {
-        // HACK(ctiller): increase call stack size for the channel to make space
-        // for channel data. We need a cleaner (but performant) way to do this,
-        // and I'm not sure what that is yet.
-        // This is only "safe" because call stacks place no additional data
-        // after the last call element, and the last call element MUST be the
-        // connected channel.
+        // HACK(ctiller): increase call stack size for the channel to make
+        // space for channel data. We need a cleaner (but performant) way to
+        // do this, and I'm not sure what that is yet. This is only "safe"
+        // because call stacks place no additional data after the last call
+        // element, and the last call element MUST be the connected channel.
         channel_stack->call_stack_size += grpc_transport_stream_size(
             static_cast<channel_data*>(elem->channel_data)->transport);
       },
@@ -1395,7 +896,7 @@ const grpc_channel_filter kPromiseBasedTransportFilter =
 
 #ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_CLIENT_CALL
 const grpc_channel_filter kClientEmulatedFilter =
-    MakeConnectedFilter<ClientConnectedCallPromise::Make>();
+    MakeConnectedFilter<MakeClientCallPromise>();
 #else
 const grpc_channel_filter kClientEmulatedFilter =
     MakeConnectedFilter<nullptr>();
@@ -1403,7 +904,7 @@ const grpc_channel_filter kClientEmulatedFilter =
 
 #ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL
 const grpc_channel_filter kServerEmulatedFilter =
-    MakeConnectedFilter<ServerConnectedCallPromise::Make>();
+    MakeConnectedFilter<MakeServerCallPromise>();
 #else
 const grpc_channel_filter kServerEmulatedFilter =
     MakeConnectedFilter<nullptr>();
@@ -1419,20 +920,20 @@ bool grpc_add_connected_filter(grpc_core::ChannelStackBuilder* builder) {
   // We can't know promise based call or not here (that decision needs the
   // collaboration of all of the filters on the channel, and we don't want
   // ordering constraints on when we add filters).
-  // We can know if this results in a promise based call how we'll create our
-  // promise (if indeed we can), and so that is the choice made here.
+  // We can know if this results in a promise based call how we'll create
+  // our promise (if indeed we can), and so that is the choice made here.
   if (t->vtable->make_call_promise != nullptr) {
-    // Option 1, and our ideal: the transport supports promise based calls, and
-    // so we simply use the transport directly.
+    // Option 1, and our ideal: the transport supports promise based calls,
+    // and so we simply use the transport directly.
     builder->AppendFilter(&grpc_core::kPromiseBasedTransportFilter);
   } else if (grpc_channel_stack_type_is_client(builder->channel_stack_type())) {
-    // Option 2: the transport does not support promise based calls, but we're
-    // on the client and so we have an implementation that we can use to convert
-    // to batches.
+    // Option 2: the transport does not support promise based calls, but
+    // we're on the client and so we have an implementation that we can use
+    // to convert to batches.
     builder->AppendFilter(&grpc_core::kClientEmulatedFilter);
   } else {
-    // Option 3: the transport does not support promise based calls, and we're
-    // on the server so we use the server filter.
+    // Option 3: the transport does not support promise based calls, and
+    // we're on the server so we use the server filter.
     builder->AppendFilter(&grpc_core::kServerEmulatedFilter);
   }
   return true;