Rename call_list to closure_list

3 files changed, 76 insertions, 68 deletions

diff --git a/src/core/httpcli/httpcli.c b/src/core/httpcli/httpcli.c
index fc45eda2de..6422bfb840 100644
--- a/src/core/httpcli/httpcli.c
+++ b/src/core/httpcli/httpcli.c
@@ -71,13 +71,12 @@ typedef struct {
 static grpc_httpcli_get_override g_get_override = NULL;
 static grpc_httpcli_post_override g_post_override = NULL;
 
-static void plaintext_handshake(void *arg, grpc_endpoint *endpoint,
-                                const char *host,
-                                void (*on_done)(void *arg,
-                                                grpc_endpoint *endpoint,
-                                                grpc_call_list *call_list),
-                                grpc_call_list *call_list) {
-  on_done(arg, endpoint, call_list);
+static void plaintext_handshake(
+    void *arg, grpc_endpoint *endpoint, const char *host,
+    void (*on_done)(void *arg, grpc_endpoint *endpoint,
+                    grpc_closure_list *closure_list),
+    grpc_closure_list *closure_list) {
+  on_done(arg, endpoint, closure_list);
 }
 
 const grpc_httpcli_handshaker grpc_httpcli_plaintext = {"http",
@@ -91,19 +90,21 @@ void grpc_httpcli_context_destroy(grpc_httpcli_context *context) {
   grpc_pollset_set_destroy(&context->pollset_set);
 }
 
-static void next_address(internal_request *req, grpc_call_list *call_list);
+static void next_address(internal_request *req,
+                         grpc_closure_list *closure_list);
 
 static void finish(internal_request *req, int success,
-                   grpc_call_list *call_list) {
+                   grpc_closure_list *closure_list) {
   grpc_pollset_set_del_pollset(&req->context->pollset_set, req->pollset,
-                               call_list);
-  req->on_response(req->user_data, success ? &req->parser.r : NULL, call_list);
+                               closure_list);
+  req->on_response(req->user_data, success ? &req->parser.r : NULL,
+                   closure_list);
   grpc_httpcli_parser_destroy(&req->parser);
   if (req->addresses != NULL) {
     grpc_resolved_addresses_destroy(req->addresses);
   }
   if (req->ep != NULL) {
-    grpc_endpoint_destroy(req->ep, call_list);
+    grpc_endpoint_destroy(req->ep, closure_list);
   }
   gpr_slice_unref(req->request_text);
   gpr_free(req->host);
@@ -113,13 +114,15 @@ static void finish(internal_request *req, int success,
   gpr_free(req);
 }
 
-static void on_read(void *user_data, int success, grpc_call_list *call_list);
+static void on_read(void *user_data, int success,
+                    grpc_closure_list *closure_list);
 
-static void do_read(internal_request *req, grpc_call_list *call_list) {
-  grpc_endpoint_read(req->ep, &req->incoming, &req->on_read, call_list);
+static void do_read(internal_request *req, grpc_closure_list *closure_list) {
+  grpc_endpoint_read(req->ep, &req->incoming, &req->on_read, closure_list);
 }
 
-static void on_read(void *user_data, int success, grpc_call_list *call_list) {
+static void on_read(void *user_data, int success,
+                    grpc_closure_list *closure_list) {
   internal_request *req = user_data;
   size_t i;
 
@@ -127,94 +130,98 @@ static void on_read(void *user_data, int success, grpc_call_list *call_list) {
     if (GPR_SLICE_LENGTH(req->incoming.slices[i])) {
       req->have_read_byte = 1;
       if (!grpc_httpcli_parser_parse(&req->parser, req->incoming.slices[i])) {
-        finish(req, 0, call_list);
+        finish(req, 0, closure_list);
         return;
       }
     }
   }
 
   if (success) {
-    do_read(req, call_list);
+    do_read(req, closure_list);
   } else if (!req->have_read_byte) {
-    next_address(req, call_list);
+    next_address(req, closure_list);
   } else {
-    finish(req, grpc_httpcli_parser_eof(&req->parser), call_list);
+    finish(req, grpc_httpcli_parser_eof(&req->parser), closure_list);
   }
 }
 
-static void on_written(internal_request *req, grpc_call_list *call_list) {
-  do_read(req, call_list);
+static void on_written(internal_request *req, grpc_closure_list *closure_list) {
+  do_read(req, closure_list);
 }
 
-static void done_write(void *arg, int success, grpc_call_list *call_list) {
+static void done_write(void *arg, int success,
+                       grpc_closure_list *closure_list) {
   internal_request *req = arg;
   if (success) {
-    on_written(req, call_list);
+    on_written(req, closure_list);
   } else {
-    next_address(req, call_list);
+    next_address(req, closure_list);
   }
 }
 
-static void start_write(internal_request *req, grpc_call_list *call_list) {
+static void start_write(internal_request *req,
+                        grpc_closure_list *closure_list) {
   gpr_slice_ref(req->request_text);
   gpr_slice_buffer_add(&req->outgoing, req->request_text);
-  grpc_endpoint_write(req->ep, &req->outgoing, &req->done_write, call_list);
+  grpc_endpoint_write(req->ep, &req->outgoing, &req->done_write, closure_list);
 }
 
 static void on_handshake_done(void *arg, grpc_endpoint *ep,
-                              grpc_call_list *call_list) {
+                              grpc_closure_list *closure_list) {
   internal_request *req = arg;
 
   if (!ep) {
-    next_address(req, call_list);
+    next_address(req, closure_list);
     return;
   }
 
   req->ep = ep;
-  start_write(req, call_list);
+  start_write(req, closure_list);
 }
 
-static void on_connected(void *arg, int success, grpc_call_list *call_list) {
+static void on_connected(void *arg, int success,
+                         grpc_closure_list *closure_list) {
   internal_request *req = arg;
 
   if (!req->ep) {
-    next_address(req, call_list);
+    next_address(req, closure_list);
     return;
   }
   req->handshaker->handshake(req, req->ep, req->host, on_handshake_done,
-                             call_list);
+                             closure_list);
 }
 
-static void next_address(internal_request *req, grpc_call_list *call_list) {
+static void next_address(internal_request *req,
+                         grpc_closure_list *closure_list) {
   grpc_resolved_address *addr;
   if (req->next_address == req->addresses->naddrs) {
-    finish(req, 0, call_list);
+    finish(req, 0, closure_list);
     return;
   }
   addr = &req->addresses->addrs[req->next_address++];
   grpc_closure_init(&req->connected, on_connected, req);
   grpc_tcp_client_connect(&req->connected, &req->ep, &req->context->pollset_set,
                           (struct sockaddr *)&addr->addr, addr->len,
-                          req->deadline, call_list);
+                          req->deadline, closure_list);
 }
 
 static void on_resolved(void *arg, grpc_resolved_addresses *addresses,
-                        grpc_call_list *call_list) {
+                        grpc_closure_list *closure_list) {
   internal_request *req = arg;
   if (!addresses) {
-    finish(req, 0, call_list);
+    finish(req, 0, closure_list);
     return;
   }
   req->addresses = addresses;
   req->next_address = 0;
-  next_address(req, call_list);
+  next_address(req, closure_list);
 }
 
 static void internal_request_begin(
     grpc_httpcli_context *context, grpc_pollset *pollset,
     const grpc_httpcli_request *request, gpr_timespec deadline,
     grpc_httpcli_response_cb on_response, void *user_data, const char *name,
-    gpr_slice request_text, grpc_call_list *call_list) {
+    gpr_slice request_text, grpc_closure_list *closure_list) {
   internal_request *req = gpr_malloc(sizeof(internal_request));
   memset(req, 0, sizeof(*req));
   req->request_text = request_text;
@@ -234,7 +241,7 @@ static void internal_request_begin(
   req->host = gpr_strdup(request->host);
 
   grpc_pollset_set_add_pollset(&req->context->pollset_set, req->pollset,
-                               call_list);
+                               closure_list);
   grpc_resolve_address(request->host, req->handshaker->default_port,
                        on_resolved, req);
 }
@@ -243,16 +250,16 @@ void grpc_httpcli_get(grpc_httpcli_context *context, grpc_pollset *pollset,
                       const grpc_httpcli_request *request,
                       gpr_timespec deadline,
                       grpc_httpcli_response_cb on_response, void *user_data,
-                      grpc_call_list *call_list) {
+                      grpc_closure_list *closure_list) {
   char *name;
   if (g_get_override &&
-      g_get_override(request, deadline, on_response, user_data, call_list)) {
+      g_get_override(request, deadline, on_response, user_data, closure_list)) {
     return;
   }
   gpr_asprintf(&name, "HTTP:GET:%s:%s", request->host, request->path);
-  internal_request_begin(context, pollset, request, deadline, on_response,
-                         user_data, name,
-                         grpc_httpcli_format_get_request(request), call_list);
+  internal_request_begin(
+      context, pollset, request, deadline, on_response, user_data, name,
+      grpc_httpcli_format_get_request(request), closure_list);
   gpr_free(name);
 }
 
@@ -261,18 +268,18 @@ void grpc_httpcli_post(grpc_httpcli_context *context, grpc_pollset *pollset,
                        const char *body_bytes, size_t body_size,
                        gpr_timespec deadline,
                        grpc_httpcli_response_cb on_response, void *user_data,
-                       grpc_call_list *call_list) {
+                       grpc_closure_list *closure_list) {
   char *name;
   if (g_post_override &&
       g_post_override(request, body_bytes, body_size, deadline, on_response,
-                      user_data, call_list)) {
+                      user_data, closure_list)) {
     return;
   }
   gpr_asprintf(&name, "HTTP:POST:%s:%s", request->host, request->path);
   internal_request_begin(
       context, pollset, request, deadline, on_response, user_data, name,
       grpc_httpcli_format_post_request(request, body_bytes, body_size),
-      call_list);
+      closure_list);
   gpr_free(name);
 }
 
diff --git a/src/core/httpcli/httpcli.h b/src/core/httpcli/httpcli.h
index 6d19da37fb..2460c6ca60 100644
--- a/src/core/httpcli/httpcli.h
+++ b/src/core/httpcli/httpcli.h
@@ -63,8 +63,8 @@ typedef struct {
   const char *default_port;
   void (*handshake)(void *arg, grpc_endpoint *endpoint, const char *host,
                     void (*on_done)(void *arg, grpc_endpoint *endpoint,
-                                    grpc_call_list *call_list),
-                    grpc_call_list *call_list);
+                                    grpc_closure_list *closure_list),
+                    grpc_closure_list *closure_list);
 } grpc_httpcli_handshaker;
 
 extern const grpc_httpcli_handshaker grpc_httpcli_plaintext;
@@ -100,7 +100,7 @@ typedef struct grpc_httpcli_response {
 /* Callback for grpc_httpcli_get and grpc_httpcli_post. */
 typedef void (*grpc_httpcli_response_cb)(void *user_data,
                                          const grpc_httpcli_response *response,
-                                         grpc_call_list *call_list);
+                                         grpc_closure_list *closure_list);
 
 void grpc_httpcli_context_init(grpc_httpcli_context *context);
 void grpc_httpcli_context_destroy(grpc_httpcli_context *context);
@@ -119,7 +119,7 @@ void grpc_httpcli_get(grpc_httpcli_context *context, grpc_pollset *pollset,
                       const grpc_httpcli_request *request,
                       gpr_timespec deadline,
                       grpc_httpcli_response_cb on_response, void *user_data,
-                      grpc_call_list *call_list);
+                      grpc_closure_list *closure_list);
 
 /* Asynchronously perform a HTTP POST.
    'context' specifies the http context under which to do the post
@@ -141,21 +141,21 @@ void grpc_httpcli_post(grpc_httpcli_context *context, grpc_pollset *pollset,
                        const char *body_bytes, size_t body_size,
                        gpr_timespec deadline,
                        grpc_httpcli_response_cb on_response, void *user_data,
-                       grpc_call_list *call_list);
+                       grpc_closure_list *closure_list);
 
 /* override functions return 1 if they handled the request, 0 otherwise */
 typedef int (*grpc_httpcli_get_override)(const grpc_httpcli_request *request,
                                          gpr_timespec deadline,
                                          grpc_httpcli_response_cb on_response,
                                          void *user_data,
-                                         grpc_call_list *call_list);
+                                         grpc_closure_list *closure_list);
 typedef int (*grpc_httpcli_post_override)(const grpc_httpcli_request *request,
                                           const char *body_bytes,
                                           size_t body_size,
                                           gpr_timespec deadline,
                                           grpc_httpcli_response_cb on_response,
                                           void *user_data,
-                                          grpc_call_list *call_list);
+                                          grpc_closure_list *closure_list);
 
 void grpc_httpcli_set_override(grpc_httpcli_get_override get,
                                grpc_httpcli_post_override post);
diff --git a/src/core/httpcli/httpcli_security_connector.c b/src/core/httpcli/httpcli_security_connector.c
index a340a90c4b..1ae1d7f09b 100644
--- a/src/core/httpcli/httpcli_security_connector.c
+++ b/src/core/httpcli/httpcli_security_connector.c
@@ -62,13 +62,13 @@ static void httpcli_ssl_do_handshake(grpc_security_connector *sc,
                                      grpc_endpoint *nonsecure_endpoint,
                                      grpc_security_handshake_done_cb cb,
                                      void *user_data,
-                                     grpc_call_list *call_list) {
+                                     grpc_closure_list *closure_list) {
   grpc_httpcli_ssl_channel_security_connector *c =
       (grpc_httpcli_ssl_channel_security_connector *)sc;
   tsi_result result = TSI_OK;
   tsi_handshaker *handshaker;
   if (c->handshaker_factory == NULL) {
-    cb(user_data, GRPC_SECURITY_ERROR, nonsecure_endpoint, NULL, call_list);
+    cb(user_data, GRPC_SECURITY_ERROR, nonsecure_endpoint, NULL, closure_list);
     return;
   }
   result = tsi_ssl_handshaker_factory_create_handshaker(
@@ -76,10 +76,10 @@ static void httpcli_ssl_do_handshake(grpc_security_connector *sc,
   if (result != TSI_OK) {
     gpr_log(GPR_ERROR, "Handshaker creation failed with error %s.",
             tsi_result_to_string(result));
-    cb(user_data, GRPC_SECURITY_ERROR, nonsecure_endpoint, NULL, call_list);
+    cb(user_data, GRPC_SECURITY_ERROR, nonsecure_endpoint, NULL, closure_list);
   } else {
     grpc_do_security_handshake(handshaker, sc, nonsecure_endpoint, cb,
-                               user_data, call_list);
+                               user_data, closure_list);
   }
 }
 
@@ -143,7 +143,8 @@ static grpc_security_status httpcli_ssl_channel_security_connector_create(
 /* handshaker */
 
 typedef struct {
-  void (*func)(void *arg, grpc_endpoint *endpoint, grpc_call_list *call_list);
+  void (*func)(void *arg, grpc_endpoint *endpoint,
+               grpc_closure_list *closure_list);
   void *arg;
 } on_done_closure;
 
@@ -151,28 +152,28 @@ static void on_secure_transport_setup_done(void *rp,
                                            grpc_security_status status,
                                            grpc_endpoint *wrapped_endpoint,
                                            grpc_endpoint *secure_endpoint,
-                                           grpc_call_list *call_list) {
+                                           grpc_closure_list *closure_list) {
   on_done_closure *c = rp;
   if (status != GRPC_SECURITY_OK) {
     gpr_log(GPR_ERROR, "Secure transport setup failed with error %d.", status);
-    c->func(c->arg, NULL, call_list);
+    c->func(c->arg, NULL, closure_list);
   } else {
-    c->func(c->arg, secure_endpoint, call_list);
+    c->func(c->arg, secure_endpoint, closure_list);
   }
   gpr_free(c);
 }
 
 static void ssl_handshake(void *arg, grpc_endpoint *tcp, const char *host,
                           void (*on_done)(void *arg, grpc_endpoint *endpoint,
-                                          grpc_call_list *call_list),
-                          grpc_call_list *call_list) {
+                                          grpc_closure_list *closure_list),
+                          grpc_closure_list *closure_list) {
   grpc_channel_security_connector *sc = NULL;
   const unsigned char *pem_root_certs = NULL;
   on_done_closure *c = gpr_malloc(sizeof(*c));
   size_t pem_root_certs_size = grpc_get_default_ssl_roots(&pem_root_certs);
   if (pem_root_certs == NULL || pem_root_certs_size == 0) {
     gpr_log(GPR_ERROR, "Could not get default pem root certs.");
-    on_done(arg, NULL, call_list);
+    on_done(arg, NULL, closure_list);
     gpr_free(c);
     return;
   }
@@ -182,7 +183,7 @@ static void ssl_handshake(void *arg, grpc_endpoint *tcp, const char *host,
                  pem_root_certs, pem_root_certs_size, host, &sc) ==
              GRPC_SECURITY_OK);
   grpc_security_connector_do_handshake(
-      &sc->base, tcp, on_secure_transport_setup_done, c, call_list);
+      &sc->base, tcp, on_secure_transport_setup_done, c, closure_list);
   GRPC_SECURITY_CONNECTOR_UNREF(&sc->base, "httpcli");
 }