grpc 1.7.3 → 1.8.0

data/src/core/lib/channel/{channel_stack_builder.c → channel_stack_builder.cc}

@@ -23,15 +23,15 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
-grpc_tracer_flag grpc_trace_channel_stack_builder =
-    GRPC_TRACER_INITIALIZER(false, "channel_stack_builder");
+grpc_core::TraceFlag grpc_trace_channel_stack_builder(false,
+                                                      "channel_stack_builder");
 
 typedef struct filter_node {
-  struct filter_node *next;
-  struct filter_node *prev;
-  const grpc_channel_filter *filter;
+  struct filter_node* next;
+  struct filter_node* prev;
+  const grpc_channel_filter* filter;
   grpc_post_filter_create_init_func init;
-  void *init_arg;
+  void* init_arg;
 } filter_node;
 
 struct grpc_channel_stack_builder {
@@ -39,23 +39,23 @@ struct grpc_channel_stack_builder {
   filter_node begin;
   filter_node end;
   // various set/get-able parameters
-  grpc_channel_args *args;
-  grpc_transport *transport;
-  char *target;
-  const char *name;
+  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* builder;
+  filter_node* node;
 };
 
-grpc_channel_stack_builder *grpc_channel_stack_builder_create(void) {
-  grpc_channel_stack_builder *b =
-      (grpc_channel_stack_builder *)gpr_zalloc(sizeof(*b));
+grpc_channel_stack_builder* grpc_channel_stack_builder_create(void) {
+  grpc_channel_stack_builder* b =
+      (grpc_channel_stack_builder*)gpr_zalloc(sizeof(*b));
 
-  b->begin.filter = NULL;
-  b->end.filter = NULL;
+  b->begin.filter = nullptr;
+  b->end.filter = nullptr;
   b->begin.next = &b->end;
   b->begin.prev = &b->end;
   b->end.next = &b->begin;
@@ -64,76 +64,76 @@ grpc_channel_stack_builder *grpc_channel_stack_builder_create(void) {
   return b;
 }
 
-void grpc_channel_stack_builder_set_target(grpc_channel_stack_builder *b,
-                                           const char *target) {
+void grpc_channel_stack_builder_set_target(grpc_channel_stack_builder* b,
+                                           const char* target) {
   gpr_free(b->target);
   b->target = gpr_strdup(target);
 }
 
-const char *grpc_channel_stack_builder_get_target(
-    grpc_channel_stack_builder *b) {
+const char* grpc_channel_stack_builder_get_target(
+    grpc_channel_stack_builder* b) {
   return 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 =
-      (grpc_channel_stack_builder_iterator *)gpr_malloc(sizeof(*it));
+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 =
+      (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) {
+    grpc_channel_stack_builder_iterator* it) {
   gpr_free(it);
 }
 
-grpc_channel_stack_builder_iterator *
+grpc_channel_stack_builder_iterator*
 grpc_channel_stack_builder_create_iterator_at_first(
-    grpc_channel_stack_builder *builder) {
+    grpc_channel_stack_builder* builder) {
   return create_iterator_at_filter_node(builder, &builder->begin);
 }
 
-grpc_channel_stack_builder_iterator *
+grpc_channel_stack_builder_iterator*
 grpc_channel_stack_builder_create_iterator_at_last(
-    grpc_channel_stack_builder *builder) {
+    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) {
+    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 == NULL) return NULL;
+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) {
+    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) {
+    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 != NULL);
-  grpc_channel_stack_builder_iterator *it =
+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 =
+    const char* filter_name_at_it =
         grpc_channel_stack_builder_iterator_filter_name(it);
     if (strcmp(filter_name, filter_name_at_it) == 0) break;
   }
@@ -141,43 +141,43 @@ grpc_channel_stack_builder_iterator *grpc_channel_stack_builder_iterator_find(
 }
 
 bool grpc_channel_stack_builder_move_prev(
-    grpc_channel_stack_builder_iterator *iterator);
+    grpc_channel_stack_builder_iterator* iterator);
 
-void grpc_channel_stack_builder_set_name(grpc_channel_stack_builder *builder,
-                                         const char *name) {
-  GPR_ASSERT(builder->name == NULL);
+void grpc_channel_stack_builder_set_name(grpc_channel_stack_builder* builder,
+                                         const char* name) {
+  GPR_ASSERT(builder->name == nullptr);
   builder->name = name;
 }
 
 void grpc_channel_stack_builder_set_channel_arguments(
-    grpc_exec_ctx *exec_ctx, grpc_channel_stack_builder *builder,
-    const grpc_channel_args *args) {
-  if (builder->args != NULL) {
+    grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder,
+    const grpc_channel_args* args) {
+  if (builder->args != nullptr) {
     grpc_channel_args_destroy(exec_ctx, builder->args);
   }
   builder->args = grpc_channel_args_copy(args);
 }
 
 void grpc_channel_stack_builder_set_transport(
-    grpc_channel_stack_builder *builder, grpc_transport *transport) {
-  GPR_ASSERT(builder->transport == NULL);
+    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) {
+grpc_transport* grpc_channel_stack_builder_get_transport(
+    grpc_channel_stack_builder* builder) {
   return builder->transport;
 }
 
-const grpc_channel_args *grpc_channel_stack_builder_get_channel_arguments(
-    grpc_channel_stack_builder *builder) {
+const grpc_channel_args* grpc_channel_stack_builder_get_channel_arguments(
+    grpc_channel_stack_builder* builder) {
   return builder->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* 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);
@@ -186,8 +186,8 @@ bool grpc_channel_stack_builder_append_filter(
 }
 
 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* 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);
@@ -201,9 +201,9 @@ bool grpc_channel_stack_builder_remove_filter(
 }
 
 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* 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);
@@ -211,10 +211,10 @@ bool grpc_channel_stack_builder_prepend_filter(
   return ok;
 }
 
-static void add_after(filter_node *before, const grpc_channel_filter *filter,
+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 = (filter_node *)gpr_malloc(sizeof(*new_node));
+                      void* user_data) {
+  filter_node* new_node = (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;
@@ -224,53 +224,53 @@ static void add_after(filter_node *before, const grpc_channel_filter *filter,
 }
 
 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_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;
 }
 
 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_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 grpc_channel_stack_builder_destroy(grpc_exec_ctx *exec_ctx,
-                                        grpc_channel_stack_builder *builder) {
-  filter_node *p = builder->begin.next;
+void grpc_channel_stack_builder_destroy(grpc_exec_ctx* exec_ctx,
+                                        grpc_channel_stack_builder* builder) {
+  filter_node* p = builder->begin.next;
   while (p != &builder->end) {
-    filter_node *next = p->next;
+    filter_node* next = p->next;
     gpr_free(p);
     p = next;
   }
-  if (builder->args != NULL) {
+  if (builder->args != nullptr) {
     grpc_channel_args_destroy(exec_ctx, builder->args);
   }
   gpr_free(builder->target);
   gpr_free(builder);
 }
 
-grpc_error *grpc_channel_stack_builder_finish(
-    grpc_exec_ctx *exec_ctx, grpc_channel_stack_builder *builder,
+grpc_error* grpc_channel_stack_builder_finish(
+    grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder,
     size_t prefix_bytes, int initial_refs, grpc_iomgr_cb_func destroy,
-    void *destroy_arg, void **result) {
+    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) {
+  for (filter_node* p = builder->begin.next; p != &builder->end; p = p->next) {
     num_filters++;
   }
 
   // create an array of filters
-  const grpc_channel_filter **filters =
-      (const grpc_channel_filter **)gpr_malloc(sizeof(*filters) * num_filters);
+  const grpc_channel_filter** filters =
+      (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) {
+  for (filter_node* p = builder->begin.next; p != &builder->end; p = p->next) {
     filters[i++] = p->filter;
   }
 
@@ -280,24 +280,24 @@ grpc_error *grpc_channel_stack_builder_finish(
   // 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 =
-      (grpc_channel_stack *)((char *)(*result) + prefix_bytes);
+  grpc_channel_stack* channel_stack =
+      (grpc_channel_stack*)((char*)(*result) + prefix_bytes);
   // and initialize it
-  grpc_error *error = grpc_channel_stack_init(
+  grpc_error* error = grpc_channel_stack_init(
       exec_ctx, initial_refs, destroy,
-      destroy_arg == NULL ? *result : destroy_arg, filters, num_filters,
+      destroy_arg == nullptr ? *result : destroy_arg, filters, num_filters,
       builder->args, builder->transport, builder->name, channel_stack);
 
   if (error != GRPC_ERROR_NONE) {
     grpc_channel_stack_destroy(exec_ctx, channel_stack);
     gpr_free(*result);
-    *result = NULL;
+    *result = nullptr;
   } else {
     // run post-initialization functions
     i = 0;
-    for (filter_node *p = builder->begin.next; p != &builder->end;
+    for (filter_node* p = builder->begin.next; p != &builder->end;
          p = p->next) {
-      if (p->init != NULL) {
+      if (p->init != nullptr) {
         p->init(channel_stack, grpc_channel_stack_element(channel_stack, i),
                 p->init_arg);
       }
@@ -306,7 +306,7 @@ grpc_error *grpc_channel_stack_builder_finish(
   }
 
   grpc_channel_stack_builder_destroy(exec_ctx, builder);
-  gpr_free((grpc_channel_filter **)filters);
+  gpr_free((grpc_channel_filter**)filters);
 
   return error;
 }

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

@@ -35,132 +35,132 @@ typedef struct grpc_channel_stack_builder_iterator
     grpc_channel_stack_builder_iterator;
 
 /// Create a new channel stack builder
-grpc_channel_stack_builder *grpc_channel_stack_builder_create(void);
+grpc_channel_stack_builder* grpc_channel_stack_builder_create(void);
 
 /// Assign a name to the channel stack: \a name must be statically allocated
-void grpc_channel_stack_builder_set_name(grpc_channel_stack_builder *builder,
-                                         const char *name);
+void grpc_channel_stack_builder_set_name(grpc_channel_stack_builder* builder,
+                                         const char* name);
 
 /// Set the target uri
-void grpc_channel_stack_builder_set_target(grpc_channel_stack_builder *b,
-                                           const char *target);
+void grpc_channel_stack_builder_set_target(grpc_channel_stack_builder* b,
+                                           const char* target);
 
-const char *grpc_channel_stack_builder_get_target(
-    grpc_channel_stack_builder *b);
+const char* 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);
+    grpc_channel_stack_builder* builder, grpc_transport* transport);
 
 /// Fetch attached transport
-grpc_transport *grpc_channel_stack_builder_get_transport(
-    grpc_channel_stack_builder *builder);
+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_exec_ctx *exec_ctx, grpc_channel_stack_builder *builder,
-    const grpc_channel_args *args);
+    grpc_exec_ctx* exec_ctx, 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);
+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_iterator*
 grpc_channel_stack_builder_create_iterator_at_first(
-    grpc_channel_stack_builder *builder);
+    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_iterator*
 grpc_channel_stack_builder_create_iterator_at_last(
-    grpc_channel_stack_builder *builder);
+    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);
+    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);
+    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);
+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);
+    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);
+    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);
+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);
+    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_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;
+    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_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;
+    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_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;
+    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_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;
+    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);
+    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);
+    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 *grpc_channel_stack_builder_finish(
-    grpc_exec_ctx *exec_ctx, grpc_channel_stack_builder *builder,
+grpc_error* grpc_channel_stack_builder_finish(
+    grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder,
     size_t prefix_bytes, int initial_refs, grpc_iomgr_cb_func destroy,
-    void *destroy_arg, void **result);
+    void* destroy_arg, void** result);
 
 /// Destroy the builder without creating a channel stack
-void grpc_channel_stack_builder_destroy(grpc_exec_ctx *exec_ctx,
-                                        grpc_channel_stack_builder *builder);
+void grpc_channel_stack_builder_destroy(grpc_exec_ctx* exec_ctx,
+                                        grpc_channel_stack_builder* builder);
 
-extern grpc_tracer_flag grpc_trace_channel_stack_builder;
+extern grpc_core::TraceFlag grpc_trace_channel_stack_builder;
 
 #ifdef __cplusplus
 }