grpc 1.69.0 → 1.71.0

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

@@ -32,6 +32,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <atomic>
 #include <memory>
 #include <string>
 #include <utility>
@@ -119,93 +120,124 @@ void ServerCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
                              bool is_notify_tag_closure) {
   BatchOpIndex op_index(ops, nops);
   if (!is_notify_tag_closure) grpc_cq_begin_op(cq_, notify_tag);
-  auto send_initial_metadata =
-      op_index.OpHandler<GRPC_OP_SEND_INITIAL_METADATA>([this](
-                                                            const grpc_op& op) {
-        auto metadata = arena()->MakePooled<ServerMetadata>();
-        PrepareOutgoingInitialMetadata(op, *metadata);
-        CToMetadata(op.data.send_initial_metadata.metadata,
-                    op.data.send_initial_metadata.count, metadata.get());
-        GRPC_TRACE_LOG(call, INFO)
-            << DebugTag() << "[call] Send initial metadata";
-        return [this, metadata = std::move(metadata)]() mutable {
-          return call_handler_.PushServerInitialMetadata(std::move(metadata));
-        };
-      });
-  auto send_message =
-      op_index.OpHandler<GRPC_OP_SEND_MESSAGE>([this](const grpc_op& op) {
-        SliceBuffer send;
-        grpc_slice_buffer_swap(
-            &op.data.send_message.send_message->data.raw.slice_buffer,
-            send.c_slice_buffer());
-        auto msg = arena()->MakePooled<Message>(std::move(send), op.flags);
-        return [this, msg = std::move(msg)]() mutable {
-          return call_handler_.PushMessage(std::move(msg));
-        };
-      });
-  auto send_trailing_metadata =
-      op_index.OpHandler<GRPC_OP_SEND_STATUS_FROM_SERVER>(
-          [this](const grpc_op& op) {
-            auto metadata = arena()->MakePooled<ServerMetadata>();
-            CToMetadata(op.data.send_status_from_server.trailing_metadata,
-                        op.data.send_status_from_server.trailing_metadata_count,
-                        metadata.get());
-            metadata->Set(GrpcStatusMetadata(),
-                          op.data.send_status_from_server.status);
-            if (auto* details =
-                    op.data.send_status_from_server.status_details) {
-              // TODO(ctiller): this should not be a copy, but we have
-              // callers that allocate and pass in a slice created with
-              // grpc_slice_from_static_string and then delete the string
-              // after passing it in, which shouldn't be a supported API.
-              metadata->Set(GrpcMessageMetadata(),
-                            Slice(grpc_slice_copy(*details)));
-            }
+
+  auto commit_with_send_ops = [&](auto send_ops) {
+    auto recv_message =
+        op_index.OpHandler<GRPC_OP_RECV_MESSAGE>([this](const grpc_op& op) {
+          return message_receiver_.MakeBatchOp(op, &call_handler_);
+        });
+    auto primary_ops =
+        AllOk<StatusFlag>(std::move(send_ops), std::move(recv_message));
+    if (auto* op = op_index.op(GRPC_OP_RECV_CLOSE_ON_SERVER)) {
+      auto recv_trailing_metadata = OpHandler<GRPC_OP_RECV_CLOSE_ON_SERVER>(
+          [this, cancelled = op->data.recv_close_on_server.cancelled]() {
+            return Map(call_handler_.WasCancelled(),
+                       [cancelled, this](bool result) -> Success {
+                         saw_was_cancelled_.store(true,
+                                                  std::memory_order_relaxed);
+                         ResetDeadline();
+                         *cancelled = result ? 1 : 0;
+                         return Success{};
+                       });
+          });
+      call_handler_.SpawnInfallible(
+          "final-batch",
+          GRPC_LATENT_SEE_PROMISE(
+              "ServerCallBatch",
+              InfallibleBatch(std::move(primary_ops),
+                              std::move(recv_trailing_metadata),
+                              is_notify_tag_closure, notify_tag, cq_)));
+    } else {
+      call_handler_.SpawnInfallible(
+          "batch", GRPC_LATENT_SEE_PROMISE(
+                       "ServerCallBatch",
+                       FallibleBatch(std::move(primary_ops),
+                                     is_notify_tag_closure, notify_tag, cq_)));
+    }
+  };
+
+  auto make_send_trailing_metadata = [this](const grpc_op& op) {
+    auto metadata = arena()->MakePooled<ServerMetadata>();
+    CToMetadata(op.data.send_status_from_server.trailing_metadata,
+                op.data.send_status_from_server.trailing_metadata_count,
+                metadata.get());
+    metadata->Set(GrpcStatusMetadata(), op.data.send_status_from_server.status);
+    if (auto* details = op.data.send_status_from_server.status_details) {
+      // TODO(ctiller): this should not be a copy, but we have
+      // callers that allocate and pass in a slice created with
+      // grpc_slice_from_static_string and then delete the string
+      // after passing it in, which shouldn't be a supported API.
+      metadata->Set(GrpcMessageMetadata(), Slice(grpc_slice_copy(*details)));
+    }
+    CHECK(metadata != nullptr);
+    bool wait_for_initial_metadata_scheduled =
+        sent_server_initial_metadata_batch_.load(std::memory_order_relaxed);
+    return [this, metadata = std::move(metadata),
+            wait_for_initial_metadata_scheduled]() mutable {
+      CHECK(metadata != nullptr);
+      // If there was a send initial metadata batch sent prior to this one, then
+      // make sure it's been scheduled first - otherwise we may accidentally
+      // treat this as trailers only.
+      return Seq(
+          If(
+              wait_for_initial_metadata_scheduled,
+              [this]() { return server_initial_metadata_scheduled_.Wait(); },
+              []() { return Empty{}; }),
+          [this, metadata = std::move(metadata)]() mutable -> Poll<Success> {
             CHECK(metadata != nullptr);
-            return [this, metadata = std::move(metadata)]() mutable {
-              CHECK(metadata != nullptr);
-              return [this, metadata = std::move(
-                                metadata)]() mutable -> Poll<Success> {
-                CHECK(metadata != nullptr);
-                call_handler_.PushServerTrailingMetadata(std::move(metadata));
-                return Success{};
-              };
-            };
+            call_handler_.PushServerTrailingMetadata(std::move(metadata));
+            return Success{};
           });
-  auto recv_message =
-      op_index.OpHandler<GRPC_OP_RECV_MESSAGE>([this](const grpc_op& op) {
-        return message_receiver_.MakeBatchOp(op, &call_handler_);
-      });
-  auto primary_ops = AllOk<StatusFlag>(
-      TrySeq(AllOk<StatusFlag>(std::move(send_initial_metadata),
-                               std::move(send_message)),
-             std::move(send_trailing_metadata)),
-      std::move(recv_message));
-  if (auto* op = op_index.op(GRPC_OP_RECV_CLOSE_ON_SERVER)) {
-    auto recv_trailing_metadata = OpHandler<GRPC_OP_RECV_CLOSE_ON_SERVER>(
-        [this, cancelled = op->data.recv_close_on_server.cancelled]() {
-          return Map(call_handler_.WasCancelled(),
-                     [cancelled, this](bool result) -> Success {
-                       saw_was_cancelled_.store(true,
-                                                std::memory_order_relaxed);
-                       ResetDeadline();
-                       *cancelled = result ? 1 : 0;
-                       return Success{};
-                     });
-        });
-    call_handler_.SpawnInfallible(
-        "final-batch",
-        GRPC_LATENT_SEE_PROMISE(
-            "ServerCallBatch",
-            InfallibleBatch(std::move(primary_ops),
-                            std::move(recv_trailing_metadata),
-                            is_notify_tag_closure, notify_tag, cq_)));
+    };
+  };
+
+  // Handle send trailing metadata only
+  if (op_index.has_op(GRPC_OP_SEND_INITIAL_METADATA) &&
+      op_index.has_op(GRPC_OP_SEND_STATUS_FROM_SERVER) &&
+      !op_index.has_op(GRPC_OP_SEND_MESSAGE) &&
+      op_index.op(GRPC_OP_SEND_INITIAL_METADATA)
+              ->data.send_initial_metadata.count == 0) {
+    const auto& trailing_metadata =
+        *op_index.op(GRPC_OP_SEND_STATUS_FROM_SERVER);
+    commit_with_send_ops(OpHandler<GRPC_OP_SEND_STATUS_FROM_SERVER>(
+        make_send_trailing_metadata(trailing_metadata)));
   } else {
-    call_handler_.SpawnInfallible(
-        "batch", GRPC_LATENT_SEE_PROMISE(
-                     "ServerCallBatch",
-                     FallibleBatch(std::move(primary_ops),
-                                   is_notify_tag_closure, notify_tag, cq_)));
+    // Non-send-trailing-metadata path
+    auto send_initial_metadata =
+        op_index.OpHandler<GRPC_OP_SEND_INITIAL_METADATA>(
+            [this](const grpc_op& op) {
+              auto metadata = arena()->MakePooled<ServerMetadata>();
+              PrepareOutgoingInitialMetadata(op, *metadata);
+              CToMetadata(op.data.send_initial_metadata.metadata,
+                          op.data.send_initial_metadata.count, metadata.get());
+              sent_server_initial_metadata_batch_.store(
+                  true, std::memory_order_relaxed);
+              GRPC_TRACE_LOG(call, INFO)
+                  << DebugTag() << "[call] Send initial metadata";
+              return [this, metadata = std::move(metadata)]() mutable {
+                server_initial_metadata_scheduled_.Set();
+                return call_handler_.PushServerInitialMetadata(
+                    std::move(metadata));
+              };
+            });
+    auto send_message =
+        op_index.OpHandler<GRPC_OP_SEND_MESSAGE>([this](const grpc_op& op) {
+          SliceBuffer send;
+          grpc_slice_buffer_swap(
+              &op.data.send_message.send_message->data.raw.slice_buffer,
+              send.c_slice_buffer());
+          auto msg = arena()->MakePooled<Message>(std::move(send), op.flags);
+          return [this, msg = std::move(msg)]() mutable {
+            return call_handler_.PushMessage(std::move(msg));
+          };
+        });
+    auto send_trailing_metadata =
+        op_index.OpHandler<GRPC_OP_SEND_STATUS_FROM_SERVER>(
+            make_send_trailing_metadata);
+    commit_with_send_ops(
+        TrySeq(AllOk<StatusFlag>(std::move(send_initial_metadata),
+                                 std::move(send_message)),
+               std::move(send_trailing_metadata)));
   }
 }
 

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

@@ -150,6 +150,8 @@ class ServerCall final : public Call, public DualRefCounted<ServerCall> {
   std::string DebugTag() { return absl::StrFormat("SERVER_CALL[%p]: ", this); }
 
   CallHandler call_handler_;
+  std::atomic<bool> sent_server_initial_metadata_batch_{false};
+  Latch<void> server_initial_metadata_scheduled_;
   MessageReceiver message_receiver_;
   ClientMetadataHandle client_initial_metadata_stored_;
   grpc_completion_queue* const cq_;

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

@@ -22,6 +22,6 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-const char* grpc_version_string(void) { return "44.2.0"; }
+const char* grpc_version_string(void) { return "46.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "gridiron"; }
+const char* grpc_g_stands_for(void) { return "gears"; }

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

@@ -79,10 +79,7 @@ void CallFilters::CancelDueToFailedPipeOperation(SourceLocation but_where) {
   GRPC_TRACE_VLOG(promise_primitives, 2)
           .AtLocation(but_where.file(), but_where.line())
       << "Cancelling due to failed pipe operation: " << DebugString();
-  auto status =
-      ServerMetadataFromStatus(GRPC_STATUS_CANCELLED, "Failed pipe operation");
-  status->Set(GrpcCallWasCancelled(), true);
-  PushServerTrailingMetadata(std::move(status));
+  Cancel();
 }
 
 void CallFilters::PushServerTrailingMetadata(ServerMetadataHandle md) {
@@ -97,6 +94,15 @@ void CallFilters::PushServerTrailingMetadata(ServerMetadataHandle md) {
   }
 }
 
+void CallFilters::Cancel() {
+  GRPC_TRACE_LOG(call, INFO) << GetContext<Activity>()->DebugTag() << " Cancel["
+                             << this << "]: into " << DebugString();
+  if (call_state_.PushServerTrailingMetadata(true)) {
+    push_server_trailing_metadata_ =
+        CancelledServerMetadataFromStatus(GRPC_STATUS_CANCELLED);
+  }
+}
+
 std::string CallFilters::DebugString() const {
   std::vector<std::string> components = {
       absl::StrFormat("this:%p", this),

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

@@ -58,7 +58,7 @@
 //
 // The type of these members matters, and is selectable by the class
 // author. For $INTERCEPTOR_NAME in the above list:
-// - static const NoInterceptor $INTERCEPTOR_NAME:
+// - static inline const NoInterceptor $INTERCEPTOR_NAME:
 //   defines that this filter does not intercept this event.
 //   there is zero runtime cost added to handling that event by this filter.
 // - void $INTERCEPTOR_NAME($VALUE_TYPE&):
@@ -91,7 +91,7 @@
 //
 // Finally, OnFinalize is added to intecept call finalization.
 // It must have one of the signatures:
-// - static const NoInterceptor OnFinalize:
+// - static inline const NoInterceptor OnFinalize:
 //   the filter does not intercept call finalization.
 // - void OnFinalize(const grpc_call_final_info*):
 //   the filter intercepts call finalization.
@@ -111,13 +111,8 @@ namespace grpc_core {
 // Tag type to indicate no interception.
 // This is used to indicate that a filter does not intercept a particular
 // event.
-// In C++14 we declare these as (for example):
-//   static const NoInterceptor OnClientInitialMetadata;
-// and out-of-line provide the definition:
-//   const MyFilter::Call::NoInterceptor
-//   MyFilter::Call::OnClientInitialMetadata;
-// In C++17 and later we can use inline variables instead:
-//   inline static const NoInterceptor OnClientInitialMetadata;
+// We declare these as (for example):
+//   inline static inline const NoInterceptor OnClientInitialMetadata;
 struct NoInterceptor {};
 
 namespace filters_detail {
@@ -545,6 +540,31 @@ struct AddOpImpl<
   }
 };
 
+// void $INTERCEPTOR_NAME(const $VALUE_TYPE&, FilterType*)
+template <typename FilterType, typename T,
+          void (FilterType::Call::*impl)(const typename T::element_type&,
+                                         FilterType*)>
+struct AddOpImpl<FilterType, T,
+                 void (FilterType::Call::*)(const typename T::element_type&,
+                                            FilterType*),
+                 impl> {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
+    to.Add(0, 0,
+           Operator<T>{
+               channel_data,
+               call_offset,
+               [](void*, void* call_data, void* channel_data,
+                  T value) -> Poll<ResultOr<T>> {
+                 (static_cast<typename FilterType::Call*>(call_data)->*impl)(
+                     *value, static_cast<FilterType*>(channel_data));
+                 return ResultOr<T>{std::move(value), nullptr};
+               },
+               nullptr,
+               nullptr,
+           });
+  }
+};
+
 // $VALUE_HANDLE $INTERCEPTOR_NAME($VALUE_HANDLE, FilterType*)
 template <typename FilterType, typename T,
           T (FilterType::Call::*impl)(T, FilterType*)>
@@ -932,6 +952,30 @@ struct AddOpImpl<FilterType, T, R (FilterType::Call::*)(T, FilterType*), impl,
                  absl::enable_if_t<std::is_same<absl::StatusOr<T>,
                                                 PromiseResult<R>>::value>> {
   static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
+#if defined(__GNUC__) && __GNUC__ == 9
+    // Workaround for a bug in GNU C++ 9 compilers that fail to compile this
+    // class.
+    class Promise {
+     public:
+      Promise(T value, typename FilterType::Call* call_data,
+              FilterType* channel_data)
+          : impl_(std::make_unique<R>(
+                (call_data->*impl)(std::move(value), channel_data))) {}
+
+      Poll<ResultOr<T>> PollOnce() {
+        auto p = (*impl_)();
+        auto* r = p.value_if_ready();
+        if (r == nullptr) return Pending{};
+        this->~Promise();
+        if (r->ok()) return ResultOr<T>{std::move(**r), nullptr};
+        return ResultOr<T>{nullptr,
+                           CancelledServerMetadataFromStatus(r->status())};
+      }
+
+     private:
+      std::unique_ptr<R> impl_;
+    };
+#else
     class Promise {
      public:
       Promise(T value, typename FilterType::Call* call_data,
@@ -951,6 +995,7 @@ struct AddOpImpl<FilterType, T, R (FilterType::Call::*)(T, FilterType*), impl,
      private:
       GPR_NO_UNIQUE_ADDRESS R impl_;
     };
+#endif
     to.Add(sizeof(Promise), alignof(Promise),
            Operator<T>{
                channel_data,
@@ -1323,12 +1368,12 @@ class ServerTrailingMetadataInterceptor {
  public:
   class Call {
    public:
-    static const NoInterceptor OnClientInitialMetadata;
-    static const NoInterceptor OnServerInitialMetadata;
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnFinalize;
+    static const inline NoInterceptor OnClientInitialMetadata;
+    static const inline NoInterceptor OnServerInitialMetadata;
+    static const inline NoInterceptor OnClientToServerMessage;
+    static const inline NoInterceptor OnClientToServerHalfClose;
+    static const inline NoInterceptor OnServerToClientMessage;
+    static const inline NoInterceptor OnFinalize;
     void OnServerTrailingMetadata(ServerMetadata& md,
                                   ServerTrailingMetadataInterceptor* filter) {
       filter->fn_(md);
@@ -1340,23 +1385,6 @@ class ServerTrailingMetadataInterceptor {
  private:
   GPR_NO_UNIQUE_ADDRESS Fn fn_;
 };
-template <typename Fn>
-const NoInterceptor
-    ServerTrailingMetadataInterceptor<Fn>::Call::OnClientInitialMetadata;
-template <typename Fn>
-const NoInterceptor
-    ServerTrailingMetadataInterceptor<Fn>::Call::OnServerInitialMetadata;
-template <typename Fn>
-const NoInterceptor
-    ServerTrailingMetadataInterceptor<Fn>::Call::OnClientToServerMessage;
-template <typename Fn>
-const NoInterceptor
-    ServerTrailingMetadataInterceptor<Fn>::Call::OnClientToServerHalfClose;
-template <typename Fn>
-const NoInterceptor
-    ServerTrailingMetadataInterceptor<Fn>::Call::OnServerToClientMessage;
-template <typename Fn>
-const NoInterceptor ServerTrailingMetadataInterceptor<Fn>::Call::OnFinalize;
 
 template <typename Fn>
 class ClientInitialMetadataInterceptor {
@@ -1367,12 +1395,12 @@ class ClientInitialMetadataInterceptor {
                                  ClientInitialMetadataInterceptor* filter) {
       return filter->fn_(md);
     }
-    static const NoInterceptor OnServerInitialMetadata;
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnServerTrailingMetadata;
-    static const NoInterceptor OnFinalize;
+    static const inline NoInterceptor OnServerInitialMetadata;
+    static const inline NoInterceptor OnClientToServerMessage;
+    static const inline NoInterceptor OnClientToServerHalfClose;
+    static const inline NoInterceptor OnServerToClientMessage;
+    static const inline NoInterceptor OnServerTrailingMetadata;
+    static const inline NoInterceptor OnFinalize;
   };
 
   explicit ClientInitialMetadataInterceptor(Fn fn) : fn_(std::move(fn)) {}
@@ -1380,24 +1408,37 @@ class ClientInitialMetadataInterceptor {
  private:
   GPR_NO_UNIQUE_ADDRESS Fn fn_;
 };
-template <typename Fn>
-const NoInterceptor
-    ClientInitialMetadataInterceptor<Fn>::Call::OnServerInitialMetadata;
-template <typename Fn>
-const NoInterceptor
-    ClientInitialMetadataInterceptor<Fn>::Call::OnClientToServerMessage;
-template <typename Fn>
-const NoInterceptor
-    ClientInitialMetadataInterceptor<Fn>::Call::OnClientToServerHalfClose;
-template <typename Fn>
-const NoInterceptor
-    ClientInitialMetadataInterceptor<Fn>::Call::OnServerToClientMessage;
-template <typename Fn>
-const NoInterceptor
-    ClientInitialMetadataInterceptor<Fn>::Call::OnServerTrailingMetadata;
-template <typename Fn>
-const NoInterceptor ClientInitialMetadataInterceptor<Fn>::Call::OnFinalize;
 
+// Determine if an interceptor needs to access the channel via one of its
+// arguments.
+
+template <typename T>
+constexpr bool MethodHasChannelAccess = false;
+
+template <typename T, typename R, typename A>
+constexpr bool MethodHasChannelAccess<R (T::*)(A)> = false;
+
+template <typename T, typename R>
+constexpr bool MethodHasChannelAccess<R (T::*)()> = false;
+
+template <typename T, typename R, typename A, typename C>
+constexpr bool MethodHasChannelAccess<R (T::*)(A, C)> = true;
+
+template <auto... Ts>
+constexpr bool AnyMethodHasChannelAccess =
+    (MethodHasChannelAccess<decltype(Ts)> || ...);
+
+// Composite for a given channel type to determine if any of its interceptors
+// fall into this category: later code should use this.
+template <typename Derived>
+inline constexpr bool CallHasChannelAccess() {
+  return AnyMethodHasChannelAccess<&Derived::Call::OnClientInitialMetadata,
+                                   &Derived::Call::OnClientToServerMessage,
+                                   &Derived::Call::OnServerInitialMetadata,
+                                   &Derived::Call::OnServerToClientMessage,
+                                   &Derived::Call::OnServerTrailingMetadata,
+                                   &Derived::Call::OnFinalize>;
+}
 }  // namespace filters_detail
 
 namespace for_each_detail {
@@ -1725,20 +1766,20 @@ class CallFilters {
               [this]() {
                 return Map(
                     MetadataExecutor<
-                        absl::optional<ServerMetadataHandle>,
+                        std::optional<ServerMetadataHandle>,
                         ServerMetadataHandle,
                         &CallFilters::push_server_initial_metadata_,
                         &filters_detail::StackData::server_initial_metadata,
                         &CallState::FinishPullServerInitialMetadata,
                         StacksVector::const_reverse_iterator>(
                         this, stacks_.crbegin(), stacks_.crend()),
-                    [](ValueOrFailure<absl::optional<ServerMetadataHandle>> r) {
+                    [](ValueOrFailure<std::optional<ServerMetadataHandle>> r) {
                       if (r.ok()) return std::move(*r);
-                      return absl::optional<ServerMetadataHandle>{};
+                      return std::optional<ServerMetadataHandle>{};
                     });
               },
               []() {
-                return Immediate(absl::optional<ServerMetadataHandle>{});
+                return Immediate(std::optional<ServerMetadataHandle>{});
               });
         });
   }
@@ -1811,6 +1852,8 @@ class CallFilters {
   // If no server initial metadata has been sent, implies
   // NoServerInitialMetadata() called.
   void PushServerTrailingMetadata(ServerMetadataHandle md);
+  // Optimized path to push cancellation onto the call
+  void Cancel();
   // Client: Fetch server trailing metadata
   // Returns a promise that resolves to ServerMetadataHandle
   GRPC_MUST_USE_RESULT auto PullServerTrailingMetadata() {
@@ -1837,6 +1880,12 @@ class CallFilters {
   GRPC_MUST_USE_RESULT auto WasCancelled() {
     return [this]() { return call_state_.PollWasCancelled(); };
   }
+  // Client & server: wait for server trailing metadata to be available, and
+  // resolve to empty when it is.
+  GRPC_MUST_USE_RESULT auto ServerTrailingMetadataWasPushed() {
+    return
+        [this]() { return call_state_.PollServerTrailingMetadataWasPushed(); };
+  }
   // Client & server: returns true if server trailing metadata has been pushed
   // *and* contained a cancellation, false otherwise.
   GRPC_MUST_USE_RESULT bool WasCancelledPushed() const {

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

@@ -26,43 +26,19 @@ namespace grpc_core {
 void ForwardCall(CallHandler call_handler, CallInitiator call_initiator,
                  absl::AnyInvocable<void(ServerMetadata&)>
                      on_server_trailing_metadata_from_initiator) {
+  call_handler.AddChildCall(call_initiator);
   // Read messages from handler into initiator.
   call_handler.SpawnInfallible(
       "read_messages", [call_handler, call_initiator]() mutable {
         return Seq(
-            ForEach(OutgoingMessages(call_handler),
+            ForEach(MessagesFrom(call_handler),
                     [call_initiator](MessageHandle msg) mutable {
                       // Need to spawn a job into the initiator's activity to
                       // push the message in.
-                      return call_initiator.SpawnWaitable(
-                          "send_message",
-                          [msg = std::move(msg), call_initiator]() mutable {
-                            return call_initiator.PushMessage(std::move(msg));
-                          });
+                      call_initiator.SpawnPushMessage(std::move(msg));
+                      return Success{};
                     }),
-            [call_initiator](StatusFlag result) mutable {
-              if (result.ok()) {
-                call_initiator.SpawnInfallible("finish-downstream-ok",
-                                               [call_initiator]() mutable {
-                                                 call_initiator.FinishSends();
-                                               });
-              }
-            });
-      });
-  call_handler.SpawnInfallible(
-      "check_cancellation", [call_handler, call_initiator]() mutable {
-        return Map(call_handler.WasCancelled(), [call_initiator =
-                                                     std::move(call_initiator)](
-                                                    bool cancelled) mutable {
-          if (cancelled) {
-            call_initiator.SpawnInfallible("propagate_handler_cancel",
-                                           [call_initiator]() mutable {
-                                             call_initiator.Cancel();
-                                             return Empty();
-                                           });
-          }
-          return Empty();
-        });
+            [call_initiator]() mutable { call_initiator.SpawnFinishSends(); });
       });
   call_initiator.SpawnInfallible(
       "read_the_things",
@@ -73,28 +49,19 @@ void ForwardCall(CallHandler call_handler, CallInitiator call_initiator,
             call_initiator.CancelIfFails(TrySeq(
                 call_initiator.PullServerInitialMetadata(),
                 [call_handler, call_initiator](
-                    absl::optional<ServerMetadataHandle> md) mutable {
+                    std::optional<ServerMetadataHandle> md) mutable {
                   const bool has_md = md.has_value();
                   return If(
                       has_md,
                       [&call_handler, &call_initiator,
                        md = std::move(md)]() mutable {
-                        call_handler.SpawnGuarded(
-                            "recv_initial_metadata",
-                            [md = std::move(*md), call_handler]() mutable {
-                              return call_handler.PushServerInitialMetadata(
-                                  std::move(md));
-                            });
+                        call_handler.SpawnPushServerInitialMetadata(
+                            std::move(*md));
                         return ForEach(
-                            OutgoingMessages(call_initiator),
+                            MessagesFrom(call_initiator),
                             [call_handler](MessageHandle msg) mutable {
-                              return call_handler.SpawnWaitable(
-                                  "recv_message", [msg = std::move(msg),
-                                                   call_handler]() mutable {
-                                    return call_handler.CancelIfFails(
-                                        call_handler.PushMessage(
-                                            std::move(msg)));
-                                  });
+                              call_handler.SpawnPushMessage(std::move(msg));
+                              return Success{};
                             });
                       },
                       []() -> StatusFlag { return Success{}; });
@@ -105,11 +72,7 @@ void ForwardCall(CallHandler call_handler, CallInitiator call_initiator,
                  std::move(on_server_trailing_metadata_from_initiator)](
                 ServerMetadataHandle md) mutable {
               on_server_trailing_metadata_from_initiator(*md);
-              call_handler.SpawnInfallible(
-                  "recv_trailing",
-                  [call_handler, md = std::move(md)]() mutable {
-                    call_handler.PushServerTrailingMetadata(std::move(md));
-                  });
+              call_handler.SpawnPushServerTrailingMetadata(std::move(md));
             });
       });
 }