grpc 1.61.0.pre2 → 1.62.0.pre1

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

@@ -104,9 +104,9 @@ ChannelInit::FilterRegistration::ExcludeFromMinimalStack() {
 
 ChannelInit::FilterRegistration& ChannelInit::Builder::RegisterFilter(
     grpc_channel_stack_type type, const grpc_channel_filter* filter,
-    SourceLocation registration_source) {
-  filters_[type].emplace_back(
-      std::make_unique<FilterRegistration>(filter, registration_source));
+    const ChannelFilterVtable* vtable, SourceLocation registration_source) {
+  filters_[type].emplace_back(std::make_unique<FilterRegistration>(
+      filter, vtable, registration_source));
   return *filters_[type].back();
 }
 
@@ -141,7 +141,7 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
       GPR_ASSERT(registration->after_.empty());
       GPR_ASSERT(registration->before_.empty());
       GPR_ASSERT(!registration->before_all_);
-      terminal_filters.emplace_back(registration->filter_,
+      terminal_filters.emplace_back(registration->filter_, nullptr,
                                     std::move(registration->predicates_),
                                     registration->registration_source_);
     } else {
@@ -222,9 +222,10 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
   std::vector<Filter> filters;
   while (!dependencies.empty()) {
     auto filter = take_ready_dependency();
-    filters.emplace_back(filter,
-                         std::move(filter_to_registration[filter]->predicates_),
-                         filter_to_registration[filter]->registration_source_);
+    auto* registration = filter_to_registration[filter];
+    filters.emplace_back(filter, registration->vtable_,
+                         std::move(registration->predicates_),
+                         registration->registration_source_);
     for (auto& p : dependencies) {
       p.second.erase(filter);
     }
@@ -405,4 +406,77 @@ bool ChannelInit::CreateStack(ChannelStackBuilder* builder) const {
   return true;
 }
 
+absl::StatusOr<ChannelInit::StackSegment> ChannelInit::CreateStackSegment(
+    grpc_channel_stack_type type, const ChannelArgs& args) const {
+  const auto& stack_config = stack_configs_[type];
+  std::vector<StackSegment::ChannelFilter> filters;
+  size_t channel_data_size = 0;
+  size_t channel_data_alignment = 0;
+  // Based on predicates build a list of filters to include in this segment.
+  for (const auto& filter : stack_config.filters) {
+    if (!filter.CheckPredicates(args)) continue;
+    if (filter.vtable == nullptr) {
+      return absl::InvalidArgumentError(
+          absl::StrCat("Filter ", NameFromChannelFilter(filter.filter),
+                       " has no v3-callstack vtable"));
+    }
+    channel_data_alignment =
+        std::max(channel_data_alignment, filter.vtable->alignment);
+    if (channel_data_size % filter.vtable->alignment != 0) {
+      channel_data_size += filter.vtable->alignment -
+                           (channel_data_size % filter.vtable->alignment);
+    }
+    filters.push_back({channel_data_size, filter.vtable});
+    channel_data_size += filter.vtable->size;
+  }
+  // Shortcut for empty segments.
+  if (filters.empty()) return StackSegment();
+  // Allocate memory for the channel data, initialize channel filters into it.
+  uint8_t* p = static_cast<uint8_t*>(
+      gpr_malloc_aligned(channel_data_size, channel_data_alignment));
+  for (size_t i = 0; i < filters.size(); i++) {
+    auto r = filters[i].vtable->init(p + filters[i].offset, args);
+    if (!r.ok()) {
+      for (size_t j = 0; j < i; j++) {
+        filters[j].vtable->destroy(p + filters[j].offset);
+      }
+      gpr_free_aligned(p);
+      return r;
+    }
+  }
+  return StackSegment(std::move(filters), p);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// ChannelInit::StackSegment
+
+ChannelInit::StackSegment::StackSegment(std::vector<ChannelFilter> filters,
+                                        uint8_t* channel_data)
+    : data_(MakeRefCounted<ChannelData>(std::move(filters), channel_data)) {}
+
+void ChannelInit::StackSegment::AddToCallFilterStack(
+    CallFilters::StackBuilder& builder) {
+  if (data_ == nullptr) return;
+  data_->AddToCallFilterStack(builder);
+  builder.AddOwnedObject(data_);
+};
+
+ChannelInit::StackSegment::ChannelData::ChannelData(
+    std::vector<ChannelFilter> filters, uint8_t* channel_data)
+    : filters_(std::move(filters)), channel_data_(channel_data) {}
+
+void ChannelInit::StackSegment::ChannelData::AddToCallFilterStack(
+    CallFilters::StackBuilder& builder) {
+  for (const auto& filter : filters_) {
+    filter.vtable->add_to_stack_builder(channel_data_ + filter.offset, builder);
+  }
+}
+
+ChannelInit::StackSegment::ChannelData::~ChannelData() {
+  for (const auto& filter : filters_) {
+    filter.vtable->destroy(channel_data_ + filter.offset);
+  }
+  gpr_free_aligned(channel_data_);
+}
+
 }  // namespace grpc_core

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

@@ -37,6 +37,7 @@
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/transport/call_filters.h"
 
 /// This module provides a way for plugins (and the grpc core library itself)
 /// to register mutators for channel stacks.
@@ -76,11 +77,26 @@ class ChannelInit {
     kCount
   };
 
+  // Vtable-like data structure for channel data initialization
+  struct ChannelFilterVtable {
+    size_t size;
+    size_t alignment;
+    absl::Status (*init)(void* data, const ChannelArgs& args);
+    void (*destroy)(void* data);
+    void (*add_to_stack_builder)(void* data,
+                                 CallFilters::StackBuilder& builder);
+  };
+
   class FilterRegistration {
    public:
+    // TODO(ctiller): Remove grpc_channel_filter* arg when that can be
+    // deprecated (once filter stack is removed).
     explicit FilterRegistration(const grpc_channel_filter* filter,
+                                const ChannelFilterVtable* vtable,
                                 SourceLocation registration_source)
-        : filter_(filter), registration_source_(registration_source) {}
+        : filter_(filter),
+          vtable_(vtable),
+          registration_source_(registration_source) {}
     FilterRegistration(const FilterRegistration&) = delete;
     FilterRegistration& operator=(const FilterRegistration&) = delete;
 
@@ -150,6 +166,7 @@ class ChannelInit {
    private:
     friend class ChannelInit;
     const grpc_channel_filter* const filter_;
+    const ChannelFilterVtable* const vtable_;
     std::vector<const grpc_channel_filter*> after_;
     std::vector<const grpc_channel_filter*> before_;
     std::vector<InclusionPredicate> predicates_;
@@ -166,13 +183,16 @@ class ChannelInit {
     // properties of the filter being registered.
     // TODO(ctiller): remove in favor of the version that does not mention
     // grpc_channel_filter
-    FilterRegistration& RegisterFilter(grpc_channel_stack_type type,
-                                       const grpc_channel_filter* filter,
-                                       SourceLocation registration_source = {});
+    FilterRegistration& RegisterFilter(
+        grpc_channel_stack_type type, const grpc_channel_filter* filter,
+        const ChannelFilterVtable* vtable = nullptr,
+        SourceLocation registration_source = {});
     template <typename Filter>
     FilterRegistration& RegisterFilter(
         grpc_channel_stack_type type, SourceLocation registration_source = {}) {
-      return RegisterFilter(type, &Filter::kFilter, registration_source);
+      return RegisterFilter(type, &Filter::kFilter,
+                            VtableForType<Filter>::vtable(),
+                            registration_source);
     }
 
     // Register a post processor for the builder.
@@ -198,20 +218,70 @@ class ChannelInit {
                                   [static_cast<int>(PostProcessorSlot::kCount)];
   };
 
+  // A set of channel filters that can be added to a call stack.
+  // TODO(ctiller): move this out so it can be used independently of
+  // the global registration mechanisms.
+  class StackSegment final {
+   public:
+    // Registration of one channel filter in the stack.
+    struct ChannelFilter {
+      size_t offset;
+      const ChannelFilterVtable* vtable;
+    };
+
+    StackSegment() = default;
+    explicit StackSegment(std::vector<ChannelFilter> filters,
+                          uint8_t* channel_data);
+    StackSegment(const StackSegment& other) = delete;
+    StackSegment& operator=(const StackSegment& other) = delete;
+    StackSegment(StackSegment&& other) noexcept = default;
+    StackSegment& operator=(StackSegment&& other) = default;
+
+    // Add this segment to a call filter stack builder
+    void AddToCallFilterStack(CallFilters::StackBuilder& builder);
+
+   private:
+    // Combined channel data for the stack
+    class ChannelData : public RefCounted<ChannelData> {
+     public:
+      explicit ChannelData(std::vector<ChannelFilter> filters,
+                           uint8_t* channel_data);
+      ~ChannelData() override;
+
+      void AddToCallFilterStack(CallFilters::StackBuilder& builder);
+
+     private:
+      std::vector<ChannelFilter> filters_;
+      uint8_t* channel_data_;
+    };
+
+    RefCountedPtr<ChannelData> data_;
+  };
+
   /// Construct a channel stack of some sort: see channel_stack.h for details
   /// \a builder is the channel stack builder to build into.
   GRPC_MUST_USE_RESULT
   bool CreateStack(ChannelStackBuilder* builder) const;
 
+  // Create a segment of a channel stack.
+  // Terminators and post processors are not included in this construction:
+  // terminators are a legacy filter-stack concept, and post processors
+  // need to migrate to other mechanisms.
+  // TODO(ctiller): figure out other mechanisms.
+  absl::StatusOr<StackSegment> CreateStackSegment(
+      grpc_channel_stack_type type, const ChannelArgs& args) const;
+
  private:
   struct Filter {
-    Filter(const grpc_channel_filter* filter,
+    Filter(const grpc_channel_filter* filter, const ChannelFilterVtable* vtable,
            std::vector<InclusionPredicate> predicates,
            SourceLocation registration_source)
         : filter(filter),
+          vtable(vtable),
           predicates(std::move(predicates)),
           registration_source(registration_source) {}
     const grpc_channel_filter* filter;
+    const ChannelFilterVtable* vtable;
     std::vector<InclusionPredicate> predicates;
     SourceLocation registration_source;
     bool CheckPredicates(const ChannelArgs& args) const;
@@ -221,6 +291,18 @@ class ChannelInit {
     std::vector<Filter> terminators;
     std::vector<PostProcessor> post_processors;
   };
+
+  template <typename T, typename = void>
+  struct VtableForType {
+    static const ChannelFilterVtable* vtable() { return nullptr; }
+  };
+
+  template <typename T>
+  struct VtableForType<T, absl::void_t<typename T::Call>> {
+    static const ChannelFilterVtable kVtable;
+    static const ChannelFilterVtable* vtable() { return &kVtable; }
+  };
+
   StackConfig stack_configs_[GRPC_NUM_CHANNEL_STACK_TYPES];
 
   static StackConfig BuildStackConfig(
@@ -228,6 +310,22 @@ class ChannelInit {
       PostProcessor* post_processors, grpc_channel_stack_type type);
 };
 
+template <typename T>
+const ChannelInit::ChannelFilterVtable
+    ChannelInit::VtableForType<T, absl::void_t<typename T::Call>>::kVtable = {
+        sizeof(T), alignof(T),
+        [](void* data, const ChannelArgs& args) -> absl::Status {
+          // TODO(ctiller): fill in ChannelFilter::Args (2nd arg)
+          absl::StatusOr<T> r = T::Create(args, {});
+          if (!r.ok()) return r.status();
+          new (data) T(std::move(*r));
+          return absl::OkStatus();
+        },
+        [](void* data) { static_cast<T*>(data)->~T(); },
+        [](void* data, CallFilters::StackBuilder& builder) {
+          builder.Add(static_cast<T*>(data));
+        }};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_SURFACE_CHANNEL_INIT_H

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

@@ -29,7 +29,7 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
-#include "src/core/ext/filters/client_channel/backup_poller.h"
+#include "src/core/client_channel/backup_poller.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"

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

@@ -525,7 +525,7 @@ class Server::RealRequestMatcherPromises : public RequestMatcherInterface {
               "Too many pending requests for this server"));
         }
         auto w = std::make_shared<ActivityWaiter>(
-            Activity::current()->MakeOwningWaker());
+            GetContext<Activity>()->MakeOwningWaker());
         pending_.push(w);
         return OnCancel(
             [w]() -> Poll<absl::StatusOr<MatchResult>> {
@@ -925,7 +925,7 @@ grpc_error_handle Server::SetupTransport(
   }
   if (cq_idx == cqs_.size()) {
     // Completion queue not found.  Pick a random one to publish new calls to.
-    cq_idx = static_cast<size_t>(rand()) % cqs_.size();
+    cq_idx = static_cast<size_t>(rand()) % std::max<size_t>(1, cqs_.size());
   }
   // Set up channelz node.
   intptr_t channelz_socket_uuid = 0;
@@ -1298,11 +1298,7 @@ Server::ChannelData::~ChannelData() {
   }
 }
 
-Arena* Server::ChannelData::CreateArena() {
-  const auto initial_size = channel_->CallSizeEstimate();
-  global_stats().IncrementCallInitialSize(initial_size);
-  return Arena::Create(initial_size, channel_->allocator());
-}
+Arena* Server::ChannelData::CreateArena() { return channel_->CreateArena(); }
 
 absl::StatusOr<CallInitiator> Server::ChannelData::CreateCall(
     ClientMetadata& client_initial_metadata, Arena* arena) {
@@ -1489,6 +1485,7 @@ void Server::ChannelData::InitCall(RefCountedPtr<CallSpineInterface> call) {
           rc->Complete(std::move(std::get<0>(r)), *md);
           auto* call_context = GetContext<CallContext>();
           *rc->call = call_context->c_call();
+          grpc_call_ref(*rc->call);
           grpc_call_set_completion_queue(call_context->c_call(),
                                          rc->cq_bound_to_call);
           call_context->server_call_context()->PublishInitialMetadata(

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

@@ -23,6 +23,6 @@
 
 #include <grpc/grpc.h>
 
-const char* grpc_version_string(void) { return "38.0.0"; }
+const char* grpc_version_string(void) { return "39.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "grand"; }
+const char* grpc_g_stands_for(void) { return "guardian"; }

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

@@ -0,0 +1,75 @@
+// Copyright 2024 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/surface/wait_for_cq_end_op.h"
+
+#include <atomic>
+
+#include "src/core/lib/gprpp/match.h"
+#include "src/core/lib/promise/trace.h"
+
+namespace grpc_core {
+Poll<Empty> WaitForCqEndOp::operator()() {
+  if (grpc_trace_promise_primitives.enabled()) {
+    gpr_log(GPR_INFO, "%sWaitForCqEndOp[%p] %s",
+            Activity::current()->DebugTag().c_str(), this,
+            StateString(state_).c_str());
+  }
+  if (auto* n = absl::get_if<NotStarted>(&state_)) {
+    if (n->is_closure) {
+      ExecCtx::Run(DEBUG_LOCATION, static_cast<grpc_closure*>(n->tag),
+                   std::move(n->error));
+      return Empty{};
+    } else {
+      auto not_started = std::move(*n);
+      auto& started =
+          state_.emplace<Started>(GetContext<Activity>()->MakeOwningWaker());
+      grpc_cq_end_op(
+          not_started.cq, not_started.tag, std::move(not_started.error),
+          [](void* p, grpc_cq_completion*) {
+            auto started = static_cast<Started*>(p);
+            auto wakeup = std::move(started->waker);
+            started->done.store(true, std::memory_order_release);
+            wakeup.Wakeup();
+          },
+          &started, &started.completion);
+    }
+  }
+  auto& started = absl::get<Started>(state_);
+  if (started.done.load(std::memory_order_acquire)) {
+    return Empty{};
+  } else {
+    return Pending{};
+  }
+}
+
+std::string WaitForCqEndOp::StateString(const State& state) {
+  return Match(
+      state,
+      [](const NotStarted& x) {
+        return absl::StrFormat(
+            "NotStarted{is_closure=%s, tag=%p, error=%s, cq=%p}",
+            x.is_closure ? "true" : "false", x.tag, x.error.ToString(), x.cq);
+      },
+      [](const Started& x) {
+        return absl::StrFormat(
+            "Started{completion=%p, done=%s}", &x.completion,
+            x.done.load(std::memory_order_relaxed) ? "true" : "false");
+      },
+      [](const Invalid&) -> std::string { return "Invalid{}"; });
+}
+
+}  // namespace grpc_core

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

@@ -32,32 +32,7 @@ class WaitForCqEndOp {
                  grpc_completion_queue* cq)
       : state_{NotStarted{is_closure, tag, std::move(error), cq}} {}
 
-  Poll<Empty> operator()() {
-    if (auto* n = absl::get_if<NotStarted>(&state_)) {
-      if (n->is_closure) {
-        ExecCtx::Run(DEBUG_LOCATION, static_cast<grpc_closure*>(n->tag),
-                     std::move(n->error));
-        return Empty{};
-      } else {
-        auto not_started = std::move(*n);
-        auto& started =
-            state_.emplace<Started>(Activity::current()->MakeOwningWaker());
-        grpc_cq_end_op(
-            not_started.cq, not_started.tag, std::move(not_started.error),
-            [](void* p, grpc_cq_completion*) {
-              auto started = static_cast<Started*>(p);
-              started->done.store(true, std::memory_order_release);
-            },
-            &started, &started.completion);
-      }
-    }
-    auto& started = absl::get<Started>(state_);
-    if (started.done.load(std::memory_order_acquire)) {
-      return Empty{};
-    } else {
-      return Pending{};
-    }
-  }
+  Poll<Empty> operator()();
 
   WaitForCqEndOp(const WaitForCqEndOp&) = delete;
   WaitForCqEndOp& operator=(const WaitForCqEndOp&) = delete;
@@ -86,6 +61,9 @@ class WaitForCqEndOp {
   };
   struct Invalid {};
   using State = absl::variant<NotStarted, Started, Invalid>;
+
+  static std::string StateString(const State& state);
+
   State state_{Invalid{}};
 };
 

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

@@ -55,8 +55,7 @@ BatchBuilder::PendingCompletion::PendingCompletion(RefCountedPtr<Batch> batch)
 
 BatchBuilder::Batch::Batch(grpc_transport_stream_op_batch_payload* payload,
                            grpc_stream_refcount* stream_refcount)
-    : party(static_cast<Party*>(Activity::current())->Ref()),
-      stream_refcount(stream_refcount) {
+    : party(GetContext<Party>()->Ref()), stream_refcount(stream_refcount) {
   batch.payload = payload;
   batch.is_traced = GetContext<CallContext>()->traced();
 #ifndef NDEBUG
@@ -70,7 +69,7 @@ BatchBuilder::Batch::~Batch() {
   auto* arena = party->arena();
   if (grpc_call_trace.enabled()) {
     gpr_log(GPR_DEBUG, "%s[connected] [batch %p] Destroy",
-            Activity::current()->DebugTag().c_str(), this);
+            GetContext<Activity>()->DebugTag().c_str(), this);
   }
   if (pending_receive_message != nullptr) {
     arena->DeletePooled(pending_receive_message);

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

@@ -202,7 +202,7 @@ class BatchBuilder {
     ~Batch();
     Batch(const Batch&) = delete;
     Batch& operator=(const Batch&) = delete;
-    std::string DebugPrefix(Activity* activity = Activity::current()) const {
+    std::string DebugPrefix(Activity* activity = GetContext<Activity>()) const {
       return absl::StrFormat("%s[connected] [batch %p] ", activity->DebugTag(),
                              this);
     }

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

@@ -0,0 +1,41 @@
+// Copyright 2024 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/transport/call_factory.h"
+
+#include "src/core/lib/debug/stats.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
+
+namespace grpc_core {
+
+CallFactory::CallFactory(const ChannelArgs& args)
+    : call_size_estimator_(1024),
+      allocator_(args.GetObject<ResourceQuota>()
+                     ->memory_quota()
+                     ->CreateMemoryOwner()) {}
+
+Arena* CallFactory::CreateArena() {
+  const size_t initial_size = call_size_estimator_.CallSizeEstimate();
+  global_stats().IncrementCallInitialSize(initial_size);
+  return Arena::Create(initial_size, &allocator_);
+}
+
+void CallFactory::DestroyArena(Arena* arena) {
+  call_size_estimator_.UpdateCallSizeEstimate(arena->TotalUsedBytes());
+  arena->Destroy();
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,56 @@
+// Copyright 2024 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_TRANSPORT_CALL_FACTORY_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_CALL_FACTORY_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/transport/call_size_estimator.h"
+#include "src/core/lib/transport/call_spine.h"
+
+namespace grpc_core {
+
+// CallFactory creates calls.
+class CallFactory : public RefCounted<CallFactory> {
+ public:
+  explicit CallFactory(const ChannelArgs& args);
+
+  // Create an arena for a call.
+  // We do this as a separate step so that servers can create arenas without
+  // creating the call into it - in the case that we have a HTTP/2 rapid reset
+  // like attack this saves a lot of cpu time.
+  Arena* CreateArena();
+  // Destroy an arena created by CreateArena.
+  // Updates the call size estimator so that we always create arenas of about
+  // the right size.
+  void DestroyArena(Arena* arena);
+
+  // Create a call. The call will be created in the given arena.
+  // It is the CallFactory's responsibility to ensure that the CallHandler
+  // associated with the call is eventually handled by something (typically a
+  // CallDestination, but this is not strictly required).
+  virtual CallInitiator CreateCall(ClientMetadataHandle md, Arena* arena) = 0;
+
+ private:
+  CallSizeEstimator call_size_estimator_;
+  MemoryAllocator allocator_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_CALL_FACTORY_H