grpc 1.44.0.pre2 → 1.45.0

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

@@ -25,283 +25,105 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/gprpp/memory.h"
 
-typedef struct filter_node {
-  struct filter_node* next;
-  struct filter_node* prev;
-  const grpc_channel_filter* filter;
-  grpc_post_filter_create_init_func init;
-  void* init_arg;
-} filter_node;
-
-struct grpc_channel_stack_builder {
-  // sentinel nodes for filters that have been added
-  filter_node begin;
-  filter_node end;
-  // various set/get-able parameters
-  grpc_channel_args* args;
-  grpc_transport* transport;
-  char* target;
-  const char* name;
-};
-
-struct grpc_channel_stack_builder_iterator {
-  grpc_channel_stack_builder* builder;
-  filter_node* node;
-};
-
-grpc_channel_stack_builder* grpc_channel_stack_builder_create(
-    const char* name) {
-  grpc_channel_stack_builder* b =
-      grpc_core::Zalloc<grpc_channel_stack_builder>();
-  b->begin.filter = nullptr;
-  b->end.filter = nullptr;
-  b->begin.next = &b->end;
-  b->begin.prev = &b->end;
-  b->end.next = &b->begin;
-  b->end.prev = &b->begin;
-  b->name = name;
-  return b;
-}
-
-void grpc_channel_stack_builder_set_target(grpc_channel_stack_builder* b,
-                                           const char* target) {
-  gpr_free(b->target);
-  b->target = gpr_strdup(target);
-}
-
-std::string grpc_channel_stack_builder_get_target(
-    grpc_channel_stack_builder* b) {
-  return b->target == nullptr ? std::string("unknown") : std::string(b->target);
-}
-
-static grpc_channel_stack_builder_iterator* create_iterator_at_filter_node(
-    grpc_channel_stack_builder* builder, filter_node* node) {
-  grpc_channel_stack_builder_iterator* it =
-      static_cast<grpc_channel_stack_builder_iterator*>(
-          gpr_malloc(sizeof(*it)));
-  it->builder = builder;
-  it->node = node;
-  return it;
-}
-
-void grpc_channel_stack_builder_iterator_destroy(
-    grpc_channel_stack_builder_iterator* it) {
-  gpr_free(it);
-}
-
-grpc_channel_stack_builder_iterator*
-grpc_channel_stack_builder_create_iterator_at_first(
-    grpc_channel_stack_builder* builder) {
-  return create_iterator_at_filter_node(builder, &builder->begin);
-}
-
-grpc_channel_stack_builder_iterator*
-grpc_channel_stack_builder_create_iterator_at_last(
-    grpc_channel_stack_builder* builder) {
-  return create_iterator_at_filter_node(builder, &builder->end);
-}
-
-bool grpc_channel_stack_builder_iterator_is_end(
-    grpc_channel_stack_builder_iterator* iterator) {
-  return iterator->node == &iterator->builder->end;
-}
-
-const char* grpc_channel_stack_builder_iterator_filter_name(
-    grpc_channel_stack_builder_iterator* iterator) {
-  if (iterator->node->filter == nullptr) return nullptr;
-  return iterator->node->filter->name;
-}
-
-bool grpc_channel_stack_builder_move_next(
-    grpc_channel_stack_builder_iterator* iterator) {
-  if (iterator->node == &iterator->builder->end) return false;
-  iterator->node = iterator->node->next;
-  return true;
-}
-
-bool grpc_channel_stack_builder_move_prev(
-    grpc_channel_stack_builder_iterator* iterator) {
-  if (iterator->node == &iterator->builder->begin) return false;
-  iterator->node = iterator->node->prev;
-  return true;
-}
-
-grpc_channel_stack_builder_iterator* grpc_channel_stack_builder_iterator_find(
-    grpc_channel_stack_builder* builder, const char* filter_name) {
-  GPR_ASSERT(filter_name != nullptr);
-  grpc_channel_stack_builder_iterator* it =
-      grpc_channel_stack_builder_create_iterator_at_first(builder);
-  while (grpc_channel_stack_builder_move_next(it)) {
-    if (grpc_channel_stack_builder_iterator_is_end(it)) break;
-    const char* filter_name_at_it =
-        grpc_channel_stack_builder_iterator_filter_name(it);
-    if (strcmp(filter_name, filter_name_at_it) == 0) break;
-  }
-  return it;
-}
-
-bool grpc_channel_stack_builder_move_prev(
-    grpc_channel_stack_builder_iterator* iterator);
+namespace grpc_core {
 
-void grpc_channel_stack_builder_set_channel_arguments(
-    grpc_channel_stack_builder* builder, const grpc_channel_args* args) {
-  if (builder->args != nullptr) {
-    grpc_channel_args_destroy(builder->args);
-  }
-  builder->args = grpc_channel_args_copy(args);
-}
-
-const grpc_channel_args* grpc_channel_stack_builder_get_channel_arguments(
-    grpc_channel_stack_builder* builder) {
-  return builder->args;
-}
-
-void grpc_channel_stack_builder_set_transport(
-    grpc_channel_stack_builder* builder, grpc_transport* transport) {
-  GPR_ASSERT(builder->transport == nullptr);
-  builder->transport = transport;
-}
-
-grpc_transport* grpc_channel_stack_builder_get_transport(
-    grpc_channel_stack_builder* builder) {
-  return builder->transport;
+ChannelStackBuilder::~ChannelStackBuilder() {
+  grpc_channel_args_destroy(args_);
 }
 
-bool grpc_channel_stack_builder_append_filter(
-    grpc_channel_stack_builder* builder, const grpc_channel_filter* filter,
-    grpc_post_filter_create_init_func post_init_func, void* user_data) {
-  grpc_channel_stack_builder_iterator* it =
-      grpc_channel_stack_builder_create_iterator_at_last(builder);
-  bool ok = grpc_channel_stack_builder_add_filter_before(
-      it, filter, post_init_func, user_data);
-  grpc_channel_stack_builder_iterator_destroy(it);
-  return ok;
-}
-
-bool grpc_channel_stack_builder_remove_filter(
-    grpc_channel_stack_builder* builder, const char* filter_name) {
-  grpc_channel_stack_builder_iterator* it =
-      grpc_channel_stack_builder_iterator_find(builder, filter_name);
-  if (grpc_channel_stack_builder_iterator_is_end(it)) {
-    grpc_channel_stack_builder_iterator_destroy(it);
-    return false;
+ChannelStackBuilder& ChannelStackBuilder::SetTarget(const char* target) {
+  if (target == nullptr) {
+    target_ = unknown_target();
+  } else {
+    target_ = target;
   }
-  it->node->prev->next = it->node->next;
-  it->node->next->prev = it->node->prev;
-  gpr_free(it->node);
-  grpc_channel_stack_builder_iterator_destroy(it);
-  return true;
-}
-
-bool grpc_channel_stack_builder_prepend_filter(
-    grpc_channel_stack_builder* builder, const grpc_channel_filter* filter,
-    grpc_post_filter_create_init_func post_init_func, void* user_data) {
-  grpc_channel_stack_builder_iterator* it =
-      grpc_channel_stack_builder_create_iterator_at_first(builder);
-  bool ok = grpc_channel_stack_builder_add_filter_after(
-      it, filter, post_init_func, user_data);
-  grpc_channel_stack_builder_iterator_destroy(it);
-  return ok;
+  return *this;
 }
 
-static void add_after(filter_node* before, const grpc_channel_filter* filter,
-                      grpc_post_filter_create_init_func post_init_func,
-                      void* user_data) {
-  filter_node* new_node =
-      static_cast<filter_node*>(gpr_malloc(sizeof(*new_node)));
-  new_node->next = before->next;
-  new_node->prev = before;
-  new_node->next->prev = new_node->prev->next = new_node;
-  new_node->filter = filter;
-  new_node->init = post_init_func;
-  new_node->init_arg = user_data;
+ChannelStackBuilder& ChannelStackBuilder::SetChannelArgs(
+    const grpc_channel_args* args) {
+  grpc_channel_args_destroy(args_);
+  args_ = grpc_channel_args_copy(args);
+  return *this;
 }
 
-bool grpc_channel_stack_builder_add_filter_before(
-    grpc_channel_stack_builder_iterator* iterator,
-    const grpc_channel_filter* filter,
-    grpc_post_filter_create_init_func post_init_func, void* user_data) {
-  if (iterator->node == &iterator->builder->begin) return false;
-  add_after(iterator->node->prev, filter, post_init_func, user_data);
-  return true;
+void ChannelStackBuilder::PrependFilter(const grpc_channel_filter* filter,
+                                        PostInitFunc post_init) {
+  stack_.insert(stack_.begin(), {filter, std::move(post_init)});
 }
 
-bool grpc_channel_stack_builder_add_filter_after(
-    grpc_channel_stack_builder_iterator* iterator,
-    const grpc_channel_filter* filter,
-    grpc_post_filter_create_init_func post_init_func, void* user_data) {
-  if (iterator->node == &iterator->builder->end) return false;
-  add_after(iterator->node, filter, post_init_func, user_data);
-  return true;
+void ChannelStackBuilder::AppendFilter(const grpc_channel_filter* filter,
+                                       PostInitFunc post_init) {
+  stack_.push_back({filter, std::move(post_init)});
 }
 
-void grpc_channel_stack_builder_destroy(grpc_channel_stack_builder* builder) {
-  filter_node* p = builder->begin.next;
-  while (p != &builder->end) {
-    filter_node* next = p->next;
-    gpr_free(p);
-    p = next;
-  }
-  if (builder->args != nullptr) {
-    grpc_channel_args_destroy(builder->args);
-  }
-  gpr_free(builder->target);
-  gpr_free(builder);
-}
-
-grpc_error_handle grpc_channel_stack_builder_finish(
-    grpc_channel_stack_builder* builder, size_t prefix_bytes, int initial_refs,
-    grpc_iomgr_cb_func destroy, void* destroy_arg, void** result) {
-  // count the number of filters
-  size_t num_filters = 0;
-  for (filter_node* p = builder->begin.next; p != &builder->end; p = p->next) {
-    num_filters++;
-  }
-
+grpc_error_handle ChannelStackBuilder::Build(size_t prefix_bytes,
+                                             int initial_refs,
+                                             grpc_iomgr_cb_func destroy,
+                                             void* destroy_arg, void** result) {
   // create an array of filters
-  const grpc_channel_filter** filters =
-      static_cast<const grpc_channel_filter**>(
-          gpr_malloc(sizeof(*filters) * num_filters));
-  size_t i = 0;
-  for (filter_node* p = builder->begin.next; p != &builder->end; p = p->next) {
-    filters[i++] = p->filter;
+  std::vector<const grpc_channel_filter*> filters;
+  filters.reserve(stack_.size());
+  for (const auto& elem : stack_) {
+    filters.push_back(elem.filter);
   }
 
   // calculate the size of the channel stack
-  size_t channel_stack_size = grpc_channel_stack_size(filters, num_filters);
+  size_t channel_stack_size =
+      grpc_channel_stack_size(filters.data(), filters.size());
 
   // allocate memory, with prefix_bytes followed by channel_stack_size
   *result = gpr_zalloc(prefix_bytes + channel_stack_size);
   // fetch a pointer to the channel stack
   grpc_channel_stack* channel_stack = reinterpret_cast<grpc_channel_stack*>(
       static_cast<char*>(*result) + prefix_bytes);
+
+  const grpc_channel_args* final_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); },
+    };
+    grpc_arg arg = grpc_channel_arg_pointer_create(
+        const_cast<char*>(GRPC_ARG_TRANSPORT), transport_, &vtable);
+    final_args = grpc_channel_args_copy_and_add(args_, &arg, 1);
+  } else {
+    final_args = args_;
+  }
+
   // and initialize it
   grpc_error_handle error = grpc_channel_stack_init(
       initial_refs, destroy, destroy_arg == nullptr ? *result : destroy_arg,
-      filters, num_filters, builder->args, builder->transport, builder->name,
-      channel_stack);
+      filters.data(), filters.size(), final_args, name_, channel_stack);
+
+  if (final_args != args_) {
+    grpc_channel_args_destroy(final_args);
+  }
 
   if (error != GRPC_ERROR_NONE) {
     grpc_channel_stack_destroy(channel_stack);
     gpr_free(*result);
     *result = nullptr;
-  } else {
-    // run post-initialization functions
-    i = 0;
-    for (filter_node* p = builder->begin.next; p != &builder->end;
-         p = p->next) {
-      if (p->init != nullptr) {
-        p->init(channel_stack, grpc_channel_stack_element(channel_stack, i),
-                p->init_arg);
-      }
-      i++;
-    }
+    return error;
   }
 
-  grpc_channel_stack_builder_destroy(builder);
-  gpr_free(const_cast<grpc_channel_filter**>(filters));
+  // run post-initialization functions
+  for (size_t i = 0; i < filters.size(); i++) {
+    if (stack_[i].post_init != nullptr) {
+      stack_[i].post_init(channel_stack,
+                          grpc_channel_stack_element(channel_stack, i));
+    }
+  }
 
-  return error;
+  return GRPC_ERROR_NONE;
 }
+
+}  // namespace grpc_core

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

@@ -1,20 +1,16 @@
-/*
- *
- * Copyright 2016 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.
- *
- */
+// Copyright 2016 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_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H
 #define GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H
@@ -26,130 +22,85 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 
-/// grpc_channel_stack_builder offers a programmatic interface to selected
-/// and order channel filters
-typedef struct grpc_channel_stack_builder grpc_channel_stack_builder;
-typedef struct grpc_channel_stack_builder_iterator
-    grpc_channel_stack_builder_iterator;
-
-/// Create a new channel stack builder.
-/// \a name must be statically allocated.
-grpc_channel_stack_builder* grpc_channel_stack_builder_create(const char* name);
-
-/// Set the target uri
-void grpc_channel_stack_builder_set_target(grpc_channel_stack_builder* b,
-                                           const char* target);
-
-std::string grpc_channel_stack_builder_get_target(
-    grpc_channel_stack_builder* b);
-
-/// Attach \a transport to the builder (does not take ownership)
-void grpc_channel_stack_builder_set_transport(
-    grpc_channel_stack_builder* builder, grpc_transport* transport);
-
-/// Fetch attached transport
-grpc_transport* grpc_channel_stack_builder_get_transport(
-    grpc_channel_stack_builder* builder);
-
-/// Set channel arguments: copies args
-void grpc_channel_stack_builder_set_channel_arguments(
-    grpc_channel_stack_builder* builder, const grpc_channel_args* args);
-
-/// Return a borrowed pointer to the channel arguments
-const grpc_channel_args* grpc_channel_stack_builder_get_channel_arguments(
-    grpc_channel_stack_builder* builder);
-
-/// Begin iterating over already defined filters in the builder at the beginning
-grpc_channel_stack_builder_iterator*
-grpc_channel_stack_builder_create_iterator_at_first(
-    grpc_channel_stack_builder* builder);
-
-/// Begin iterating over already defined filters in the builder at the end
-grpc_channel_stack_builder_iterator*
-grpc_channel_stack_builder_create_iterator_at_last(
-    grpc_channel_stack_builder* builder);
-
-/// Is an iterator at the first element?
-bool grpc_channel_stack_builder_iterator_is_first(
-    grpc_channel_stack_builder_iterator* iterator);
-
-/// Is an iterator at the end?
-bool grpc_channel_stack_builder_iterator_is_end(
-    grpc_channel_stack_builder_iterator* iterator);
-
-/// What is the name of the filter at this iterator position?
-const char* grpc_channel_stack_builder_iterator_filter_name(
-    grpc_channel_stack_builder_iterator* iterator);
-
-/// Move an iterator to the next item
-bool grpc_channel_stack_builder_move_next(
-    grpc_channel_stack_builder_iterator* iterator);
-
-/// Move an iterator to the previous item
-bool grpc_channel_stack_builder_move_prev(
-    grpc_channel_stack_builder_iterator* iterator);
-
-/// Return an iterator at \a filter_name, or at the end of the list if not
-/// found.
-grpc_channel_stack_builder_iterator* grpc_channel_stack_builder_iterator_find(
-    grpc_channel_stack_builder* builder, const char* filter_name);
-
-typedef void (*grpc_post_filter_create_init_func)(
-    grpc_channel_stack* channel_stack, grpc_channel_element* elem, void* arg);
-
-/// Add \a filter to the stack, after \a iterator.
-/// Call \a post_init_func(..., \a user_data) once the channel stack is
-/// created.
-bool grpc_channel_stack_builder_add_filter_after(
-    grpc_channel_stack_builder_iterator* iterator,
-    const grpc_channel_filter* filter,
-    grpc_post_filter_create_init_func post_init_func,
-    void* user_data) GRPC_MUST_USE_RESULT;
-
-/// Add \a filter to the stack, before \a iterator.
-/// Call \a post_init_func(..., \a user_data) once the channel stack is
-/// created.
-bool grpc_channel_stack_builder_add_filter_before(
-    grpc_channel_stack_builder_iterator* iterator,
-    const grpc_channel_filter* filter,
-    grpc_post_filter_create_init_func post_init_func,
-    void* user_data) GRPC_MUST_USE_RESULT;
-
-/// Add \a filter to the beginning of the filter list.
-/// Call \a post_init_func(..., \a user_data) once the channel stack is
-/// created.
-bool grpc_channel_stack_builder_prepend_filter(
-    grpc_channel_stack_builder* builder, const grpc_channel_filter* filter,
-    grpc_post_filter_create_init_func post_init_func,
-    void* user_data) GRPC_MUST_USE_RESULT;
-
-/// Add \a filter to the end of the filter list.
-/// Call \a post_init_func(..., \a user_data) once the channel stack is
-/// created.
-bool grpc_channel_stack_builder_append_filter(
-    grpc_channel_stack_builder* builder, const grpc_channel_filter* filter,
-    grpc_post_filter_create_init_func post_init_func,
-    void* user_data) GRPC_MUST_USE_RESULT;
-
-/// Remove any filter whose name is \a filter_name from \a builder. Returns true
-/// if \a filter_name was not found.
-bool grpc_channel_stack_builder_remove_filter(
-    grpc_channel_stack_builder* builder, const char* filter_name);
-
-/// Terminate iteration and destroy \a iterator
-void grpc_channel_stack_builder_iterator_destroy(
-    grpc_channel_stack_builder_iterator* iterator);
-
-/// Destroy the builder, return the freshly minted channel stack in \a result.
-/// Allocates \a prefix_bytes bytes before the channel stack
-/// Returns the base pointer of the allocated block
-/// \a initial_refs, \a destroy, \a destroy_arg are as per
-/// grpc_channel_stack_init
-grpc_error_handle grpc_channel_stack_builder_finish(
-    grpc_channel_stack_builder* builder, size_t prefix_bytes, int initial_refs,
-    grpc_iomgr_cb_func destroy, void* destroy_arg, void** result);
-
-/// Destroy the builder without creating a channel stack
-void grpc_channel_stack_builder_destroy(grpc_channel_stack_builder* builder);
-
-#endif /* GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H */
+namespace grpc_core {
+
+// Build a channel stack.
+// Allows interested parties to add filters to the stack, and to query an
+// in-progress build.
+// Carries some useful context for the channel stack, such as a target string
+// and a transport.
+class ChannelStackBuilder {
+ public:
+  // A function that will be called after the channel stack is successfully
+  // built.
+  using PostInitFunc = std::function<void(grpc_channel_stack* channel_stack,
+                                          grpc_channel_element* elem)>;
+
+  // One filter in the currently building stack.
+  struct StackEntry {
+    const grpc_channel_filter* filter;
+    PostInitFunc post_init;
+  };
+
+  // Initialize with a name.
+  explicit ChannelStackBuilder(const char* name) : name_(name) {}
+
+  ~ChannelStackBuilder();
+
+  // Set the target string.
+  ChannelStackBuilder& SetTarget(const char* target);
+
+  // 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_; }
+
+  // Set channel args (takes a copy of them).
+  ChannelStackBuilder& SetChannelArgs(const grpc_channel_args* args);
+
+  // Query the channel args.
+  const grpc_channel_args* channel_args() const { return args_; }
+
+  // Mutable vector of proposed stack entries.
+  std::vector<StackEntry>* mutable_stack() { return &stack_; }
+
+  // Helper to add a filter to the front of the stack.
+  void PrependFilter(const grpc_channel_filter* filter, PostInitFunc post_init);
+
+  // Helper to add a filter to the end of the stack.
+  void AppendFilter(const grpc_channel_filter* filter, PostInitFunc post_init);
+
+  // Build the channel stack.
+  // After success, *result holds the new channel stack,
+  // prefix_bytes are allocated before the channel stack,
+  // initial_refs, destroy, destroy_arg are as per grpc_channel_stack_init
+  // On failure, *result is nullptr.
+  grpc_error_handle Build(size_t prefix_bytes, int initial_refs,
+                          grpc_iomgr_cb_func destroy, void* destroy_arg,
+                          void** result);
+
+ private:
+  static std::string unknown_target() { return "unknown"; }
+
+  // The name of the stack
+  const char* const name_;
+  // The target
+  std::string target_{unknown_target()};
+  // The transport
+  grpc_transport* transport_ = nullptr;
+  // Channel args
+  const grpc_channel_args* args_ = nullptr;
+  // The in-progress stack
+  std::vector<StackEntry> stack_;
+};
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H

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

@@ -46,8 +46,7 @@ ChannelTrace::TraceEvent::TraceEvent(Severity severity, const grpc_slice& data,
                                      RefCountedPtr<BaseNode> referenced_entity)
     : severity_(severity),
       data_(data),
-      timestamp_(
-          grpc_millis_to_timespec(ExecCtx::Get()->Now(), GPR_CLOCK_REALTIME)),
+      timestamp_(ExecCtx::Get()->Now().as_timespec(GPR_CLOCK_REALTIME)),
       next_(nullptr),
       referenced_entity_(std::move(referenced_entity)),
       memory_usage_(sizeof(TraceEvent) + grpc_slice_memory_usage(data)) {}
@@ -55,8 +54,7 @@ ChannelTrace::TraceEvent::TraceEvent(Severity severity, const grpc_slice& data,
 ChannelTrace::TraceEvent::TraceEvent(Severity severity, const grpc_slice& data)
     : severity_(severity),
       data_(data),
-      timestamp_(
-          grpc_millis_to_timespec(ExecCtx::Get()->Now(), GPR_CLOCK_REALTIME)),
+      timestamp_(ExecCtx::Get()->Now().as_timespec(GPR_CLOCK_REALTIME)),
       next_(nullptr),
       memory_usage_(sizeof(TraceEvent) + grpc_slice_memory_usage(data)) {}
 
@@ -72,8 +70,7 @@ ChannelTrace::ChannelTrace(size_t max_event_memory)
     return;  // tracing is disabled if max_event_memory_ == 0
   }
   gpr_mu_init(&tracer_mu_);
-  time_created_ =
-      grpc_millis_to_timespec(ExecCtx::Get()->Now(), GPR_CLOCK_REALTIME);
+  time_created_ = ExecCtx::Get()->Now().as_timespec(GPR_CLOCK_REALTIME);
 }
 
 ChannelTrace::~ChannelTrace() {

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

@@ -203,6 +203,7 @@ static void connected_channel_get_channel_info(
 
 const grpc_channel_filter grpc_connected_filter = {
     connected_channel_start_transport_stream_op_batch,
+    nullptr,
     connected_channel_start_transport_op,
     sizeof(call_data),
     connected_channel_init_call_elem,
@@ -232,11 +233,15 @@ static void bind_transport(grpc_channel_stack* channel_stack,
       grpc_transport_stream_size(static_cast<grpc_transport*>(t));
 }
 
-bool grpc_add_connected_filter(grpc_channel_stack_builder* builder) {
-  grpc_transport* t = grpc_channel_stack_builder_get_transport(builder);
+bool grpc_add_connected_filter(grpc_core::ChannelStackBuilder* builder) {
+  grpc_transport* t = builder->transport();
   GPR_ASSERT(t != nullptr);
-  return grpc_channel_stack_builder_append_filter(
-      builder, &grpc_connected_filter, bind_transport, t);
+  builder->AppendFilter(
+      &grpc_connected_filter,
+      [t](grpc_channel_stack* stk, grpc_channel_element* elem) {
+        bind_transport(stk, elem, t);
+      });
+  return true;
 }
 
 grpc_stream* grpc_connected_channel_get_stream(grpc_call_element* elem) {

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

@@ -25,7 +25,7 @@
 
 extern const grpc_channel_filter grpc_connected_filter;
 
-bool grpc_add_connected_filter(grpc_channel_stack_builder* builder);
+bool grpc_add_connected_filter(grpc_core::ChannelStackBuilder* builder);
 
 /* Debug helper to dig the transport stream out of a call element */
 grpc_stream* grpc_connected_channel_get_stream(grpc_call_element* elem);