Rename call_list to closure_list

1 files changed, 17 insertions, 15 deletions

diff --git a/src/core/channel/channel_stack.h b/src/core/channel/channel_stack.h
index 5afe7f258a..b3facd4f01 100644
--- a/src/core/channel/channel_stack.h
+++ b/src/core/channel/channel_stack.h
@@ -66,12 +66,12 @@ typedef struct {
      See grpc_call_next_op on how to call the next element in the stack */
   void (*start_transport_stream_op)(grpc_call_element *elem,
                                     grpc_transport_stream_op *op,
-                                    grpc_call_list *call_list);
+                                    grpc_closure_list *closure_list);
   /* Called to handle channel level operations - e.g. new calls, or transport
      closure.
      See grpc_channel_next_op on how to call the next element in the stack */
   void (*start_transport_op)(grpc_channel_element *elem, grpc_transport_op *op,
-                             grpc_call_list *call_list);
+                             grpc_closure_list *closure_list);
 
   /* sizeof(per call data) */
   size_t sizeof_call_data;
@@ -86,10 +86,11 @@ typedef struct {
   void (*init_call_elem)(grpc_call_element *elem,
                          const void *server_transport_data,
                          grpc_transport_stream_op *initial_op,
-                         grpc_call_list *call_list);
+                         grpc_closure_list *closure_list);
   /* Destroy per call data.
      The filter does not need to do any chaining */
-  void (*destroy_call_elem)(grpc_call_element *elem, grpc_call_list *call_list);
+  void (*destroy_call_elem)(grpc_call_element *elem,
+                            grpc_closure_list *closure_list);
 
   /* sizeof(per channel data) */
   size_t sizeof_channel_data;
@@ -102,14 +103,14 @@ typedef struct {
   void (*init_channel_elem)(grpc_channel_element *elem, grpc_channel *master,
                             const grpc_channel_args *args,
                             grpc_mdctx *metadata_context, int is_first,
-                            int is_last, grpc_call_list *call_list);
+                            int is_last, grpc_closure_list *closure_list);
   /* Destroy per channel data.
      The filter does not need to do any chaining */
   void (*destroy_channel_elem)(grpc_channel_element *elem,
-                               grpc_call_list *call_list);
+                               grpc_closure_list *closure_list);
 
   /* Implement grpc_call_get_peer() */
-  char *(*get_peer)(grpc_call_element *elem, grpc_call_list *call_list);
+  char *(*get_peer)(grpc_call_element *elem, grpc_closure_list *closure_list);
 
   /* The name of this filter */
   const char *name;
@@ -162,10 +163,10 @@ void grpc_channel_stack_init(const grpc_channel_filter **filters,
                              const grpc_channel_args *args,
                              grpc_mdctx *metadata_context,
                              grpc_channel_stack *stack,
-                             grpc_call_list *call_list);
+                             grpc_closure_list *closure_list);
 /* Destroy a channel stack */
 void grpc_channel_stack_destroy(grpc_channel_stack *stack,
-                                grpc_call_list *call_list);
+                                grpc_closure_list *closure_list);
 
 /* Initialize a call stack given a channel stack. transport_server_data is
    expected to be NULL on a client, or an opaque transport owned pointer on the
@@ -174,20 +175,21 @@ void grpc_call_stack_init(grpc_channel_stack *channel_stack,
                           const void *transport_server_data,
                           grpc_transport_stream_op *initial_op,
                           grpc_call_stack *call_stack,
-                          grpc_call_list *call_list);
+                          grpc_closure_list *closure_list);
 /* Destroy a call stack */
-void grpc_call_stack_destroy(grpc_call_stack *stack, grpc_call_list *call_list);
+void grpc_call_stack_destroy(grpc_call_stack *stack,
+                             grpc_closure_list *closure_list);
 
 /* Call the next operation in a call stack */
 void grpc_call_next_op(grpc_call_element *elem, grpc_transport_stream_op *op,
-                       grpc_call_list *call_list);
+                       grpc_closure_list *closure_list);
 /* Call the next operation (depending on call directionality) in a channel
    stack */
 void grpc_channel_next_op(grpc_channel_element *elem, grpc_transport_op *op,
-                          grpc_call_list *call_list);
+                          grpc_closure_list *closure_list);
 /* Pass through a request to get_peer to the next child element */
 char *grpc_call_next_get_peer(grpc_call_element *elem,
-                              grpc_call_list *call_list);
+                              grpc_closure_list *closure_list);
 
 /* Given the top element of a channel stack, get the channel stack itself */
 grpc_channel_stack *grpc_channel_stack_from_top_element(
@@ -199,7 +201,7 @@ void grpc_call_log_op(char *file, int line, gpr_log_severity severity,
                       grpc_call_element *elem, grpc_transport_stream_op *op);
 
 void grpc_call_element_send_cancel(grpc_call_element *cur_elem,
-                                   grpc_call_list *call_list);
+                                   grpc_closure_list *closure_list);
 
 extern int grpc_trace_channel;