grpc 1.62.0 → 1.64.0

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

@@ -19,8 +19,6 @@
 // promise-style. Most of this will be removed once the promises conversion is
 // completed.
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 #include <stdlib.h>
 
@@ -33,6 +31,7 @@
 
 #include "absl/container/inlined_vector.h"
 #include "absl/functional/function_ref.h"
+#include "absl/log/check.h"
 #include "absl/meta/type_traits.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
@@ -41,15 +40,17 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.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/event_engine/default_event_engine.h"  // IWYU pragma: keep
-#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/event_engine/default_event_engine.h"
+#include "src/core/lib/event_engine/event_engine_context.h"  // IWYU pragma: keep
 #include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -74,24 +75,64 @@
 
 namespace grpc_core {
 
+// HACK: If a filter has this type as a base class it will be skipped in
+// v3 filter stacks. This is a temporary measure to allow the v3 filter stack
+// to be bought up whilst some tests inadvertently rely on hard to convert
+// filters.
+class HackyHackyHackySkipInV3FilterStacks {};
+
 class ChannelFilter {
  public:
   class Args {
    public:
     Args() : Args(nullptr, nullptr) {}
-    explicit Args(grpc_channel_stack* channel_stack,
-                  grpc_channel_element* channel_element)
-        : channel_stack_(channel_stack), channel_element_(channel_element) {}
+    Args(grpc_channel_stack* channel_stack,
+         grpc_channel_element* channel_element)
+        : impl_(ChannelStackBased{channel_stack, channel_element}) {}
+    // While we're moving to call-v3 we need to have access to
+    // grpc_channel_stack & friends here. That means that we can't rely on this
+    // type signature from interception_chain.h, which means that we need a way
+    // of constructing this object without naming it ===> implicit construction.
+    // TODO(ctiller): remove this once we're fully on call-v3
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    Args(size_t instance_id) : impl_(V3Based{instance_id}) {}
+
+    ABSL_DEPRECATED("Direct access to channel stack is deprecated")
+    grpc_channel_stack* channel_stack() const {
+      return absl::get<ChannelStackBased>(impl_).channel_stack;
+    }
 
-    grpc_channel_stack* channel_stack() const { return channel_stack_; }
-    grpc_channel_element* uninitialized_channel_element() {
-      return channel_element_;
+    // Get the instance id of this filter.
+    // This id is unique amongst all filters /of the same type/ and densely
+    // packed (starting at 0) for a given channel stack instantiation.
+    // eg. for a stack with filter types A B C A B D A the instance ids would be
+    // 0 0 0 1 1 0 2.
+    // This is useful for filters that need to store per-instance data in a
+    // parallel data structure.
+    size_t instance_id() const {
+      return Match(
+          impl_,
+          [](const ChannelStackBased& cs) {
+            return grpc_channel_stack_filter_instance_number(
+                cs.channel_stack, cs.channel_element);
+          },
+          [](const V3Based& v3) { return v3.instance_id; });
     }
 
    private:
     friend class ChannelFilter;
-    grpc_channel_stack* channel_stack_;
-    grpc_channel_element* channel_element_;
+
+    struct ChannelStackBased {
+      grpc_channel_stack* channel_stack;
+      grpc_channel_element* channel_element;
+    };
+
+    struct V3Based {
+      size_t instance_id;
+    };
+
+    using Impl = absl::variant<ChannelStackBased, V3Based>;
+    Impl impl_;
   };
 
   // Perform post-initialization step (if any).
@@ -312,7 +353,7 @@ auto MapResult(const NoInterceptor*, Promise x, void*) {
 template <typename Promise, typename Derived>
 auto MapResult(absl::Status (Derived::Call::*fn)(ServerMetadata&), Promise x,
                FilterCallData<Derived>* call_data) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerTrailingMetadata);
+  DCHECK(fn == &Derived::Call::OnServerTrailingMetadata);
   return Map(std::move(x), [call_data](ServerMetadataHandle md) {
     auto status = call_data->call.OnServerTrailingMetadata(*md);
     if (!status.ok()) return ServerMetadataFromStatus(status);
@@ -323,7 +364,7 @@ auto MapResult(absl::Status (Derived::Call::*fn)(ServerMetadata&), Promise x,
 template <typename Promise, typename Derived>
 auto MapResult(void (Derived::Call::*fn)(ServerMetadata&), Promise x,
                FilterCallData<Derived>* call_data) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerTrailingMetadata);
+  DCHECK(fn == &Derived::Call::OnServerTrailingMetadata);
   return Map(std::move(x), [call_data](ServerMetadataHandle md) {
     call_data->call.OnServerTrailingMetadata(*md);
     return md;
@@ -333,7 +374,7 @@ auto MapResult(void (Derived::Call::*fn)(ServerMetadata&), Promise x,
 template <typename Promise, typename Derived>
 auto MapResult(void (Derived::Call::*fn)(ServerMetadata&, Derived*), Promise x,
                FilterCallData<Derived>* call_data) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerTrailingMetadata);
+  DCHECK(fn == &Derived::Call::OnServerTrailingMetadata);
   return Map(std::move(x), [call_data](ServerMetadataHandle md) {
     call_data->call.OnServerTrailingMetadata(*md, call_data->channel);
     return md;
@@ -446,7 +487,7 @@ template <typename Interceptor, typename Derived>
 auto RunCall(Interceptor interceptor, CallArgs call_args,
              NextPromiseFactory next_promise_factory,
              FilterCallData<Derived>* call_data) {
-  GPR_DEBUG_ASSERT(interceptor == &Derived::Call::OnClientInitialMetadata);
+  DCHECK(interceptor == &Derived::Call::OnClientInitialMetadata);
   return RunCallImpl<Interceptor, Derived>::Run(
       std::move(call_args), std::move(next_promise_factory), call_data);
 }
@@ -458,7 +499,7 @@ template <typename Derived>
 inline void InterceptClientToServerMessage(
     ServerMetadataHandle (Derived::Call::*fn)(const Message&),
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnClientToServerMessage);
+  DCHECK(fn == &Derived::Call::OnClientToServerMessage);
   call_args.client_to_server_messages->InterceptAndMap(
       [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
         auto return_md = call_data->call.OnClientToServerMessage(*msg);
@@ -473,7 +514,7 @@ template <typename Derived>
 inline void InterceptClientToServerMessage(
     ServerMetadataHandle (Derived::Call::*fn)(const Message&, Derived*),
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnClientToServerMessage);
+  DCHECK(fn == &Derived::Call::OnClientToServerMessage);
   call_args.client_to_server_messages->InterceptAndMap(
       [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
         auto return_md =
@@ -489,7 +530,7 @@ template <typename Derived>
 inline void InterceptClientToServerMessage(
     MessageHandle (Derived::Call::*fn)(MessageHandle, Derived*),
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnClientToServerMessage);
+  DCHECK(fn == &Derived::Call::OnClientToServerMessage);
   call_args.client_to_server_messages->InterceptAndMap(
       [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
         return call_data->call.OnClientToServerMessage(std::move(msg),
@@ -501,7 +542,7 @@ template <typename Derived>
 inline void InterceptClientToServerMessage(
     absl::StatusOr<MessageHandle> (Derived::Call::*fn)(MessageHandle, Derived*),
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnClientToServerMessage);
+  DCHECK(fn == &Derived::Call::OnClientToServerMessage);
   call_args.client_to_server_messages->InterceptAndMap(
       [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
         auto r = call_data->call.OnClientToServerMessage(std::move(msg),
@@ -519,13 +560,14 @@ inline void InterceptClientToServerMessage(const NoInterceptor*, void*, void*,
 template <typename Derived>
 inline void InterceptClientToServerMessage(
     ServerMetadataHandle (Derived::Call::*fn)(const Message&),
-    typename Derived::Call* call, Derived*, CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnClientToServerMessage);
+    typename Derived::Call* call, Derived*, PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnClientToServerMessage);
   call_spine->client_to_server_messages().receiver.InterceptAndMap(
       [call, call_spine](MessageHandle msg) -> absl::optional<MessageHandle> {
         auto return_md = call->OnClientToServerMessage(*msg);
         if (return_md == nullptr) return std::move(msg);
-        return call_spine->Cancel(std::move(return_md));
+        call_spine->PushServerTrailingMetadata(std::move(return_md));
+        return absl::nullopt;
       });
 }
 
@@ -533,14 +575,15 @@ template <typename Derived>
 inline void InterceptClientToServerMessage(
     ServerMetadataHandle (Derived::Call::*fn)(const Message&, Derived*),
     typename Derived::Call* call, Derived* channel,
-    CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnClientToServerMessage);
+    PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnClientToServerMessage);
   call_spine->client_to_server_messages().receiver.InterceptAndMap(
       [call, call_spine,
        channel](MessageHandle msg) -> absl::optional<MessageHandle> {
         auto return_md = call->OnClientToServerMessage(*msg, channel);
         if (return_md == nullptr) return std::move(msg);
-        return call_spine->Cancel(std::move(return_md));
+        call_spine->PushServerTrailingMetadata(std::move(return_md));
+        return absl::nullopt;
       });
 }
 
@@ -548,8 +591,8 @@ template <typename Derived>
 inline void InterceptClientToServerMessage(
     MessageHandle (Derived::Call::*fn)(MessageHandle, Derived*),
     typename Derived::Call* call, Derived* channel,
-    CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnClientToServerMessage);
+    PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnClientToServerMessage);
   call_spine->client_to_server_messages().receiver.InterceptAndMap(
       [call, channel](MessageHandle msg) {
         return call->OnClientToServerMessage(std::move(msg), channel);
@@ -560,25 +603,27 @@ template <typename Derived>
 inline void InterceptClientToServerMessage(
     absl::StatusOr<MessageHandle> (Derived::Call::*fn)(MessageHandle, Derived*),
     typename Derived::Call* call, Derived* channel,
-    CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnClientToServerMessage);
+    PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnClientToServerMessage);
   call_spine->client_to_server_messages().receiver.InterceptAndMap(
       [call, call_spine,
        channel](MessageHandle msg) -> absl::optional<MessageHandle> {
         auto r = call->OnClientToServerMessage(std::move(msg), channel);
         if (r.ok()) return std::move(*r);
-        return call_spine->Cancel(ServerMetadataFromStatus(r.status()));
+        call_spine->PushServerTrailingMetadata(
+            ServerMetadataFromStatus(r.status()));
+        return absl::nullopt;
       });
 }
 
 inline void InterceptClientInitialMetadata(const NoInterceptor*, void*, void*,
-                                           CallSpineInterface*) {}
+                                           PipeBasedCallSpine*) {}
 
 template <typename Derived>
 inline void InterceptClientInitialMetadata(
     void (Derived::Call::*fn)(ClientMetadata& md), typename Derived::Call* call,
-    Derived*, CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnClientInitialMetadata);
+    Derived*, PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnClientInitialMetadata);
   call_spine->client_initial_metadata().receiver.InterceptAndMap(
       [call](ClientMetadataHandle md) {
         call->OnClientInitialMetadata(*md);
@@ -590,8 +635,8 @@ template <typename Derived>
 inline void InterceptClientInitialMetadata(
     void (Derived::Call::*fn)(ClientMetadata& md, Derived* channel),
     typename Derived::Call* call, Derived* channel,
-    CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnClientInitialMetadata);
+    PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnClientInitialMetadata);
   call_spine->client_initial_metadata().receiver.InterceptAndMap(
       [call, channel](ClientMetadataHandle md) {
         call->OnClientInitialMetadata(*md, channel);
@@ -602,14 +647,15 @@ inline void InterceptClientInitialMetadata(
 template <typename Derived>
 inline void InterceptClientInitialMetadata(
     ServerMetadataHandle (Derived::Call::*fn)(ClientMetadata& md),
-    typename Derived::Call* call, Derived*, CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnClientInitialMetadata);
+    typename Derived::Call* call, Derived*, PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnClientInitialMetadata);
   call_spine->client_initial_metadata().receiver.InterceptAndMap(
       [call_spine,
        call](ClientMetadataHandle md) -> absl::optional<ClientMetadataHandle> {
         auto return_md = call->OnClientInitialMetadata(*md);
         if (return_md == nullptr) return std::move(md);
-        return call_spine->Cancel(std::move(return_md));
+        call_spine->PushServerTrailingMetadata(std::move(return_md));
+        return absl::nullopt;
       });
 }
 
@@ -618,28 +664,31 @@ inline void InterceptClientInitialMetadata(
     ServerMetadataHandle (Derived::Call::*fn)(ClientMetadata& md,
                                               Derived* channel),
     typename Derived::Call* call, Derived* channel,
-    CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnClientInitialMetadata);
+    PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnClientInitialMetadata);
   call_spine->client_initial_metadata().receiver.InterceptAndMap(
       [call_spine, call, channel](
           ClientMetadataHandle md) -> absl::optional<ClientMetadataHandle> {
         auto return_md = call->OnClientInitialMetadata(*md, channel);
         if (return_md == nullptr) return std::move(md);
-        return call_spine->Cancel(std::move(return_md));
+        call_spine->PushServerTrailingMetadata(std::move(return_md));
+        return absl::nullopt;
       });
 }
 
 template <typename Derived>
 inline void InterceptClientInitialMetadata(
     absl::Status (Derived::Call::*fn)(ClientMetadata& md),
-    typename Derived::Call* call, Derived*, CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnClientInitialMetadata);
+    typename Derived::Call* call, Derived*, PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnClientInitialMetadata);
   call_spine->client_initial_metadata().receiver.InterceptAndMap(
       [call_spine,
        call](ClientMetadataHandle md) -> absl::optional<ClientMetadataHandle> {
         auto status = call->OnClientInitialMetadata(*md);
         if (status.ok()) return std::move(md);
-        return call_spine->Cancel(ServerMetadataFromStatus(status));
+        call_spine->PushServerTrailingMetadata(
+            ServerMetadataFromStatus(status));
+        return absl::nullopt;
       });
 }
 
@@ -647,14 +696,16 @@ template <typename Derived>
 inline void InterceptClientInitialMetadata(
     absl::Status (Derived::Call::*fn)(ClientMetadata& md, Derived* channel),
     typename Derived::Call* call, Derived* channel,
-    CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnClientInitialMetadata);
+    PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnClientInitialMetadata);
   call_spine->client_initial_metadata().receiver.InterceptAndMap(
       [call_spine, call, channel](
           ClientMetadataHandle md) -> absl::optional<ClientMetadataHandle> {
         auto status = call->OnClientInitialMetadata(*md, channel);
         if (status.ok()) return std::move(md);
-        return call_spine->Cancel(ServerMetadataFromStatus(status));
+        call_spine->PushServerTrailingMetadata(
+            ServerMetadataFromStatus(status));
+        return absl::nullopt;
       });
 }
 
@@ -666,8 +717,8 @@ absl::void_t<decltype(StatusCast<ServerMetadataHandle>(
 InterceptClientInitialMetadata(Promise (Derived::Call::*promise_factory)(
                                    ClientMetadata& md, Derived* channel),
                                typename Derived::Call* call, Derived* channel,
-                               CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(promise_factory == &Derived::Call::OnClientInitialMetadata);
+                               PipeBasedCallSpine* call_spine) {
+  DCHECK(promise_factory == &Derived::Call::OnClientInitialMetadata);
   call_spine->client_initial_metadata().receiver.InterceptAndMap(
       [call, call_spine, channel](ClientMetadataHandle md) {
         ClientMetadata& md_ref = *md;
@@ -676,8 +727,9 @@ InterceptClientInitialMetadata(Promise (Derived::Call::*promise_factory)(
                     call_spine](PromiseResult<Promise> status) mutable
                    -> absl::optional<ClientMetadataHandle> {
                      if (IsStatusOk(status)) return std::move(md);
-                     return call_spine->Cancel(
+                     call_spine->PushServerTrailingMetadata(
                          StatusCast<ServerMetadataHandle>(std::move(status)));
+                     return absl::nullopt;
                    });
       });
 }
@@ -690,7 +742,7 @@ template <typename Derived>
 inline void InterceptServerInitialMetadata(
     void (Derived::Call::*fn)(ServerMetadata&),
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerInitialMetadata);
+  DCHECK(fn == &Derived::Call::OnServerInitialMetadata);
   call_args.server_initial_metadata->InterceptAndMap(
       [call_data](ServerMetadataHandle md) {
         call_data->call.OnServerInitialMetadata(*md);
@@ -702,7 +754,7 @@ template <typename Derived>
 inline void InterceptServerInitialMetadata(
     absl::Status (Derived::Call::*fn)(ServerMetadata&),
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerInitialMetadata);
+  DCHECK(fn == &Derived::Call::OnServerInitialMetadata);
   call_args.server_initial_metadata->InterceptAndMap(
       [call_data](
           ServerMetadataHandle md) -> absl::optional<ServerMetadataHandle> {
@@ -719,7 +771,7 @@ template <typename Derived>
 inline void InterceptServerInitialMetadata(
     void (Derived::Call::*fn)(ServerMetadata&, Derived*),
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerInitialMetadata);
+  DCHECK(fn == &Derived::Call::OnServerInitialMetadata);
   call_args.server_initial_metadata->InterceptAndMap(
       [call_data](ServerMetadataHandle md) {
         call_data->call.OnServerInitialMetadata(*md, call_data->channel);
@@ -731,7 +783,7 @@ template <typename Derived>
 inline void InterceptServerInitialMetadata(
     absl::Status (Derived::Call::*fn)(ServerMetadata&, Derived*),
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerInitialMetadata);
+  DCHECK(fn == &Derived::Call::OnServerInitialMetadata);
   call_args.server_initial_metadata->InterceptAndMap(
       [call_data](
           ServerMetadataHandle md) -> absl::optional<ServerMetadataHandle> {
@@ -751,8 +803,8 @@ inline void InterceptServerInitialMetadata(const NoInterceptor*, void*, void*,
 template <typename Derived>
 inline void InterceptServerInitialMetadata(
     void (Derived::Call::*fn)(ServerMetadata&), typename Derived::Call* call,
-    Derived*, CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerInitialMetadata);
+    Derived*, PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnServerInitialMetadata);
   call_spine->server_initial_metadata().sender.InterceptAndMap(
       [call](ServerMetadataHandle md) {
         call->OnServerInitialMetadata(*md);
@@ -763,14 +815,16 @@ inline void InterceptServerInitialMetadata(
 template <typename Derived>
 inline void InterceptServerInitialMetadata(
     absl::Status (Derived::Call::*fn)(ServerMetadata&),
-    typename Derived::Call* call, Derived*, CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerInitialMetadata);
+    typename Derived::Call* call, Derived*, PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnServerInitialMetadata);
   call_spine->server_initial_metadata().sender.InterceptAndMap(
       [call, call_spine](
           ServerMetadataHandle md) -> absl::optional<ServerMetadataHandle> {
         auto status = call->OnServerInitialMetadata(*md);
         if (status.ok()) return std::move(md);
-        return call_spine->Cancel(ServerMetadataFromStatus(status));
+        call_spine->PushServerTrailingMetadata(
+            ServerMetadataFromStatus(status));
+        return absl::nullopt;
       });
 }
 
@@ -778,8 +832,8 @@ template <typename Derived>
 inline void InterceptServerInitialMetadata(
     void (Derived::Call::*fn)(ServerMetadata&, Derived*),
     typename Derived::Call* call, Derived* channel,
-    CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerInitialMetadata);
+    PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnServerInitialMetadata);
   call_spine->server_initial_metadata().sender.InterceptAndMap(
       [call, channel](ServerMetadataHandle md) {
         call->OnServerInitialMetadata(*md, channel);
@@ -791,14 +845,16 @@ template <typename Derived>
 inline void InterceptServerInitialMetadata(
     absl::Status (Derived::Call::*fn)(ServerMetadata&, Derived*),
     typename Derived::Call* call, Derived* channel,
-    CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerInitialMetadata);
+    PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnServerInitialMetadata);
   call_spine->server_initial_metadata().sender.InterceptAndMap(
       [call, call_spine, channel](
           ServerMetadataHandle md) -> absl::optional<ServerMetadataHandle> {
         auto status = call->OnServerInitialMetadata(*md, channel);
         if (status.ok()) return std::move(md);
-        return call_spine->Cancel(ServerMetadataFromStatus(status));
+        call_spine->PullServerTrailingMetadata(
+            ServerMetadataFromStatus(status));
+        return absl::nullopt;
       });
 }
 
@@ -809,7 +865,7 @@ template <typename Derived>
 inline void InterceptServerToClientMessage(
     ServerMetadataHandle (Derived::Call::*fn)(const Message&),
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerToClientMessage);
+  DCHECK(fn == &Derived::Call::OnServerToClientMessage);
   call_args.server_to_client_messages->InterceptAndMap(
       [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
         auto return_md = call_data->call.OnServerToClientMessage(*msg);
@@ -824,7 +880,7 @@ template <typename Derived>
 inline void InterceptServerToClientMessage(
     ServerMetadataHandle (Derived::Call::*fn)(const Message&, Derived*),
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerToClientMessage);
+  DCHECK(fn == &Derived::Call::OnServerToClientMessage);
   call_args.server_to_client_messages->InterceptAndMap(
       [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
         auto return_md =
@@ -840,7 +896,7 @@ template <typename Derived>
 inline void InterceptServerToClientMessage(
     MessageHandle (Derived::Call::*fn)(MessageHandle, Derived*),
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerToClientMessage);
+  DCHECK(fn == &Derived::Call::OnServerToClientMessage);
   call_args.server_to_client_messages->InterceptAndMap(
       [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
         return call_data->call.OnServerToClientMessage(std::move(msg),
@@ -852,7 +908,7 @@ template <typename Derived>
 inline void InterceptServerToClientMessage(
     absl::StatusOr<MessageHandle> (Derived::Call::*fn)(MessageHandle, Derived*),
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerToClientMessage);
+  DCHECK(fn == &Derived::Call::OnServerToClientMessage);
   call_args.server_to_client_messages->InterceptAndMap(
       [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
         auto r = call_data->call.OnServerToClientMessage(std::move(msg),
@@ -870,13 +926,14 @@ inline void InterceptServerToClientMessage(const NoInterceptor*, void*, void*,
 template <typename Derived>
 inline void InterceptServerToClientMessage(
     ServerMetadataHandle (Derived::Call::*fn)(const Message&),
-    typename Derived::Call* call, Derived*, CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerToClientMessage);
+    typename Derived::Call* call, Derived*, PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnServerToClientMessage);
   call_spine->server_to_client_messages().sender.InterceptAndMap(
       [call, call_spine](MessageHandle msg) -> absl::optional<MessageHandle> {
         auto return_md = call->OnServerToClientMessage(*msg);
         if (return_md == nullptr) return std::move(msg);
-        return call_spine->Cancel(std::move(return_md));
+        call_spine->PushServerTrailingMetadata(std::move(return_md));
+        return absl::nullopt;
       });
 }
 
@@ -884,14 +941,15 @@ template <typename Derived>
 inline void InterceptServerToClientMessage(
     ServerMetadataHandle (Derived::Call::*fn)(const Message&, Derived*),
     typename Derived::Call* call, Derived* channel,
-    CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerToClientMessage);
+    PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnServerToClientMessage);
   call_spine->server_to_client_messages().sender.InterceptAndMap(
       [call, call_spine,
        channel](MessageHandle msg) -> absl::optional<MessageHandle> {
         auto return_md = call->OnServerToClientMessage(*msg, channel);
         if (return_md == nullptr) return std::move(msg);
-        return call_spine->Cancel(std::move(return_md));
+        call_spine->PushServerTrailingMetadata(std::move(return_md));
+        return absl::nullopt;
       });
 }
 
@@ -899,8 +957,8 @@ template <typename Derived>
 inline void InterceptServerToClientMessage(
     MessageHandle (Derived::Call::*fn)(MessageHandle, Derived*),
     typename Derived::Call* call, Derived* channel,
-    CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerToClientMessage);
+    PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnServerToClientMessage);
   call_spine->server_to_client_messages().sender.InterceptAndMap(
       [call, channel](MessageHandle msg) {
         return call->OnServerToClientMessage(std::move(msg), channel);
@@ -911,14 +969,16 @@ template <typename Derived>
 inline void InterceptServerToClientMessage(
     absl::StatusOr<MessageHandle> (Derived::Call::*fn)(MessageHandle, Derived*),
     typename Derived::Call* call, Derived* channel,
-    CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerToClientMessage);
+    PipeBasedCallSpine* call_spine) {
+  DCHECK(fn == &Derived::Call::OnServerToClientMessage);
   call_spine->server_to_client_messages().sender.InterceptAndMap(
       [call, call_spine,
        channel](MessageHandle msg) -> absl::optional<MessageHandle> {
         auto r = call->OnServerToClientMessage(std::move(msg), channel);
         if (r.ok()) return std::move(*r);
-        return call_spine->Cancel(ServerMetadataFromStatus(r.status()));
+        call_spine->PushServerTrailingMetadata(
+            ServerMetadataFromStatus(r.status()));
+        return absl::nullopt;
       });
 }
 
@@ -927,40 +987,25 @@ inline void InterceptServerTrailingMetadata(const NoInterceptor*, void*, void*,
 
 template <typename Derived>
 inline void InterceptServerTrailingMetadata(
-    void (Derived::Call::*fn)(ServerMetadata&), typename Derived::Call* call,
-    Derived*, CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerTrailingMetadata);
-  call_spine->server_trailing_metadata().sender.InterceptAndMap(
-      [call](ServerMetadataHandle md) {
-        call->OnServerTrailingMetadata(*md);
-        return md;
-      });
+    void (Derived::Call::*)(ServerMetadata&), typename Derived::Call*, Derived*,
+    PipeBasedCallSpine*) {
+  gpr_log(GPR_ERROR,
+          "InterceptServerTrailingMetadata not available for call v2.5");
 }
-
 template <typename Derived>
 inline void InterceptServerTrailingMetadata(
-    void (Derived::Call::*fn)(ServerMetadata&, Derived*),
-    typename Derived::Call* call, Derived* channel,
-    CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerTrailingMetadata);
-  call_spine->server_trailing_metadata().sender.InterceptAndMap(
-      [call, channel](ServerMetadataHandle md) {
-        call->OnServerTrailingMetadata(*md, channel);
-        return md;
-      });
+    void (Derived::Call::*)(ServerMetadata&, Derived*), typename Derived::Call*,
+    Derived*, PipeBasedCallSpine*) {
+  gpr_log(GPR_ERROR,
+          "InterceptServerTrailingMetadata not available for call v2.5");
 }
 
 template <typename Derived>
 inline void InterceptServerTrailingMetadata(
-    absl::Status (Derived::Call::*fn)(ServerMetadata&),
-    typename Derived::Call* call, Derived*, CallSpineInterface* call_spine) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnServerTrailingMetadata);
-  call_spine->server_trailing_metadata().sender.InterceptAndMap(
-      [call](ServerMetadataHandle md) -> absl::optional<ServerMetadataHandle> {
-        auto status = call->OnServerTrailingMetadata(*md);
-        if (status.ok()) return std::move(md);
-        return ServerMetadataFromStatus(status);
-      });
+    absl::Status (Derived::Call::*)(ServerMetadata&), typename Derived::Call*,
+    Derived*, PipeBasedCallSpine*) {
+  gpr_log(GPR_ERROR,
+          "InterceptServerTrailingMetadata not available for call v2.5");
 }
 
 inline void InterceptFinalize(const NoInterceptor*, void*, void*) {}
@@ -968,7 +1013,7 @@ inline void InterceptFinalize(const NoInterceptor*, void*, void*) {}
 template <class Call>
 inline void InterceptFinalize(void (Call::*fn)(const grpc_call_final_info*),
                               void*, Call* call) {
-  GPR_DEBUG_ASSERT(fn == &Call::OnFinalize);
+  DCHECK(fn == &Call::OnFinalize);
   GetContext<CallFinalization>()->Add(
       [call](const grpc_call_final_info* final_info) {
         call->OnFinalize(final_info);
@@ -979,7 +1024,7 @@ template <class Derived>
 inline void InterceptFinalize(
     void (Derived::Call::*fn)(const grpc_call_final_info*, Derived*),
     Derived* channel, typename Derived::Call* call) {
-  GPR_DEBUG_ASSERT(fn == &Derived::Call::OnFinalize);
+  DCHECK(fn == &Derived::Call::OnFinalize);
   GetContext<CallFinalization>()->Add(
       [call, channel](const grpc_call_final_info* final_info) {
         call->OnFinalize(final_info, channel);
@@ -1059,8 +1104,10 @@ MakeFilterCall(Derived* derived) {
 //   the filter does not intercept call finalization.
 // - void OnFinalize(const grpc_call_final_info*):
 //   the filter intercepts call finalization.
+class ImplementChannelFilterTag {};
 template <typename Derived>
-class ImplementChannelFilter : public ChannelFilter {
+class ImplementChannelFilter : public ChannelFilter,
+                               public ImplementChannelFilterTag {
  public:
   // Natively construct a v3 call.
   void InitCall(CallSpineInterface* call_spine) {
@@ -1068,23 +1115,20 @@ class ImplementChannelFilter : public ChannelFilter {
         GetContext<Arena>()
             ->ManagedNew<promise_filter_detail::CallWrapper<Derived>>(
                 static_cast<Derived*>(this));
+    auto* c = DownCast<PipeBasedCallSpine*>(call_spine);
+    auto* d = static_cast<Derived*>(this);
     promise_filter_detail::InterceptClientInitialMetadata(
-        &Derived::Call::OnClientInitialMetadata, call,
-        static_cast<Derived*>(this), call_spine);
+        &Derived::Call::OnClientInitialMetadata, call, d, c);
     promise_filter_detail::InterceptClientToServerMessage(
-        &Derived::Call::OnClientToServerMessage, call,
-        static_cast<Derived*>(this), call_spine);
+        &Derived::Call::OnClientToServerMessage, call, d, c);
     promise_filter_detail::InterceptServerInitialMetadata(
-        &Derived::Call::OnServerInitialMetadata, call,
-        static_cast<Derived*>(this), call_spine);
+        &Derived::Call::OnServerInitialMetadata, call, d, c);
     promise_filter_detail::InterceptServerToClientMessage(
-        &Derived::Call::OnServerToClientMessage, call,
-        static_cast<Derived*>(this), call_spine);
+        &Derived::Call::OnServerToClientMessage, call, d, c);
     promise_filter_detail::InterceptServerTrailingMetadata(
-        &Derived::Call::OnServerTrailingMetadata, call,
-        static_cast<Derived*>(this), call_spine);
-    promise_filter_detail::InterceptFinalize(&Derived::Call::OnFinalize,
-                                             static_cast<Derived*>(this), call);
+        &Derived::Call::OnServerTrailingMetadata, call, d, c);
+    promise_filter_detail::InterceptFinalize(&Derived::Call::OnFinalize, d,
+                                             call);
   }
 
   // Polyfill for the original promise scheme.
@@ -1169,8 +1213,7 @@ class BaseCallData : public Activity, private Wakeable {
   ~BaseCallData() override;
 
   void set_pollent(grpc_polling_entity* pollent) {
-    GPR_ASSERT(nullptr ==
-               pollent_.exchange(pollent, std::memory_order_release));
+    CHECK(nullptr == pollent_.exchange(pollent, std::memory_order_release));
   }
 
   // Activity implementation (partial).
@@ -1216,7 +1259,7 @@ class BaseCallData : public Activity, private Wakeable {
     ~Flusher();
 
     void Resume(grpc_transport_stream_op_batch* batch) {
-      GPR_ASSERT(!call_->is_last());
+      CHECK(!call_->is_last());
       if (batch->HasOp()) {
         release_.push_back(batch);
       } else if (batch->on_complete != nullptr) {
@@ -1295,7 +1338,7 @@ class BaseCallData : public Activity, private Wakeable {
     PipeSender<MessageHandle>* original_sender() override { abort(); }
 
     void GotPipe(PipeReceiver<MessageHandle>* receiver) override {
-      GPR_ASSERT(receiver_ == nullptr);
+      CHECK_EQ(receiver_, nullptr);
       receiver_ = receiver;
     }
 
@@ -1303,7 +1346,7 @@ class BaseCallData : public Activity, private Wakeable {
 
     PipeSender<MessageHandle>* Push() override { return &pipe_.sender; }
     PipeReceiver<MessageHandle>* Pull() override {
-      GPR_ASSERT(receiver_ != nullptr);
+      CHECK_NE(receiver_, nullptr);
       return receiver_;
     }
 
@@ -1324,12 +1367,12 @@ class BaseCallData : public Activity, private Wakeable {
     void GotPipe(PipeReceiver<MessageHandle>*) override { abort(); }
 
     void GotPipe(PipeSender<MessageHandle>* sender) override {
-      GPR_ASSERT(sender_ == nullptr);
+      CHECK_EQ(sender_, nullptr);
       sender_ = sender;
     }
 
     PipeSender<MessageHandle>* Push() override {
-      GPR_ASSERT(sender_ != nullptr);
+      CHECK_NE(sender_, nullptr);
       return sender_;
     }
     PipeReceiver<MessageHandle>* Pull() override { return &pipe_.receiver; }
@@ -1823,6 +1866,15 @@ struct BaseCallDataMethods {
   }
 };
 
+// The type of object returned by a filter's Create method.
+template <typename T>
+using CreatedType = typename decltype(T::Create(ChannelArgs(), {}))::value_type;
+
+template <typename GrpcChannelOrCallElement>
+inline ChannelFilter* ChannelFilterFromElem(GrpcChannelOrCallElement* elem) {
+  return *static_cast<ChannelFilter**>(elem->channel_data);
+}
+
 template <typename CallData, uint8_t kFlags>
 struct CallDataFilterWithFlagsMethods {
   static absl::Status InitCallElem(grpc_call_element* elem,
@@ -1838,7 +1890,7 @@ struct CallDataFilterWithFlagsMethods {
     if ((kFlags & kFilterIsLast) != 0) {
       ExecCtx::Run(DEBUG_LOCATION, then_schedule_closure, absl::OkStatus());
     } else {
-      GPR_ASSERT(then_schedule_closure == nullptr);
+      CHECK_EQ(then_schedule_closure, nullptr);
     }
   }
 };
@@ -1847,32 +1899,25 @@ struct ChannelFilterMethods {
   static ArenaPromise<ServerMetadataHandle> MakeCallPromise(
       grpc_channel_element* elem, CallArgs call_args,
       NextPromiseFactory next_promise_factory) {
-    return static_cast<ChannelFilter*>(elem->channel_data)
-        ->MakeCallPromise(std::move(call_args),
-                          std::move(next_promise_factory));
+    return ChannelFilterFromElem(elem)->MakeCallPromise(
+        std::move(call_args), std::move(next_promise_factory));
   }
 
   static void StartTransportOp(grpc_channel_element* elem,
                                grpc_transport_op* op) {
-    if (!static_cast<ChannelFilter*>(elem->channel_data)
-             ->StartTransportOp(op)) {
+    if (!ChannelFilterFromElem(elem)->StartTransportOp(op)) {
       grpc_channel_next_op(elem, op);
     }
   }
 
   static void PostInitChannelElem(grpc_channel_stack*,
                                   grpc_channel_element* elem) {
-    static_cast<ChannelFilter*>(elem->channel_data)->PostInit();
-  }
-
-  static void DestroyChannelElem(grpc_channel_element* elem) {
-    static_cast<ChannelFilter*>(elem->channel_data)->~ChannelFilter();
+    ChannelFilterFromElem(elem)->PostInit();
   }
 
   static void GetChannelInfo(grpc_channel_element* elem,
                              const grpc_channel_info* info) {
-    if (!static_cast<ChannelFilter*>(elem->channel_data)
-             ->GetChannelInfo(info)) {
+    if (!ChannelFilterFromElem(elem)->GetChannelInfo(info)) {
       grpc_channel_next_get_info(elem, info);
     }
   }
@@ -1882,19 +1927,20 @@ template <typename F, uint8_t kFlags>
 struct ChannelFilterWithFlagsMethods {
   static absl::Status InitChannelElem(grpc_channel_element* elem,
                                       grpc_channel_element_args* args) {
-    GPR_ASSERT(args->is_last == ((kFlags & kFilterIsLast) != 0));
+    CHECK(args->is_last == ((kFlags & kFilterIsLast) != 0));
     auto status = F::Create(args->channel_args,
                             ChannelFilter::Args(args->channel_stack, elem));
     if (!status.ok()) {
-      static_assert(
-          sizeof(promise_filter_detail::InvalidChannelFilter) <= sizeof(F),
-          "InvalidChannelFilter must fit in F");
-      new (elem->channel_data) promise_filter_detail::InvalidChannelFilter();
+      new (elem->channel_data) F*(nullptr);
       return absl_status_to_grpc_error(status.status());
     }
-    new (elem->channel_data) F(std::move(*status));
+    new (elem->channel_data) F*(status->release());
     return absl::OkStatus();
   }
+
+  static void DestroyChannelElem(grpc_channel_element* elem) {
+    CreatedType<F> channel_elem(DownCast<F*>(ChannelFilterFromElem(elem)));
+  }
 };
 
 }  // namespace promise_filter_detail
@@ -1906,9 +1952,11 @@ struct ChannelFilterWithFlagsMethods {
 //       ChannelArgs channel_args, ChannelFilter::Args filter_args);
 // };
 template <typename F, FilterEndpoint kEndpoint, uint8_t kFlags = 0>
-absl::enable_if_t<std::is_base_of<ChannelFilter, F>::value &&
-                      !std::is_base_of<ImplementChannelFilter<F>, F>::value,
-                  grpc_channel_filter>
+absl::enable_if_t<
+    std::is_base_of<ChannelFilter, F>::value &&
+        !std::is_base_of<ImplementChannelFilterTag, F>::value &&
+        !std::is_base_of<HackyHackyHackySkipInV3FilterStacks, F>::value,
+    grpc_channel_filter>
 MakePromiseBasedFilter(const char* name) {
   using CallData = promise_filter_detail::CallData<kEndpoint>;
 
@@ -1938,7 +1986,8 @@ MakePromiseBasedFilter(const char* name) {
       // post_init_channel_elem
       promise_filter_detail::ChannelFilterMethods::PostInitChannelElem,
       // destroy_channel_elem
-      promise_filter_detail::ChannelFilterMethods::DestroyChannelElem,
+      promise_filter_detail::ChannelFilterWithFlagsMethods<
+          F, kFlags>::DestroyChannelElem,
       // get_channel_info
       promise_filter_detail::ChannelFilterMethods::GetChannelInfo,
       // name
@@ -1947,7 +1996,54 @@ MakePromiseBasedFilter(const char* name) {
 }
 
 template <typename F, FilterEndpoint kEndpoint, uint8_t kFlags = 0>
-absl::enable_if_t<std::is_base_of<ImplementChannelFilter<F>, F>::value,
+absl::enable_if_t<
+    std::is_base_of<HackyHackyHackySkipInV3FilterStacks, F>::value,
+    grpc_channel_filter>
+MakePromiseBasedFilter(const char* name) {
+  using CallData = promise_filter_detail::CallData<kEndpoint>;
+
+  return grpc_channel_filter{
+      // start_transport_stream_op_batch
+      promise_filter_detail::BaseCallDataMethods::StartTransportStreamOpBatch,
+      // make_call_promise
+      promise_filter_detail::ChannelFilterMethods::MakeCallPromise,
+      [](grpc_channel_element* elem, CallSpineInterface*) {
+        GRPC_LOG_EVERY_N_SEC(
+            1, GPR_ERROR,
+            "gRPC V3 call stack in use, with a filter ('%s') that is not V3.",
+            elem->filter->name);
+      },
+      // start_transport_op
+      promise_filter_detail::ChannelFilterMethods::StartTransportOp,
+      // sizeof_call_data
+      sizeof(CallData),
+      // init_call_elem
+      promise_filter_detail::CallDataFilterWithFlagsMethods<
+          CallData, kFlags>::InitCallElem,
+      // set_pollset_or_pollset_set
+      promise_filter_detail::BaseCallDataMethods::SetPollsetOrPollsetSet,
+      // destroy_call_elem
+      promise_filter_detail::CallDataFilterWithFlagsMethods<
+          CallData, kFlags>::DestroyCallElem,
+      // sizeof_channel_data
+      sizeof(F),
+      // init_channel_elem
+      promise_filter_detail::ChannelFilterWithFlagsMethods<
+          F, kFlags>::InitChannelElem,
+      // post_init_channel_elem
+      promise_filter_detail::ChannelFilterMethods::PostInitChannelElem,
+      // destroy_channel_elem
+      promise_filter_detail::ChannelFilterWithFlagsMethods<
+          F, kFlags>::DestroyChannelElem,
+      // get_channel_info
+      promise_filter_detail::ChannelFilterMethods::GetChannelInfo,
+      // name
+      name,
+  };
+}
+
+template <typename F, FilterEndpoint kEndpoint, uint8_t kFlags = 0>
+absl::enable_if_t<std::is_base_of<ImplementChannelFilterTag, F>::value,
                   grpc_channel_filter>
 MakePromiseBasedFilter(const char* name) {
   using CallData = promise_filter_detail::CallData<kEndpoint>;
@@ -1980,7 +2076,8 @@ MakePromiseBasedFilter(const char* name) {
       // post_init_channel_elem
       promise_filter_detail::ChannelFilterMethods::PostInitChannelElem,
       // destroy_channel_elem
-      promise_filter_detail::ChannelFilterMethods::DestroyChannelElem,
+      promise_filter_detail::ChannelFilterWithFlagsMethods<
+          F, kFlags>::DestroyChannelElem,
       // get_channel_info
       promise_filter_detail::ChannelFilterMethods::GetChannelInfo,
       // name