grpc 1.24.0 → 1.25.0.pre1

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

@@ -65,6 +65,10 @@ class SliceHashTable : public RefCounted<SliceHashTable<T>> {
                                               Entry* entries,
                                               ValueCmp value_cmp);
 
+  // Use Create function instead of using this directly.
+  SliceHashTable(size_t num_entries, Entry* entries, ValueCmp value_cmp);
+  virtual ~SliceHashTable();
+
   /// Returns the value from the table associated with \a key.
   /// Returns null if \a key is not found.
   const T* Get(const grpc_slice& key) const;
@@ -78,12 +82,6 @@ class SliceHashTable : public RefCounted<SliceHashTable<T>> {
   static int Cmp(const SliceHashTable& a, const SliceHashTable& b);
 
  private:
-  GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_DELETE
-  GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_NEW
-
-  SliceHashTable(size_t num_entries, Entry* entries, ValueCmp value_cmp);
-  virtual ~SliceHashTable();
-
   void Add(const grpc_slice& key, T& value);
 
   // Default value comparison function, if none specified by caller.

data/src/core/lib/slice/slice_intern.cc

@@ -50,10 +50,6 @@ typedef struct slice_shard {
   size_t capacity;
 } slice_shard;
 
-/* hash seed: decided at initialization time */
-uint32_t g_hash_seed;
-static int g_forced_hash_seed = 0;
-
 static slice_shard g_shards[SHARD_COUNT];
 
 typedef struct {
@@ -68,6 +64,10 @@ uint32_t grpc_static_metadata_hash_values[GRPC_STATIC_MDSTR_COUNT];
 
 namespace grpc_core {
 
+/* hash seed: decided at initialization time */
+uint32_t g_hash_seed;
+static bool g_forced_hash_seed = false;
+
 InternedSliceRefcount::~InternedSliceRefcount() {
   slice_shard* shard = &g_shards[SHARD_IDX(this->hash)];
   MutexLock lock(&shard->mu);
@@ -115,7 +115,7 @@ grpc_core::InternedSlice::InternedSlice(InternedSliceRefcount* s) {
 
 uint32_t grpc_slice_default_hash_impl(grpc_slice s) {
   return gpr_murmur_hash3(GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s),
-                          g_hash_seed);
+                          grpc_core::g_hash_seed);
 }
 
 uint32_t grpc_static_slice_hash(grpc_slice s) {
@@ -159,20 +159,20 @@ grpc_slice grpc_slice_intern(grpc_slice slice) {
 }
 
 // Attempt to see if the provided slice or string matches a static slice.
-// SliceArgs... is either a const grpc_slice& or a string and length. In either
-// case, hash is the pre-computed hash value.
+// SliceArgs is either a const grpc_slice& or const pair<const char*, size_t>&.
+// In either case, hash is the pre-computed hash value.
 //
 // Returns: a matching static slice, or null.
-template <class... SliceArgs>
+template <typename SliceArgs>
 static const grpc_core::StaticMetadataSlice* MatchStaticSlice(
-    uint32_t hash, SliceArgs&&... args) {
+    uint32_t hash, const SliceArgs& args) {
   for (uint32_t i = 0; i <= max_static_metadata_hash_probe; i++) {
     static_metadata_hash_ent ent =
         static_metadata_hash[(hash + i) % GPR_ARRAY_SIZE(static_metadata_hash)];
     const grpc_core::StaticMetadataSlice* static_slice_table =
         grpc_static_slice_table();
     if (ent.hash == hash && ent.idx < GRPC_STATIC_MDSTR_COUNT &&
-        static_slice_table[ent.idx].Equals(std::forward<SliceArgs>(args)...)) {
+        static_slice_table[ent.idx] == args) {
       return &static_slice_table[ent.idx];
     }
   }
@@ -182,8 +182,12 @@ static const grpc_core::StaticMetadataSlice* MatchStaticSlice(
 // Helper methods to enable us to select appropriately overloaded slice methods
 // whether we're dealing with a slice, or a buffer with length, when interning
 // strings. Helpers for FindOrCreateInternedSlice().
-static const void* GetBuffer(const void* buf, size_t len) { return buf; }
-static size_t GetLength(const void* buf, size_t len) { return len; }
+static const char* GetBuffer(const std::pair<const char*, size_t>& buflen) {
+  return buflen.first;
+}
+static size_t GetLength(const std::pair<const char*, size_t>& buflen) {
+  return buflen.second;
+}
 static const void* GetBuffer(const grpc_slice& slice) {
   return GRPC_SLICE_START_PTR(slice);
 }
@@ -192,19 +196,19 @@ static size_t GetLength(const grpc_slice& slice) {
 }
 
 // Creates an interned slice for a string that does not currently exist in the
-// intern table. SliceArgs... is either a const grpc_slice& or a string and
-// length. In either case, hash is the pre-computed hash value. We must already
-// hold the shard lock. Helper for FindOrCreateInternedSlice().
+// intern table. SliceArgs is either a const grpc_slice& or a const
+// pair<const char*, size_t>&. Hash is the pre-computed hash value. We must
+// already hold the shard lock. Helper for FindOrCreateInternedSlice().
 //
 // Returns: a newly interned slice.
-template <class... SliceArgs>
+template <typename SliceArgs>
 static InternedSliceRefcount* InternNewStringLocked(slice_shard* shard,
                                                     size_t shard_idx,
                                                     uint32_t hash,
-                                                    SliceArgs&&... args) {
+                                                    const SliceArgs& args) {
   /* string data goes after the internal_string header */
-  size_t len = GetLength(std::forward<SliceArgs>(args)...);
-  const void* buffer = GetBuffer(std::forward<SliceArgs>(args)...);
+  size_t len = GetLength(args);
+  const void* buffer = GetBuffer(args);
   InternedSliceRefcount* s =
       static_cast<InternedSliceRefcount*>(gpr_malloc(sizeof(*s) + len));
   new (s) grpc_core::InternedSliceRefcount(len, hash, shard->strs[shard_idx]);
@@ -227,16 +231,15 @@ static InternedSliceRefcount* InternNewStringLocked(slice_shard* shard,
 // shard lock. Helper for FindOrCreateInternedSlice().
 //
 // Returns: a pre-existing matching static slice, or null.
-template <class... SliceArgs>
+template <typename SliceArgs>
 static InternedSliceRefcount* MatchInternedSliceLocked(uint32_t hash,
                                                        size_t idx,
-                                                       SliceArgs&&... args) {
+                                                       const SliceArgs& args) {
   InternedSliceRefcount* s;
   slice_shard* shard = &g_shards[SHARD_IDX(hash)];
   /* search for an existing string */
   for (s = shard->strs[idx]; s; s = s->bucket_next) {
-    if (s->hash == hash &&
-        grpc_core::InternedSlice(s).Equals(std::forward<SliceArgs>(args)...)) {
+    if (s->hash == hash && grpc_core::InternedSlice(s) == args) {
       if (s->refcnt.RefIfNonZero()) {
         return s;
       }
@@ -248,22 +251,20 @@ static InternedSliceRefcount* MatchInternedSliceLocked(uint32_t hash,
 // Attempt to see if the provided slice or string matches an existing interned
 // slice, and failing that, create an interned slice with its contents. Returns
 // either the existing matching interned slice or the newly created one.
-// SliceArgs... is either a const grpc_slice& or a string and length. In either
-// case, hash is the pre-computed hash value. We do not hold the shard lock
-// here, but do take it.
+// SliceArgs is either a const grpc_slice& or const pair<const char*, size_t>&.
+// In either case, hash is the pre-computed hash value. We do not hold the
+// shard lock here, but do take it.
 //
 // Returns: an interned slice, either pre-existing/matched or newly created.
-template <class... SliceArgs>
+template <typename SliceArgs>
 static InternedSliceRefcount* FindOrCreateInternedSlice(uint32_t hash,
-                                                        SliceArgs&&... args) {
+                                                        const SliceArgs& args) {
   slice_shard* shard = &g_shards[SHARD_IDX(hash)];
   gpr_mu_lock(&shard->mu);
   const size_t idx = TABLE_IDX(hash, shard->capacity);
-  InternedSliceRefcount* s =
-      MatchInternedSliceLocked(hash, idx, std::forward<SliceArgs>(args)...);
+  InternedSliceRefcount* s = MatchInternedSliceLocked(hash, idx, args);
   if (s == nullptr) {
-    s = InternNewStringLocked(shard, idx, hash,
-                              std::forward<SliceArgs>(args)...);
+    s = InternNewStringLocked(shard, idx, hash, args);
   }
   gpr_mu_unlock(&shard->mu);
   return s;
@@ -277,12 +278,13 @@ grpc_core::ManagedMemorySlice::ManagedMemorySlice(const char* string,
                                                   size_t len) {
   GPR_TIMER_SCOPE("grpc_slice_intern", 0);
   const uint32_t hash = gpr_murmur_hash3(string, len, g_hash_seed);
-  const StaticMetadataSlice* static_slice = MatchStaticSlice(hash, string, len);
+  const StaticMetadataSlice* static_slice =
+      MatchStaticSlice(hash, std::pair<const char*, size_t>(string, len));
   if (static_slice) {
     *this = *static_slice;
   } else {
-    *this =
-        grpc_core::InternedSlice(FindOrCreateInternedSlice(hash, string, len));
+    *this = grpc_core::InternedSlice(FindOrCreateInternedSlice(
+        hash, std::pair<const char*, size_t>(string, len)));
   }
 }
 
@@ -303,13 +305,14 @@ grpc_core::ManagedMemorySlice::ManagedMemorySlice(const grpc_slice* slice_ptr) {
 }
 
 void grpc_test_only_set_slice_hash_seed(uint32_t seed) {
-  g_hash_seed = seed;
-  g_forced_hash_seed = 1;
+  grpc_core::g_hash_seed = seed;
+  grpc_core::g_forced_hash_seed = true;
 }
 
 void grpc_slice_intern_init(void) {
-  if (!g_forced_hash_seed) {
-    g_hash_seed = static_cast<uint32_t>(gpr_now(GPR_CLOCK_REALTIME).tv_nsec);
+  if (!grpc_core::g_forced_hash_seed) {
+    grpc_core::g_hash_seed =
+        static_cast<uint32_t>(gpr_now(GPR_CLOCK_REALTIME).tv_nsec);
   }
   for (size_t i = 0; i < SHARD_COUNT; i++) {
     slice_shard* shard = &g_shards[i];

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

@@ -36,7 +36,6 @@
 // Interned slices have specific fast-path operations for hashing. To inline
 // these operations, we need to forward declare them here.
 extern uint32_t grpc_static_metadata_hash_values[GRPC_STATIC_MDSTR_COUNT];
-extern uint32_t g_hash_seed;
 
 // grpc_slice_refcount : A reference count for grpc_slice.
 //
@@ -259,7 +258,8 @@ inline uint32_t grpc_slice_refcount::Hash(const grpc_slice& slice) {
       break;
   }
   return gpr_murmur_hash3(grpc_refcounted_slice_data(slice),
-                          grpc_refcounted_slice_length(slice), g_hash_seed);
+                          grpc_refcounted_slice_length(slice),
+                          grpc_core::g_hash_seed);
 }
 
 inline const grpc_slice& grpc_slice_ref_internal(const grpc_slice& slice) {
@@ -327,7 +327,7 @@ inline uint32_t grpc_slice_hash_refcounted(const grpc_slice& s) {
 
 inline uint32_t grpc_slice_default_hash_internal(const grpc_slice& s) {
   return gpr_murmur_hash3(GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s),
-                          g_hash_seed);
+                          grpc_core::g_hash_seed);
 }
 
 inline uint32_t grpc_slice_hash_internal(const grpc_slice& s) {

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

@@ -25,6 +25,12 @@
 
 #include <grpc/slice.h>
 
+#include "src/core/lib/gpr/murmur_hash.h"
+
+namespace grpc_core {
+extern uint32_t g_hash_seed;
+}  // namespace grpc_core
+
 // When we compare two slices, and we know the latter is not inlined, we can
 // short circuit our comparison operator. We specifically use differs()
 // semantics instead of equals() semantics due to more favourable code
@@ -101,15 +107,16 @@ struct ManagedMemorySlice : public grpc_slice {
   explicit ManagedMemorySlice(const char* string);
   ManagedMemorySlice(const char* buf, size_t len);
   explicit ManagedMemorySlice(const grpc_slice* slice);
-  bool Equals(const grpc_slice& other) const {
+  bool operator==(const grpc_slice& other) const {
     if (refcount == other.refcount) {
       return true;
     }
     return !grpc_slice_differs_refcounted(other, *this);
   }
-  bool Equals(const char* buf, const size_t len) const {
-    return data.refcounted.length == len && buf != nullptr &&
-           memcmp(buf, data.refcounted.bytes, len) == 0;
+  bool operator!=(const grpc_slice& other) const { return !(*this == other); }
+  bool operator==(std::pair<const char*, size_t> buflen) const {
+    return data.refcounted.length == buflen.second && buflen.first != nullptr &&
+           memcmp(buflen.first, data.refcounted.bytes, buflen.second) == 0;
   }
 };
 struct UnmanagedMemorySlice : public grpc_slice {
@@ -150,6 +157,16 @@ struct ExternallyManagedSlice : public UnmanagedMemorySlice {
     data.refcounted.length = length;
     data.refcounted.bytes = bytes;
   }
+  bool operator==(const grpc_slice& other) const {
+    return data.refcounted.length == GRPC_SLICE_LENGTH(other) &&
+           memcmp(data.refcounted.bytes, GRPC_SLICE_START_PTR(other),
+                  data.refcounted.length) == 0;
+  }
+  bool operator!=(const grpc_slice& other) const { return !(*this == other); }
+  uint32_t Hash() {
+    return gpr_murmur_hash3(data.refcounted.bytes, data.refcounted.length,
+                            g_hash_seed);
+  }
 };
 
 struct StaticMetadataSlice : public ManagedMemorySlice {

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

@@ -44,6 +44,10 @@ class SliceWeakHashTable : public RefCounted<SliceWeakHashTable<T, Size>> {
     return MakeRefCounted<SliceWeakHashTable<T, Size>>();
   }
 
+  /// Use Create function instead of using this directly.
+  SliceWeakHashTable() = default;
+  ~SliceWeakHashTable() = default;
+
   /// Add a mapping from \a key to \a value, taking ownership of \a key. This
   /// operation will always succeed. It may discard older entries.
   void Add(const grpc_slice& key, T value) {
@@ -61,12 +65,6 @@ class SliceWeakHashTable : public RefCounted<SliceWeakHashTable<T, Size>> {
   }
 
  private:
-  GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_NEW
-  GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_DELETE
-
-  SliceWeakHashTable() = default;
-  ~SliceWeakHashTable() = default;
-
   /// The type of the table "rows".
   class Entry {
    public:

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

@@ -1131,8 +1131,7 @@ static size_t batch_slot_for_op(grpc_op_type type) {
 }
 
 static batch_control* reuse_or_allocate_batch_control(grpc_call* call,
-                                                      const grpc_op* ops,
-                                                      size_t num_ops) {
+                                                      const grpc_op* ops) {
   size_t slot_idx = batch_slot_for_op(ops[0].op);
   batch_control** pslot = &call->active_batches[slot_idx];
   batch_control* bctl;
@@ -1268,6 +1267,7 @@ static void continue_receiving_slices(batch_control* bctl) {
         *call->receiving_buffer = nullptr;
         call->receiving_message = 0;
         finish_batch_step(bctl);
+        GRPC_ERROR_UNREF(error);
         return;
       }
     } else {
@@ -1579,7 +1579,7 @@ static grpc_call_error call_start_batch(grpc_call* call, const grpc_op* ops,
     goto done;
   }
 
-  bctl = reuse_or_allocate_batch_control(call, ops, nops);
+  bctl = reuse_or_allocate_batch_control(call, ops);
   if (bctl == nullptr) {
     return GRPC_CALL_ERROR_TOO_MANY_OPERATIONS;
   }

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

@@ -257,6 +257,13 @@ grpc_channel* grpc_channel_create(const char* target,
       get_default_authority(input_args);
   grpc_channel_args* args =
       build_channel_args(input_args, default_authority.get());
+  if (grpc_channel_stack_type_is_client(channel_stack_type)) {
+    auto channel_args_mutator =
+        grpc_channel_args_get_client_channel_creation_mutator();
+    if (channel_args_mutator != nullptr) {
+      args = channel_args_mutator(target, args, channel_stack_type);
+    }
+  }
   grpc_channel_stack_builder_set_channel_arguments(builder, args);
   grpc_channel_args_destroy(args);
   grpc_channel_stack_builder_set_target(builder, target);

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

@@ -210,14 +210,14 @@ struct cq_vtable {
 
 namespace {
 
-/* Queue that holds the cq_completion_events. Internally uses gpr_mpscq queue
- * (a lockfree multiproducer single consumer queue). It uses a queue_lock
- * to support multiple consumers.
+/* Queue that holds the cq_completion_events. Internally uses
+ * MultiProducerSingleConsumerQueue (a lockfree multiproducer single consumer
+ * queue). It uses a queue_lock to support multiple consumers.
  * Only used in completion queues whose completion_type is GRPC_CQ_NEXT */
 class CqEventQueue {
  public:
-  CqEventQueue() { gpr_mpscq_init(&queue_); }
-  ~CqEventQueue() { gpr_mpscq_destroy(&queue_); }
+  CqEventQueue() = default;
+  ~CqEventQueue() = default;
 
   /* Note: The counter is not incremented/decremented atomically with push/pop.
    * The count is only eventually consistent */
@@ -232,7 +232,7 @@ class CqEventQueue {
   /* Spinlock to serialize consumers i.e pop() operations */
   gpr_spinlock queue_lock_ = GPR_SPINLOCK_INITIALIZER;
 
-  gpr_mpscq queue_;
+  grpc_core::MultiProducerSingleConsumerQueue queue_;
 
   /* A lazy counter of number of items in the queue. This is NOT atomically
      incremented/decremented along with push/pop operations and hence is only
@@ -462,7 +462,8 @@ int grpc_completion_queue_thread_local_cache_flush(grpc_completion_queue* cq,
 }
 
 bool CqEventQueue::Push(grpc_cq_completion* c) {
-  gpr_mpscq_push(&queue_, reinterpret_cast<gpr_mpscq_node*>(c));
+  queue_.Push(
+      reinterpret_cast<grpc_core::MultiProducerSingleConsumerQueue::Node*>(c));
   return num_queue_items_.FetchAdd(1, grpc_core::MemoryOrder::RELAXED) == 0;
 }
 
@@ -473,8 +474,7 @@ grpc_cq_completion* CqEventQueue::Pop() {
     GRPC_STATS_INC_CQ_EV_QUEUE_TRYLOCK_SUCCESSES();
 
     bool is_empty = false;
-    c = reinterpret_cast<grpc_cq_completion*>(
-        gpr_mpscq_pop_and_check_end(&queue_, &is_empty));
+    c = reinterpret_cast<grpc_cq_completion*>(queue_.PopAndCheckEnd(&is_empty));
     gpr_spinlock_unlock(&queue_lock_);
 
     if (c == nullptr && !is_empty) {
@@ -1007,8 +1007,9 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
 
     if (cqd->pending_events.Load(grpc_core::MemoryOrder::ACQUIRE) == 0) {
       /* Before returning, check if the queue has any items left over (since
-         gpr_mpscq_pop() can sometimes return NULL even if the queue is not
-         empty. If so, keep retrying but do not return GRPC_QUEUE_SHUTDOWN */
+         MultiProducerSingleConsumerQueue::Pop() can sometimes return NULL
+         even if the queue is not empty. If so, keep retrying but do not
+         return GRPC_QUEUE_SHUTDOWN */
       if (cqd->queue.num_items() > 0) {
         /* Go to the beginning of the loop. No point doing a poll because
            (cq->shutdown == true) is only possible when there is no pending

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

@@ -24,8 +24,9 @@
 #include <grpc/support/port_platform.h>
 
 #include <grpc/grpc.h>
+
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gprpp/abstract.h"
+#include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/iomgr/pollset.h"
 
 /* These trace flags default to 1. The corresponding lines are only traced
@@ -36,7 +37,8 @@ extern grpc_core::DebugOnlyTraceFlag grpc_trace_pending_tags;
 extern grpc_core::DebugOnlyTraceFlag grpc_trace_cq_refcount;
 
 typedef struct grpc_cq_completion {
-  gpr_mpscq_node node;
+  grpc_core::ManualConstructor<grpc_core::MultiProducerSingleConsumerQueue>
+      node;
 
   /** user supplied tag */
   void* tag;

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

@@ -73,6 +73,7 @@ static void do_basic_init(void) {
   g_shutting_down = false;
   grpc_register_built_in_plugins();
   grpc_cq_global_init();
+  grpc_core::grpc_executor_global_init();
   gpr_time_init();
   g_initializations = 0;
 }

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

@@ -32,6 +32,7 @@
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/lame_client.h"
+#include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/static_metadata.h"
 
 namespace grpc_core {
@@ -39,15 +40,19 @@ namespace grpc_core {
 namespace {
 
 struct CallData {
-  grpc_core::CallCombiner* call_combiner;
+  CallCombiner* call_combiner;
   grpc_linked_mdelem status;
   grpc_linked_mdelem details;
-  grpc_core::Atomic<bool> filled_metadata;
+  Atomic<bool> filled_metadata;
 };
 
 struct ChannelData {
+  ChannelData() : state_tracker("lame_channel", GRPC_CHANNEL_SHUTDOWN) {}
+
   grpc_status_code error_code;
   const char* error_message;
+  Mutex mu;
+  ConnectivityStateTracker state_tracker;
 };
 
 static void fill_metadata(grpc_call_element* elem, grpc_metadata_batch* mdb) {
@@ -94,10 +99,16 @@ static void lame_get_channel_info(grpc_channel_element* elem,
 
 static void lame_start_transport_op(grpc_channel_element* elem,
                                     grpc_transport_op* op) {
-  if (op->on_connectivity_state_change) {
-    GPR_ASSERT(*op->connectivity_state != GRPC_CHANNEL_SHUTDOWN);
-    *op->connectivity_state = GRPC_CHANNEL_SHUTDOWN;
-    GRPC_CLOSURE_SCHED(op->on_connectivity_state_change, GRPC_ERROR_NONE);
+  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
+  {
+    MutexLock lock(&chand->mu);
+    if (op->start_connectivity_watch != nullptr) {
+      chand->state_tracker.AddWatcher(op->start_connectivity_watch_state,
+                                      std::move(op->start_connectivity_watch));
+    }
+    if (op->stop_connectivity_watch != nullptr) {
+      chand->state_tracker.RemoveWatcher(op->stop_connectivity_watch);
+    }
   }
   if (op->send_ping.on_initiate != nullptr) {
     GRPC_CLOSURE_SCHED(
@@ -115,27 +126,31 @@ static void lame_start_transport_op(grpc_channel_element* elem,
   }
 }
 
-static grpc_error* init_call_elem(grpc_call_element* elem,
-                                  const grpc_call_element_args* args) {
+static grpc_error* lame_init_call_elem(grpc_call_element* elem,
+                                       const grpc_call_element_args* args) {
   CallData* calld = static_cast<CallData*>(elem->call_data);
   calld->call_combiner = args->call_combiner;
   return GRPC_ERROR_NONE;
 }
 
-static void destroy_call_elem(grpc_call_element* elem,
-                              const grpc_call_final_info* final_info,
-                              grpc_closure* then_schedule_closure) {
+static void lame_destroy_call_elem(grpc_call_element* elem,
+                                   const grpc_call_final_info* final_info,
+                                   grpc_closure* then_schedule_closure) {
   GRPC_CLOSURE_SCHED(then_schedule_closure, GRPC_ERROR_NONE);
 }
 
-static grpc_error* init_channel_elem(grpc_channel_element* elem,
-                                     grpc_channel_element_args* args) {
+static grpc_error* lame_init_channel_elem(grpc_channel_element* elem,
+                                          grpc_channel_element_args* args) {
   GPR_ASSERT(args->is_first);
   GPR_ASSERT(args->is_last);
+  new (elem->channel_data) ChannelData;
   return GRPC_ERROR_NONE;
 }
 
-static void destroy_channel_elem(grpc_channel_element* elem) {}
+static void lame_destroy_channel_elem(grpc_channel_element* elem) {
+  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
+  chand->~ChannelData();
+}
 
 }  // namespace
 
@@ -145,12 +160,12 @@ const grpc_channel_filter grpc_lame_filter = {
     grpc_core::lame_start_transport_stream_op_batch,
     grpc_core::lame_start_transport_op,
     sizeof(grpc_core::CallData),
-    grpc_core::init_call_elem,
+    grpc_core::lame_init_call_elem,
     grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    grpc_core::destroy_call_elem,
+    grpc_core::lame_destroy_call_elem,
     sizeof(grpc_core::ChannelData),
-    grpc_core::init_channel_elem,
-    grpc_core::destroy_channel_elem,
+    grpc_core::lame_init_channel_elem,
+    grpc_core::lame_destroy_channel_elem,
     grpc_core::lame_get_channel_info,
     "lame-client",
 };