grpc 1.61.0 → 1.62.0.pre1

data/src/core/lib/security/transport/legacy_server_auth_filter.cc

@@ -124,7 +124,7 @@ class LegacyServerAuthFilter::RunApplicationCode {
       gpr_log(GPR_ERROR,
               "%s[server-auth]: Delegate to application: filter=%p this=%p "
               "auth_ctx=%p",
-              Activity::current()->DebugTag().c_str(), filter, this,
+              GetContext<Activity>()->DebugTag().c_str(), filter, this,
               filter->auth_context_.get());
     }
     filter->server_credentials_->auth_metadata_processor().process(
@@ -152,7 +152,7 @@ class LegacyServerAuthFilter::RunApplicationCode {
  private:
   struct State {
     explicit State(CallArgs call_args) : call_args(std::move(call_args)) {}
-    Waker waker{Activity::current()->MakeOwningWaker()};
+    Waker waker{GetContext<Activity>()->MakeOwningWaker()};
     absl::StatusOr<CallArgs> call_args;
     grpc_metadata_array md =
         MetadataBatchToMetadataArray(call_args->client_initial_metadata.get());

data/src/core/lib/security/transport/security_handshaker.cc

@@ -671,11 +671,3 @@ void SecurityRegisterHandshakerFactories(CoreConfiguration::Builder* builder) {
 }
 
 }  // namespace grpc_core
-
-grpc_handshaker* grpc_security_handshaker_create(
-    tsi_handshaker* handshaker, grpc_security_connector* connector,
-    const grpc_channel_args* args) {
-  return SecurityHandshakerCreate(handshaker, connector,
-                                  grpc_core::ChannelArgs::FromC(args))
-      .release();
-}

data/src/core/lib/security/transport/security_handshaker.h

@@ -42,10 +42,4 @@ void SecurityRegisterHandshakerFactories(CoreConfiguration::Builder*);
 
 }  // namespace grpc_core
 
-// TODO(arjunroy): This is transitional to account for the new handshaker API
-// and will eventually be removed entirely.
-grpc_handshaker* grpc_security_handshaker_create(
-    tsi_handshaker* handshaker, grpc_security_connector* connector,
-    const grpc_channel_args* args);
-
 #endif  // GRPC_SRC_CORE_LIB_SECURITY_TRANSPORT_SECURITY_HANDSHAKER_H

data/src/core/lib/security/transport/server_auth_filter.cc

@@ -123,7 +123,7 @@ grpc_metadata_array MetadataBatchToMetadataArray(
 struct ServerAuthFilter::RunApplicationCode::State {
   explicit State(ClientMetadata& client_metadata)
       : client_metadata(&client_metadata) {}
-  Waker waker{Activity::current()->MakeOwningWaker()};
+  Waker waker{GetContext<Activity>()->MakeOwningWaker()};
   absl::StatusOr<ClientMetadata*> client_metadata;
   grpc_metadata_array md = MetadataBatchToMetadataArray(*client_metadata);
   std::atomic<bool> done{false};
@@ -136,7 +136,7 @@ ServerAuthFilter::RunApplicationCode::RunApplicationCode(
     gpr_log(GPR_ERROR,
             "%s[server-auth]: Delegate to application: filter=%p this=%p "
             "auth_ctx=%p",
-            Activity::current()->DebugTag().c_str(), filter, this,
+            GetContext<Activity>()->DebugTag().c_str(), filter, this,
             filter->auth_context_.get());
   }
   filter->server_credentials_->auth_metadata_processor().process(

data/src/core/lib/slice/slice_buffer.h

@@ -113,7 +113,9 @@ class SliceBuffer {
   }
 
   /// Removes and unrefs all slices in the SliceBuffer.
-  void Clear() { grpc_slice_buffer_reset_and_unref(&slice_buffer_); }
+  GRPC_REINITIALIZES void Clear() {
+    grpc_slice_buffer_reset_and_unref(&slice_buffer_);
+  }
 
   /// Removes the first slice in the SliceBuffer and returns it.
   Slice TakeFirst();

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

@@ -412,8 +412,7 @@ void Call::DeleteThis() {
   RefCountedPtr<Channel> channel = std::move(channel_);
   Arena* arena = arena_;
   this->~Call();
-  channel->UpdateCallSizeEstimate(arena->TotalUsedBytes());
-  arena->Destroy();
+  channel->DestroyArena(arena);
 }
 
 void Call::PrepareOutgoingInitialMetadata(const grpc_op& op,
@@ -814,20 +813,15 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
     *composite = grpc_error_add_child(*composite, new_err);
   };
 
-  Arena* arena;
   FilterStackCall* call;
   grpc_error_handle error;
   grpc_channel_stack* channel_stack = channel->channel_stack();
-  size_t initial_size = channel->CallSizeEstimate();
-  global_stats().IncrementCallInitialSize(initial_size);
   size_t call_alloc_size =
       GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(FilterStackCall)) +
       channel_stack->call_stack_size;
 
-  std::pair<Arena*, void*> arena_with_call = Arena::CreateWithAlloc(
-      initial_size, call_alloc_size, channel->allocator());
-  arena = arena_with_call.first;
-  call = new (arena_with_call.second) FilterStackCall(arena, *args);
+  Arena* arena = channel->CreateArena();
+  call = new (arena->Alloc(call_alloc_size)) FilterStackCall(arena, *args);
   GPR_DEBUG_ASSERT(FromC(call->c_ptr()) == call);
   GPR_DEBUG_ASSERT(FromCallStack(call->call_stack()) == call);
   *out_call = call->c_ptr();
@@ -1998,10 +1992,11 @@ class BasicPromiseBasedCall : public Call,
   using Call::arena;
 
   BasicPromiseBasedCall(Arena* arena, uint32_t initial_external_refs,
+                        uint32_t initial_internal_refs,
                         const grpc_call_create_args& args)
       : Call(arena, args.server_transport_data == nullptr, args.send_deadline,
              args.channel->Ref()),
-        Party(arena, initial_external_refs != 0 ? 1 : 0),
+        Party(arena, initial_internal_refs),
         external_refs_(initial_external_refs),
         cq_(args.cq) {
     if (args.cq != nullptr) {
@@ -2189,19 +2184,21 @@ void BasicPromiseBasedCall::UpdateDeadline(Timestamp deadline) {
 }
 
 void BasicPromiseBasedCall::ResetDeadline() {
-  MutexLock lock(&deadline_mu_);
-  if (deadline_ == Timestamp::InfFuture()) return;
-  auto* const event_engine = channel()->event_engine();
-  if (!event_engine->Cancel(deadline_task_)) return;
-  deadline_ = Timestamp::InfFuture();
-  InternalUnref("deadline");
+  {
+    MutexLock lock(&deadline_mu_);
+    if (deadline_ == Timestamp::InfFuture()) return;
+    auto* const event_engine = channel()->event_engine();
+    if (!event_engine->Cancel(deadline_task_)) return;
+    deadline_ = Timestamp::InfFuture();
+  }
+  InternalUnref("deadline[reset]");
 }
 
 void BasicPromiseBasedCall::Run() {
   ApplicationCallbackExecCtx callback_exec_ctx;
   ExecCtx exec_ctx;
   CancelWithError(absl::DeadlineExceededError("Deadline exceeded"));
-  InternalUnref("deadline");
+  InternalUnref("deadline[run]");
 }
 
 class PromiseBasedCall : public BasicPromiseBasedCall {
@@ -2488,11 +2485,8 @@ grpc_error_handle MakePromiseBasedCall(grpc_call_create_args* args,
                                        grpc_call** out_call) {
   Channel* channel = args->channel.get();
 
-  const auto initial_size = channel->CallSizeEstimate();
-  global_stats().IncrementCallInitialSize(initial_size);
-  auto alloc =
-      Arena::CreateWithAlloc(initial_size, sizeof(T), channel->allocator());
-  PromiseBasedCall* call = new (alloc.second) T(alloc.first, args);
+  auto* arena = channel->CreateArena();
+  PromiseBasedCall* call = arena->New<T>(arena, args);
   *out_call = call->c_ptr();
   GPR_DEBUG_ASSERT(Call::FromC(*out_call) == call);
   return absl::OkStatus();
@@ -2500,7 +2494,8 @@ grpc_error_handle MakePromiseBasedCall(grpc_call_create_args* args,
 
 PromiseBasedCall::PromiseBasedCall(Arena* arena, uint32_t initial_external_refs,
                                    const grpc_call_create_args& args)
-    : BasicPromiseBasedCall(arena, initial_external_refs, args) {}
+    : BasicPromiseBasedCall(arena, initial_external_refs,
+                            initial_external_refs != 0 ? 1 : 0, args) {}
 
 static void CToMetadata(grpc_metadata* metadata, size_t count,
                         grpc_metadata_batch* b) {
@@ -2845,24 +2840,24 @@ class ClientPromiseBasedCall final : public PromiseBasedCall {
                         ClientMetadataHandle metadata)
           : call_(call) {
         call_->InternalRef("call-spine");
-        SpawnInfallible("send_client_initial_metadata",
-                        [this, metadata = std::move(metadata)]() mutable {
-                          return Map(client_initial_metadata_.sender.Push(
-                                         std::move(metadata)),
-                                     [](bool) { return Empty{}; });
-                        });
-        SpawnInfallible("monitor_cancellation", [this]() {
-          return Seq(cancel_error_.Wait(),
-                     [this](ServerMetadataHandle trailing_metadata) {
-                       Crash("here");
-                       return Map(server_trailing_metadata_.sender.Push(
-                                      std::move(trailing_metadata)),
-                                  [](bool) { return Empty{}; });
-                     });
-        });
+        SpawnInfallible(
+            "send_client_initial_metadata",
+            [self = Ref(), metadata = std::move(metadata)]() mutable {
+              return Map(self->client_initial_metadata_.sender.Push(
+                             std::move(metadata)),
+                         [self](bool) { return Empty{}; });
+            });
       }
 
-      ~WrappingCallSpine() override { call_->InternalUnref("call-spine"); }
+      ~WrappingCallSpine() override {
+        {
+          ScopedContext context(call_);
+          // Move these out and destroy before the internal unref.
+          auto client_initial_metadata = std::move(client_initial_metadata_);
+          auto server_trailing_metadata = std::move(server_trailing_metadata_);
+        }
+        call_->InternalUnref("call-spine");
+      }
 
       Pipe<ClientMetadataHandle>& client_initial_metadata() override {
         return client_initial_metadata_;
@@ -2894,6 +2889,10 @@ class ClientPromiseBasedCall final : public PromiseBasedCall {
       void Unref() override {
         if (refs_.Unref()) delete this;
       }
+      RefCountedPtr<WrappingCallSpine> Ref() {
+        IncrementRefCount();
+        return RefCountedPtr<WrappingCallSpine>(this);
+      }
 
      private:
       RefCount refs_;
@@ -2909,6 +2908,7 @@ class ClientPromiseBasedCall final : public PromiseBasedCall {
                &client_to_server_messages_.receiver);
     GPR_ASSERT(call_args.server_to_client_messages ==
                &server_to_client_messages_.sender);
+    call_args.client_initial_metadata_outstanding.Complete(true);
     return MakeRefCounted<WrappingCallSpine>(
         this, std::move(call_args.client_initial_metadata));
   }
@@ -3737,7 +3737,10 @@ class ServerCallSpine final : public CallSpineInterface,
   void Unref() override { InternalUnref("CallSpine"); }
 
   // PromiseBasedCall
-  void OrphanCall() override {}
+  void OrphanCall() override {
+    ResetDeadline();
+    CancelWithError(absl::CancelledError());
+  }
   void CancelWithError(grpc_error_handle error) override {
     SpawnInfallible("CancelWithError", [this, error = std::move(error)] {
       std::ignore = Cancel(ServerMetadataFromStatus(error));
@@ -3798,20 +3801,27 @@ class ServerCallSpine final : public CallSpineInterface,
 };
 
 ServerCallSpine::ServerCallSpine(Server* server, Channel* channel, Arena* arena)
-    : BasicPromiseBasedCall(
-          arena, 1, [channel, server]() -> grpc_call_create_args {
-            grpc_call_create_args args;
-            args.channel = channel->Ref();
-            args.server = server;
-            args.parent = nullptr;
-            args.propagation_mask = 0;
-            args.cq = nullptr;
-            args.pollset_set_alternative = nullptr;
-            args.server_transport_data = &args;  // Arbitrary non-null pointer
-            args.send_deadline = Timestamp::InfFuture();
-            return args;
-          }()) {
+    : BasicPromiseBasedCall(arena, 0, 1,
+                            [channel, server]() -> grpc_call_create_args {
+                              grpc_call_create_args args;
+                              args.channel = channel->Ref();
+                              args.server = server;
+                              args.parent = nullptr;
+                              args.propagation_mask = 0;
+                              args.cq = nullptr;
+                              args.pollset_set_alternative = nullptr;
+                              args.server_transport_data =
+                                  &args;  // Arbitrary non-null pointer
+                              args.send_deadline = Timestamp::InfFuture();
+                              return args;
+                            }()),
+      client_initial_metadata_(arena),
+      server_initial_metadata_(arena),
+      client_to_server_messages_(arena),
+      server_to_client_messages_(arena),
+      server_trailing_metadata_(arena) {
   global_stats().IncrementServerCallsCreated();
+  ScopedContext ctx(this);
   channel->channel_stack()->InitServerCallSpine(this);
 }
 
@@ -3851,14 +3861,17 @@ class MaybeOpImpl {
   struct Dismissed {};
   using State = absl::variant<Dismissed, PromiseFactory, Promise>;
 
-  MaybeOpImpl() : state_(Dismissed{}) {}
-  explicit MaybeOpImpl(SetupResult result)
-      : state_(PromiseFactory(std::move(result))) {}
+  // op_ is garbage but shouldn't be uninitialized
+  MaybeOpImpl() : state_(Dismissed{}), op_(GRPC_OP_RECV_STATUS_ON_CLIENT) {}
+  MaybeOpImpl(SetupResult result, grpc_op_type op)
+      : state_(PromiseFactory(std::move(result))), op_(op) {}
 
   MaybeOpImpl(const MaybeOpImpl&) = delete;
   MaybeOpImpl& operator=(const MaybeOpImpl&) = delete;
-  MaybeOpImpl(MaybeOpImpl&& other) noexcept : state_(MoveState(other.state_)) {}
+  MaybeOpImpl(MaybeOpImpl&& other) noexcept
+      : state_(MoveState(other.state_)), op_(other.op_) {}
   MaybeOpImpl& operator=(MaybeOpImpl&& other) noexcept {
+    op_ = other.op_;
     if (absl::holds_alternative<Dismissed>(state_)) {
       state_.template emplace<Dismissed>();
       return *this;
@@ -3876,12 +3889,45 @@ class MaybeOpImpl {
       auto promise = factory.Make();
       state_.template emplace<Promise>(std::move(promise));
     }
+    if (grpc_call_trace.enabled()) {
+      gpr_log(GPR_INFO, "%sBeginPoll %s",
+              Activity::current()->DebugTag().c_str(), OpName(op_).c_str());
+    }
     auto& promise = absl::get<Promise>(state_);
-    return poll_cast<StatusFlag>(promise());
+    auto r = poll_cast<StatusFlag>(promise());
+    if (grpc_call_trace.enabled()) {
+      gpr_log(GPR_INFO, "%sEndPoll %s --> %s",
+              Activity::current()->DebugTag().c_str(), OpName(op_).c_str(),
+              r.pending() ? "PENDING" : (r.value().ok() ? "OK" : "FAILURE"));
+    }
+    return r;
   }
 
  private:
-  State state_;
+  GPR_NO_UNIQUE_ADDRESS State state_;
+  GPR_NO_UNIQUE_ADDRESS grpc_op_type op_;
+
+  static std::string OpName(grpc_op_type op) {
+    switch (op) {
+      case GRPC_OP_SEND_INITIAL_METADATA:
+        return "SendInitialMetadata";
+      case GRPC_OP_SEND_MESSAGE:
+        return "SendMessage";
+      case GRPC_OP_SEND_STATUS_FROM_SERVER:
+        return "SendStatusFromServer";
+      case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
+        return "SendCloseFromClient";
+      case GRPC_OP_RECV_MESSAGE:
+        return "RecvMessage";
+      case GRPC_OP_RECV_CLOSE_ON_SERVER:
+        return "RecvCloseOnServer";
+      case GRPC_OP_RECV_INITIAL_METADATA:
+        return "RecvInitialMetadata";
+      case GRPC_OP_RECV_STATUS_ON_CLIENT:
+        return "RecvStatusOnClient";
+    }
+    return absl::StrCat("UnknownOp(", op, ")");
+  }
 
   static State MoveState(State& state) {
     if (absl::holds_alternative<Dismissed>(state)) return Dismissed{};
@@ -3903,9 +3949,42 @@ auto MaybeOp(const grpc_op* ops, uint8_t idx, SetupFn setup) {
   if (idx == 255) {
     return MaybeOpImpl<SetupFn>();
   } else {
-    return MaybeOpImpl<SetupFn>(setup(ops[idx]));
+    return MaybeOpImpl<SetupFn>(setup(ops[idx]), ops[idx].op);
   }
 }
+
+template <typename F>
+class PollBatchLogger {
+ public:
+  PollBatchLogger(void* tag, F f) : tag_(tag), f_(std::move(f)) {}
+
+  auto operator()() {
+    if (grpc_call_trace.enabled()) {
+      gpr_log(GPR_INFO, "Poll batch %p", tag_);
+    }
+    auto r = f_();
+    if (grpc_call_trace.enabled()) {
+      gpr_log(GPR_INFO, "Poll batch %p --> %s", tag_, ResultString(r).c_str());
+    }
+    return r;
+  }
+
+ private:
+  template <typename T>
+  static std::string ResultString(Poll<T> r) {
+    if (r.pending()) return "PENDING";
+    return ResultString(r.value());
+  }
+  static std::string ResultString(Empty) { return "DONE"; }
+
+  void* tag_;
+  F f_;
+};
+
+template <typename F>
+PollBatchLogger<F> LogPollBatch(void* tag, F f) {
+  return PollBatchLogger<F>(tag, std::move(f));
+}
 }  // namespace
 
 StatusFlag ServerCallSpine::FinishRecvMessage(
@@ -3929,6 +4008,7 @@ StatusFlag ServerCallSpine::FinishRecvMessage(
               DebugTag().c_str(),
               (*recv_message_)->data.raw.slice_buffer.length);
     }
+    recv_message_ = nullptr;
     return Success{};
   }
   if (result.cancelled()) {
@@ -3939,6 +4019,7 @@ StatusFlag ServerCallSpine::FinishRecvMessage(
               DebugTag().c_str());
     }
     *recv_message_ = nullptr;
+    recv_message_ = nullptr;
     return Failure{};
   }
   if (grpc_call_trace.enabled()) {
@@ -3948,6 +4029,7 @@ StatusFlag ServerCallSpine::FinishRecvMessage(
             DebugTag().c_str());
   }
   *recv_message_ = nullptr;
+  recv_message_ = nullptr;
   return Success{};
 }
 
@@ -4031,9 +4113,9 @@ void ServerCallSpine::CommitBatch(const grpc_op* ops, size_t nops,
         ops, got_ops[GRPC_OP_RECV_CLOSE_ON_SERVER], [this](const grpc_op& op) {
           return [this, cancelled = op.data.recv_close_on_server.cancelled]() {
             return Map(server_trailing_metadata_.receiver.AwaitClosed(),
-                       [cancelled](bool result) -> Success {
+                       [cancelled, this](bool result) -> Success {
+                         ResetDeadline();
                          *cancelled = result ? 1 : 0;
-                         Crash("return metadata here");
                          return Success{};
                        });
           };
@@ -4043,22 +4125,26 @@ void ServerCallSpine::CommitBatch(const grpc_op* ops, size_t nops,
         [primary_ops = std::move(primary_ops),
          recv_trailing_metadata = std::move(recv_trailing_metadata),
          is_notify_tag_closure, notify_tag, this]() mutable {
-          return Seq(std::move(primary_ops), std::move(recv_trailing_metadata),
-                     [is_notify_tag_closure, notify_tag, this](StatusFlag) {
-                       return WaitForCqEndOp(is_notify_tag_closure, notify_tag,
-                                             absl::OkStatus(), cq());
-                     });
+          return LogPollBatch(
+              notify_tag,
+              Seq(std::move(primary_ops), std::move(recv_trailing_metadata),
+                  [is_notify_tag_closure, notify_tag, this](StatusFlag) {
+                    return WaitForCqEndOp(is_notify_tag_closure, notify_tag,
+                                          absl::OkStatus(), cq());
+                  }));
         });
   } else {
-    SpawnInfallible(
-        "batch", [primary_ops = std::move(primary_ops), is_notify_tag_closure,
-                  notify_tag, this]() mutable {
-          return Seq(std::move(primary_ops), [is_notify_tag_closure, notify_tag,
-                                              this](StatusFlag r) {
-            return WaitForCqEndOp(is_notify_tag_closure, notify_tag,
-                                  StatusCast<grpc_error_handle>(r), cq());
-          });
-        });
+    SpawnInfallible("batch", [primary_ops = std::move(primary_ops),
+                              is_notify_tag_closure, notify_tag,
+                              this]() mutable {
+      return LogPollBatch(
+          notify_tag,
+          Seq(std::move(primary_ops),
+              [is_notify_tag_closure, notify_tag, this](StatusFlag r) {
+                return WaitForCqEndOp(is_notify_tag_closure, notify_tag,
+                                      StatusCast<grpc_error_handle>(r), cq());
+              }));
+    });
   }
 }
 

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

@@ -56,22 +56,22 @@ const grpc_channel_filter* PromiseTracingFilterFor(
                 gpr_log(
                     GPR_DEBUG,
                     "%s[%s] CreateCallPromise: client_initial_metadata=%s",
-                    Activity::current()->DebugTag().c_str(),
+                    GetContext<Activity>()->DebugTag().c_str(),
                     source_filter->name,
                     call_args.client_initial_metadata->DebugString().c_str());
                 return [source_filter, child = next_promise_factory(
                                            std::move(call_args))]() mutable {
                   gpr_log(GPR_DEBUG, "%s[%s] PollCallPromise: begin",
-                          Activity::current()->DebugTag().c_str(),
+                          GetContext<Activity>()->DebugTag().c_str(),
                           source_filter->name);
                   auto r = child();
                   if (auto* p = r.value_if_ready()) {
                     gpr_log(GPR_DEBUG, "%s[%s] PollCallPromise: done: %s",
-                            Activity::current()->DebugTag().c_str(),
+                            GetContext<Activity>()->DebugTag().c_str(),
                             source_filter->name, (*p)->DebugString().c_str());
                   } else {
                     gpr_log(GPR_DEBUG, "%s[%s] PollCallPromise: <<pending>>",
-                            Activity::current()->DebugTag().c_str(),
+                            GetContext<Activity>()->DebugTag().c_str(),
                             source_filter->name);
                   }
                   return r;
@@ -84,35 +84,35 @@ const grpc_channel_filter* PromiseTracingFilterFor(
                 call->client_initial_metadata().receiver.InterceptAndMap(
                     [source_filter](ClientMetadataHandle md) {
                       gpr_log(GPR_DEBUG, "%s[%s] OnClientInitialMetadata: %s",
-                              Activity::current()->DebugTag().c_str(),
+                              GetContext<Activity>()->DebugTag().c_str(),
                               source_filter->name, md->DebugString().c_str());
                       return md;
                     });
                 call->client_to_server_messages().receiver.InterceptAndMap(
                     [source_filter](MessageHandle msg) {
                       gpr_log(GPR_DEBUG, "%s[%s] OnClientToServerMessage: %s",
-                              Activity::current()->DebugTag().c_str(),
+                              GetContext<Activity>()->DebugTag().c_str(),
                               source_filter->name, msg->DebugString().c_str());
                       return msg;
                     });
                 call->server_initial_metadata().sender.InterceptAndMap(
                     [source_filter](ServerMetadataHandle md) {
                       gpr_log(GPR_DEBUG, "%s[%s] OnServerInitialMetadata: %s",
-                              Activity::current()->DebugTag().c_str(),
+                              GetContext<Activity>()->DebugTag().c_str(),
                               source_filter->name, md->DebugString().c_str());
                       return md;
                     });
                 call->server_to_client_messages().sender.InterceptAndMap(
                     [source_filter](MessageHandle msg) {
                       gpr_log(GPR_DEBUG, "%s[%s] OnServerToClientMessage: %s",
-                              Activity::current()->DebugTag().c_str(),
+                              GetContext<Activity>()->DebugTag().c_str(),
                               source_filter->name, msg->DebugString().c_str());
                       return msg;
                     });
                 call->server_trailing_metadata().sender.InterceptAndMap(
                     [source_filter](ServerMetadataHandle md) {
                       gpr_log(GPR_DEBUG, "%s[%s] OnServerTrailingMetadata: %s",
-                              Activity::current()->DebugTag().c_str(),
+                              GetContext<Activity>()->DebugTag().c_str(),
                               source_filter->name, md->DebugString().c_str());
                       return md;
                     });

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

@@ -58,12 +58,25 @@
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/init_internally.h"
+#include "src/core/lib/transport/call_factory.h"
 #include "src/core/lib/transport/transport.h"
 
 // IWYU pragma: no_include <type_traits>
 
 namespace grpc_core {
 
+namespace {
+
+class NotReallyACallFactory final : public CallFactory {
+ public:
+  using CallFactory::CallFactory;
+  CallInitiator CreateCall(ClientMetadataHandle, Arena*) override {
+    Crash("NotReallyACallFactory::CreateCall should never be called");
+  }
+};
+
+}  // namespace
+
 Channel::Channel(bool is_client, bool is_promising, std::string target,
                  const ChannelArgs& channel_args,
                  grpc_compression_options compression_options,
@@ -71,14 +84,10 @@ Channel::Channel(bool is_client, bool is_promising, std::string target,
     : is_client_(is_client),
       is_promising_(is_promising),
       compression_options_(compression_options),
-      call_size_estimate_(channel_stack->call_stack_size +
-                          grpc_call_get_initial_size_estimate()),
       channelz_node_(channel_args.GetObjectRef<channelz::ChannelNode>()),
-      allocator_(channel_args.GetObject<ResourceQuota>()
-                     ->memory_quota()
-                     ->CreateMemoryOwner()),
       target_(std::move(target)),
-      channel_stack_(std::move(channel_stack)) {
+      channel_stack_(std::move(channel_stack)),
+      call_factory_(MakeRefCounted<NotReallyACallFactory>(channel_args)) {
   // We need to make sure that grpc_shutdown() does not shut things down
   // until after the channel is destroyed.  However, the channel may not
   // actually be destroyed by the time grpc_channel_destroy() returns,
@@ -230,24 +239,6 @@ absl::StatusOr<RefCountedPtr<Channel>> Channel::Create(
   return CreateWithBuilder(&builder);
 }
 
-void Channel::UpdateCallSizeEstimate(size_t size) {
-  size_t cur = call_size_estimate_.load(std::memory_order_relaxed);
-  if (cur < size) {
-    // size grew: update estimate
-    call_size_estimate_.compare_exchange_weak(
-        cur, size, std::memory_order_relaxed, std::memory_order_relaxed);
-    // if we lose: never mind, something else will likely update soon enough
-  } else if (cur == size) {
-    // no change: holding pattern
-  } else if (cur > 0) {
-    // size shrank: decrease estimate
-    call_size_estimate_.compare_exchange_weak(
-        cur, std::min(cur - 1, (255 * cur + size) / 256),
-        std::memory_order_relaxed, std::memory_order_relaxed);
-    // if we lose: never mind, something else will likely update soon enough
-  }
-}
-
 }  // namespace grpc_core
 
 char* grpc_channel_get_target(grpc_channel* channel) {

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

@@ -52,9 +52,9 @@
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
-#include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/transport/call_factory.h"
 #include "src/core/lib/transport/transport.h"
 
 /// The same as grpc_channel_destroy, but doesn't create an ExecCtx, and so
@@ -80,9 +80,6 @@ grpc_channel_stack* grpc_channel_get_channel_stack(grpc_channel* channel);
 grpc_core::channelz::ChannelNode* grpc_channel_get_channelz_node(
     grpc_channel* channel);
 
-size_t grpc_channel_get_call_size_estimate(grpc_channel* channel);
-void grpc_channel_update_call_size_estimate(grpc_channel* channel, size_t size);
-
 namespace grpc_core {
 
 struct RegisteredCall {
@@ -124,22 +121,10 @@ class Channel : public RefCounted<Channel>,
 
   channelz::ChannelNode* channelz_node() const { return channelz_node_.get(); }
 
-  size_t CallSizeEstimate() {
-    // We round up our current estimate to the NEXT value of kRoundUpSize.
-    // This ensures:
-    //  1. a consistent size allocation when our estimate is drifting slowly
-    //     (which is common) - which tends to help most allocators reuse memory
-    //  2. a small amount of allowed growth over the estimate without hitting
-    //     the arena size doubling case, reducing overall memory usage
-    static constexpr size_t kRoundUpSize = 256;
-    return (call_size_estimate_.load(std::memory_order_relaxed) +
-            2 * kRoundUpSize) &
-           ~(kRoundUpSize - 1);
-  }
+  Arena* CreateArena() { return call_factory_->CreateArena(); }
+  void DestroyArena(Arena* arena) { return call_factory_->DestroyArena(arena); }
 
-  void UpdateCallSizeEstimate(size_t size);
   absl::string_view target() const { return target_; }
-  MemoryAllocator* allocator() { return &allocator_; }
   bool is_client() const { return is_client_; }
   bool is_promising() const { return is_promising_; }
   RegisteredCall* RegisterCall(const char* method, const char* host);
@@ -162,12 +147,11 @@ class Channel : public RefCounted<Channel>,
   const bool is_client_;
   const bool is_promising_;
   const grpc_compression_options compression_options_;
-  std::atomic<size_t> call_size_estimate_;
   CallRegistrationTable registration_table_;
   RefCountedPtr<channelz::ChannelNode> channelz_node_;
-  MemoryAllocator allocator_;
   std::string target_;
   const RefCountedPtr<grpc_channel_stack> channel_stack_;
+  const RefCountedPtr<CallFactory> call_factory_;
 };
 
 }  // namespace grpc_core