grpc 1.59.5 → 1.60.0.pre1

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

@@ -28,12 +28,20 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack_trace.h"
 #include "src/core/lib/gpr/alloc.h"
+#include "src/core/lib/surface/channel_init.h"
 
 using grpc_event_engine::experimental::EventEngine;
 
 grpc_core::TraceFlag grpc_trace_channel(false, "channel");
-grpc_core::TraceFlag grpc_trace_channel_stack(false, "channel_stack");
+
+static int register_get_name_fn = []() {
+  grpc_core::NameFromChannelFilter = [](const grpc_channel_filter* filter) {
+    return filter->name;
+  };
+  return 0;
+}();
 
 // Memory layouts.
 

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

@@ -23,13 +23,10 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/support/log.h>
-
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/transport_fwd.h"
 
 namespace grpc_core {
 
@@ -53,16 +50,6 @@ class ChannelStackBuilder {
   // Query the target.
   absl::string_view target() const { return target_; }
 
-  // Set the transport.
-  ChannelStackBuilder& SetTransport(grpc_transport* transport) {
-    GPR_ASSERT(transport_ == nullptr);
-    transport_ = transport;
-    return *this;
-  }
-
-  // Query the transport.
-  grpc_transport* transport() const { return transport_; }
-
   // Query the channel args.
   const ChannelArgs& channel_args() const { return args_; }
 
@@ -77,6 +64,10 @@ class ChannelStackBuilder {
   // The type of channel stack being built.
   grpc_channel_stack_type channel_stack_type() const { return type_; }
 
+  // TODO(ctiller): re-evaluate the need for AppendFilter, PrependFilter.
+  // Their usefulness is largely zero now that we have ordering constraints in
+  // channel init.
+
   // Helper to add a filter to the front of the stack.
   void PrependFilter(const grpc_channel_filter* filter);
 
@@ -107,8 +98,6 @@ class ChannelStackBuilder {
   const grpc_channel_stack_type type_;
   // The target
   std::string target_{unknown_target()};
-  // The transport
-  grpc_transport* transport_ = nullptr;
   // Channel args
   ChannelArgs args_;
   // The in-progress stack

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

@@ -27,19 +27,15 @@
 
 #include "absl/status/status.h"
 
-#include <grpc/grpc.h>
 #include <grpc/support/alloc.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/debug/trace.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/surface/call_trace.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
@@ -82,20 +78,6 @@ ChannelStackBuilderImpl::Build() {
   auto* channel_stack =
       static_cast<grpc_channel_stack*>(gpr_zalloc(channel_stack_size));
 
-  ChannelArgs final_args = channel_args();
-  if (transport() != nullptr) {
-    static const grpc_arg_pointer_vtable vtable = {
-        // copy
-        [](void* p) { return p; },
-        // destroy
-        [](void*) {},
-        // cmp
-        [](void* a, void* b) { return QsortCompare(a, b); },
-    };
-    final_args = final_args.Set(GRPC_ARG_TRANSPORT,
-                                ChannelArgs::Pointer(transport(), &vtable));
-  }
-
   // and initialize it
   grpc_error_handle error = grpc_channel_stack_init(
       1,
@@ -104,7 +86,7 @@ ChannelStackBuilderImpl::Build() {
         grpc_channel_stack_destroy(stk);
         gpr_free(stk);
       },
-      channel_stack, stack.data(), stack.size(), final_args, name(),
+      channel_stack, stack.data(), stack.size(), channel_args(), name(),
       channel_stack);
 
   if (!error.ok()) {

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

@@ -0,0 +1,19 @@
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/channel/channel_stack_trace.h"
+
+grpc_core::TraceFlag grpc_trace_channel_stack(false, "channel_stack");

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

@@ -0,0 +1,24 @@
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_STACK_TRACE_H
+#define GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_STACK_TRACE_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/debug/trace.h"
+
+extern grpc_core::TraceFlag grpc_trace_channel_stack;
+
+#endif  // GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_STACK_TRACE_H

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

@@ -20,7 +20,7 @@
 
 #include "src/core/lib/channel/channel_trace.h"
 
-#include <algorithm>
+#include <memory>
 #include <utility>
 
 #include "absl/strings/str_cat.h"

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

@@ -23,7 +23,6 @@
 #include <inttypes.h>
 
 #include <functional>
-#include <initializer_list>
 #include <memory>
 #include <string>
 #include <type_traits>
@@ -32,7 +31,6 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/types/optional.h"
-#include "absl/types/variant.h"
 
 #include <grpc/grpc.h>
 #include <grpc/status.h>
@@ -43,6 +41,7 @@
 #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/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gpr/alloc.h"
@@ -80,11 +79,9 @@
 #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"
 
 typedef struct connected_channel_channel_data {
-  grpc_transport* transport;
+  grpc_core::Transport* transport;
 } channel_data;
 
 struct callback_state {
@@ -183,15 +180,15 @@ static void connected_channel_start_transport_stream_op_batch(
     callback_state* state = get_state_for_batch(calld, batch);
     intercept_callback(calld, state, false, "on_complete", &batch->on_complete);
   }
-  grpc_transport_perform_stream_op(
-      chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA(calld), batch);
+  chand->transport->filter_stack_transport()->PerformStreamOp(
+      TRANSPORT_STREAM_FROM_CALL_DATA(calld), batch);
   GRPC_CALL_COMBINER_STOP(calld->call_combiner, "passed batch to transport");
 }
 
 static void connected_channel_start_transport_op(grpc_channel_element* elem,
                                                  grpc_transport_op* op) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  grpc_transport_perform_op(chand->transport, op);
+  chand->transport->PerformOp(op);
 }
 
 // Constructor for call_data
@@ -200,19 +197,18 @@ static grpc_error_handle connected_channel_init_call_elem(
   call_data* calld = static_cast<call_data*>(elem->call_data);
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   calld->call_combiner = args->call_combiner;
-  int r = grpc_transport_init_stream(
-      chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA(calld),
-      &args->call_stack->refcount, args->server_transport_data, args->arena);
-  return r == 0 ? absl::OkStatus()
-                : GRPC_ERROR_CREATE("transport stream initialization failed");
+  chand->transport->filter_stack_transport()->InitStream(
+      TRANSPORT_STREAM_FROM_CALL_DATA(calld), &args->call_stack->refcount,
+      args->server_transport_data, args->arena);
+  return absl::OkStatus();
 }
 
 static void set_pollset_or_pollset_set(grpc_call_element* elem,
                                        grpc_polling_entity* pollent) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  grpc_transport_set_pops(chand->transport,
-                          TRANSPORT_STREAM_FROM_CALL_DATA(calld), pollent);
+  chand->transport->SetPollingEntity(TRANSPORT_STREAM_FROM_CALL_DATA(calld),
+                                     pollent);
 }
 
 // Destructor for call_data
@@ -221,9 +217,8 @@ static void connected_channel_destroy_call_elem(
     grpc_closure* then_schedule_closure) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  grpc_transport_destroy_stream(chand->transport,
-                                TRANSPORT_STREAM_FROM_CALL_DATA(calld),
-                                then_schedule_closure);
+  chand->transport->filter_stack_transport()->DestroyStream(
+      TRANSPORT_STREAM_FROM_CALL_DATA(calld), then_schedule_closure);
 }
 
 // Constructor for channel_data
@@ -231,7 +226,7 @@ static grpc_error_handle connected_channel_init_channel_elem(
     grpc_channel_element* elem, grpc_channel_element_args* args) {
   channel_data* cd = static_cast<channel_data*>(elem->channel_data);
   GPR_ASSERT(args->is_last);
-  cd->transport = args->channel_args.GetObject<grpc_transport>();
+  cd->transport = args->channel_args.GetObject<grpc_core::Transport>();
   return absl::OkStatus();
 }
 
@@ -239,7 +234,7 @@ static grpc_error_handle connected_channel_init_channel_elem(
 static void connected_channel_destroy_channel_elem(grpc_channel_element* elem) {
   channel_data* cd = static_cast<channel_data*>(elem->channel_data);
   if (cd->transport) {
-    grpc_transport_destroy(cd->transport);
+    cd->transport->Orphan();
   }
 }
 
@@ -255,7 +250,7 @@ namespace {
     defined(GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL)
 class ConnectedChannelStream : public Orphanable {
  public:
-  explicit ConnectedChannelStream(grpc_transport* transport)
+  explicit ConnectedChannelStream(Transport* transport)
       : transport_(transport), stream_(nullptr, StreamDeleter(this)) {
     GRPC_STREAM_REF_INIT(
         &stream_refcount_, 1,
@@ -265,7 +260,7 @@ class ConnectedChannelStream : public Orphanable {
         this, "ConnectedChannelStream");
   }
 
-  grpc_transport* transport() { return transport_; }
+  Transport* transport() { return transport_; }
   grpc_closure* stream_destroyed_closure() { return &stream_destroyed_; }
 
   BatchBuilder::Target batch_target() {
@@ -338,8 +333,8 @@ class ConnectedChannelStream : public Orphanable {
     explicit StreamDeleter(ConnectedChannelStream* impl) : impl_(impl) {}
     void operator()(grpc_stream* stream) const {
       if (stream == nullptr) return;
-      grpc_transport_destroy_stream(impl_->transport(), stream,
-                                    impl_->stream_destroyed_closure());
+      impl_->transport()->filter_stack_transport()->DestroyStream(
+          stream, impl_->stream_destroyed_closure());
     }
 
    private:
@@ -359,7 +354,7 @@ class ConnectedChannelStream : public Orphanable {
     }
   }
 
-  grpc_transport* const transport_;
+  Transport* const transport_;
   RefCountedPtr<CallContext> const call_context_{
       GetContext<CallContext>()->Ref()};
   grpc_closure stream_destroyed_ =
@@ -437,22 +432,22 @@ auto ConnectedChannelStream::SendMessages(
         // defined(GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL)
 
 #ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_CLIENT_CALL
-ArenaPromise<ServerMetadataHandle> MakeClientCallPromise(
-    grpc_transport* transport, CallArgs call_args, NextPromiseFactory) {
+ArenaPromise<ServerMetadataHandle> MakeClientCallPromise(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>());
+  stream->SetStream(static_cast<grpc_stream*>(GetContext<Arena>()->Alloc(
+      transport->filter_stack_transport()->SizeOfStream())));
+  transport->filter_stack_transport()->InitStream(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);
-      });
+  party->Spawn("set_polling_entity", call_args.polling_entity->Wait(),
+               [transport, stream = stream->InternalRef()](
+                   grpc_polling_entity polling_entity) {
+                 transport->SetPollingEntity(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.
@@ -574,15 +569,14 @@ ArenaPromise<ServerMetadataHandle> MakeClientCallPromise(
 
 #ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL
 ArenaPromise<ServerMetadataHandle> MakeServerCallPromise(
-    grpc_transport* transport, CallArgs,
-    NextPromiseFactory next_promise_factory) {
+    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(),
+  stream->SetStream(static_cast<grpc_stream*>(GetContext<Arena>()->Alloc(
+      transport->filter_stack_transport()->SizeOfStream())));
+  transport->filter_stack_transport()->InitStream(
+      stream->stream(), stream->stream_refcount(),
       GetContext<CallContext>()->server_call_context()->server_stream_data(),
       GetContext<Arena>());
   auto* party = static_cast<Party*>(Activity::current());
@@ -601,12 +595,11 @@ ArenaPromise<ServerMetadataHandle> MakeServerCallPromise(
   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);
-      });
+  party->Spawn("set_polling_entity", call_data->polling_entity_latch.Wait(),
+               [transport, stream = stream->InternalRef()](
+                   grpc_polling_entity polling_entity) {
+                 transport->SetPollingEntity(stream->stream(), &polling_entity);
+               });
 
   auto server_to_client_empty =
       call_data->server_to_client.receiver.AwaitEmpty();
@@ -847,7 +840,7 @@ ArenaPromise<ServerMetadataHandle> MakeServerCallPromise(
 #endif
 
 template <ArenaPromise<ServerMetadataHandle> (*make_call_promise)(
-    grpc_transport*, CallArgs, NextPromiseFactory)>
+    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
@@ -857,7 +850,7 @@ grpc_channel_filter MakeConnectedFilter() {
   // call be promise based.
   auto make_call_wrapper = +[](grpc_channel_element* elem, CallArgs call_args,
                                NextPromiseFactory next) {
-    grpc_transport* transport =
+    Transport* transport =
         static_cast<channel_data*>(elem->channel_data)->transport;
     return make_call_promise(transport, std::move(call_args), std::move(next));
   };
@@ -877,8 +870,10 @@ grpc_channel_filter MakeConnectedFilter() {
         // 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);
+        channel_stack->call_stack_size +=
+            static_cast<channel_data*>(elem->channel_data)
+                ->transport->filter_stack_transport()
+                ->SizeOfStream();
       },
       connected_channel_destroy_channel_elem,
       connected_channel_get_channel_info,
@@ -887,8 +882,8 @@ grpc_channel_filter MakeConnectedFilter() {
 }
 
 ArenaPromise<ServerMetadataHandle> MakeTransportCallPromise(
-    grpc_transport* transport, CallArgs call_args, NextPromiseFactory) {
-  return transport->vtable->make_call_promise(transport, std::move(call_args));
+    Transport* transport, CallArgs call_args, NextPromiseFactory) {
+  return transport->client_transport()->MakeCallPromise(std::move(call_args));
 }
 
 const grpc_channel_filter kPromiseBasedTransportFilter =
@@ -910,31 +905,49 @@ const grpc_channel_filter kServerEmulatedFilter =
     MakeConnectedFilter<nullptr>();
 #endif
 
+bool TransportSupportsPromiseBasedCalls(const ChannelArgs& args) {
+  auto* transport = args.GetObject<Transport>();
+  return transport->client_transport() != nullptr;
+}
+
 }  // namespace
-}  // namespace grpc_core
 
-bool grpc_add_connected_filter(grpc_core::ChannelStackBuilder* builder) {
-  grpc_transport* t = builder->transport();
-  GPR_ASSERT(t != nullptr);
-  // Choose the right vtable for the connected filter.
+void RegisterConnectedChannel(CoreConfiguration::Builder* 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.
-  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.
-    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.
-    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.
-    builder->AppendFilter(&grpc_core::kServerEmulatedFilter);
-  }
-  return true;
+
+  // Option 1, and our ideal: the transport supports promise based calls,
+  // and so we simply use the transport directly.
+  builder->channel_init()
+      ->RegisterFilter(GRPC_CLIENT_SUBCHANNEL, &kPromiseBasedTransportFilter)
+      .Terminal()
+      .If(TransportSupportsPromiseBasedCalls);
+  builder->channel_init()
+      ->RegisterFilter(GRPC_CLIENT_DIRECT_CHANNEL,
+                       &kPromiseBasedTransportFilter)
+      .Terminal()
+      .If(TransportSupportsPromiseBasedCalls);
+  builder->channel_init()
+      ->RegisterFilter(GRPC_SERVER_CHANNEL, &kPromiseBasedTransportFilter)
+      .Terminal()
+      .If(TransportSupportsPromiseBasedCalls);
+
+  // Option 2: the transport does not support promise based calls.
+  builder->channel_init()
+      ->RegisterFilter(GRPC_CLIENT_SUBCHANNEL, &kClientEmulatedFilter)
+      .Terminal()
+      .IfNot(TransportSupportsPromiseBasedCalls);
+  builder->channel_init()
+      ->RegisterFilter(GRPC_CLIENT_DIRECT_CHANNEL, &kClientEmulatedFilter)
+      .Terminal()
+      .IfNot(TransportSupportsPromiseBasedCalls);
+  builder->channel_init()
+      ->RegisterFilter(GRPC_SERVER_CHANNEL, &kServerEmulatedFilter)
+      .Terminal()
+      .IfNot(TransportSupportsPromiseBasedCalls);
 }
+
+}  // namespace grpc_core

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

@@ -56,6 +56,9 @@ typedef enum {
   /// the server.
   GRPC_CONTEXT_BACKEND_METRIC_PROVIDER,
 
+  /// Special Google context
+  GRPC_CONTEXT_GOOGLE,
+
   GRPC_CONTEXT_COUNT
 } grpc_context_index;
 

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

@@ -17,7 +17,6 @@
 #include "src/core/lib/channel/promise_based_filter.h"
 
 #include <algorithm>
-#include <initializer_list>
 #include <memory>
 #include <string>
 #include <utility>
@@ -721,7 +720,7 @@ void BaseCallData::ReceiveMessage::OnComplete(absl::Status status) {
       Crash(absl::StrFormat("ILLEGAL STATE: %s", StateString(state_)));
     case State::kForwardedBatchNoPipe:
       state_ = State::kBatchCompletedNoPipe;
-      return;
+      break;
     case State::kForwardedBatch:
       state_ = State::kBatchCompleted;
       break;
@@ -784,6 +783,8 @@ void BaseCallData::ReceiveMessage::Done(const ServerMetadata& metadata,
       }
     } break;
     case State::kBatchCompletedNoPipe:
+      state_ = State::kBatchCompletedButCancelledNoPipe;
+      break;
     case State::kBatchCompletedButCancelled:
     case State::kBatchCompletedButCancelledNoPipe:
       Crash(absl::StrFormat("ILLEGAL STATE: %s", StateString(state_)));
@@ -1313,10 +1314,13 @@ ClientCallData::ClientCallData(grpc_call_element* elem,
 }
 
 ClientCallData::~ClientCallData() {
+  ScopedActivity scoped_activity(this);
   GPR_ASSERT(poll_ctx_ == nullptr);
   if (recv_initial_metadata_ != nullptr) {
     recv_initial_metadata_->~RecvInitialMetadata();
   }
+  initial_metadata_outstanding_token_ =
+      ClientInitialMetadataOutstandingToken::Empty();
 }
 
 std::string ClientCallData::DebugTag() const {

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

@@ -25,7 +25,6 @@
 #include <stdlib.h>
 
 #include <atomic>
-#include <initializer_list>
 #include <memory>
 #include <new>
 #include <string>

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

@@ -27,7 +27,6 @@
 #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/channel_stack_builder.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/config/core_configuration.h"
@@ -36,8 +35,6 @@
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/pipe.h"
-#include "src/core/lib/promise/poll.h"
-#include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/transport.h"
 
@@ -99,12 +96,8 @@ ArenaPromise<ServerMetadataHandle> ServerCallTracerFilter::MakeCallPromise(
 }  // namespace
 
 void RegisterServerCallTracerFilter(CoreConfiguration::Builder* builder) {
-  builder->channel_init()->RegisterStage(
-      GRPC_SERVER_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      [](ChannelStackBuilder* builder) {
-        builder->AppendFilter(&ServerCallTracerFilter::kFilter);
-        return true;
-      });
+  builder->channel_init()->RegisterFilter(GRPC_SERVER_CHANNEL,
+                                          &ServerCallTracerFilter::kFilter);
 }
 
 }  // namespace grpc_core

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

@@ -22,7 +22,6 @@
 
 #include <string.h>
 
-#include <algorithm>
 #include <vector>
 
 #include "absl/strings/str_cat.h"