diff --git a/src/core/census/grpc_filter.c b/src/core/census/grpc_filter.c
index fa318c4e5410a63962b956d294e21d70febb0da4..26de5142c5d6754c29e7e9c0fd60692dcadbe880 100644
--- a/src/core/census/grpc_filter.c
+++ b/src/core/census/grpc_filter.c
@@ -90,20 +90,20 @@ static void client_mutate_op(grpc_call_element* elem,
static void client_start_transport_op(grpc_call_element* elem,
grpc_transport_stream_op* op,
- grpc_call_list* call_list) {
+ grpc_closure_list* closure_list) {
client_mutate_op(elem, op);
- grpc_call_next_op(elem, op, call_list);
+ grpc_call_next_op(elem, op, closure_list);
}
static void server_on_done_recv(void* ptr, int success,
- grpc_call_list* call_list) {
+ grpc_closure_list* closure_list) {
grpc_call_element* elem = ptr;
call_data* calld = elem->call_data;
channel_data* chand = elem->channel_data;
if (success) {
extract_and_annotate_method_tag(calld->recv_ops, calld, chand);
}
- calld->on_done_recv->cb(calld->on_done_recv->cb_arg, success, call_list);
+ calld->on_done_recv->cb(calld->on_done_recv->cb_arg, success, closure_list);
}
static void server_mutate_op(grpc_call_element* elem,
@@ -119,17 +119,17 @@ static void server_mutate_op(grpc_call_element* elem,
static void server_start_transport_op(grpc_call_element* elem,
grpc_transport_stream_op* op,
- grpc_call_list* call_list) {
+ grpc_closure_list* closure_list) {
call_data* calld = elem->call_data;
GPR_ASSERT((calld->op_id.upper != 0) || (calld->op_id.lower != 0));
server_mutate_op(elem, op);
- grpc_call_next_op(elem, op, call_list);
+ grpc_call_next_op(elem, op, closure_list);
}
static void client_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) {
call_data* d = elem->call_data;
GPR_ASSERT(d != NULL);
d->start_ts = gpr_now(GPR_CLOCK_REALTIME);
@@ -137,7 +137,7 @@ static void client_init_call_elem(grpc_call_element* elem,
}
static void client_destroy_call_elem(grpc_call_element* elem,
- grpc_call_list* call_list) {
+ grpc_closure_list* closure_list) {
call_data* d = elem->call_data;
GPR_ASSERT(d != NULL);
/* TODO(hongyu): record rpc client stats and census_rpc_end_op here */
@@ -146,7 +146,7 @@ static void client_destroy_call_elem(grpc_call_element* elem,
static void server_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) {
call_data* d = elem->call_data;
GPR_ASSERT(d != NULL);
d->start_ts = gpr_now(GPR_CLOCK_REALTIME);
@@ -156,7 +156,7 @@ static void server_init_call_elem(grpc_call_element* elem,
}
static void server_destroy_call_elem(grpc_call_element* elem,
- grpc_call_list* call_list) {
+ grpc_closure_list* closure_list) {
call_data* d = elem->call_data;
GPR_ASSERT(d != NULL);
/* TODO(hongyu): record rpc server stats and census_tracing_end_op here */
@@ -165,14 +165,14 @@ static void server_destroy_call_elem(grpc_call_element* elem,
static void init_channel_elem(grpc_channel_element* elem, grpc_channel* master,
const grpc_channel_args* args, grpc_mdctx* mdctx,
int is_first, int is_last,
- grpc_call_list* call_list) {
+ grpc_closure_list* closure_list) {
channel_data* chand = elem->channel_data;
GPR_ASSERT(chand != NULL);
chand->path_str = grpc_mdstr_from_string(mdctx, ":path", 0);
}
static void destroy_channel_elem(grpc_channel_element* elem,
- grpc_call_list* call_list) {
+ grpc_closure_list* closure_list) {
channel_data* chand = elem->channel_data;
GPR_ASSERT(chand != NULL);
if (chand->path_str != NULL) {
diff --git a/src/core/channel/channel_stack.c b/src/core/channel/channel_stack.c
index 10fbd520c32874521badf5b5028bbcb0e6092f2b..47f1f8e828d77fc7d3fdf4b9eab6958b808381fe 100644
--- a/src/core/channel/channel_stack.c
+++ b/src/core/channel/channel_stack.c
@@ -106,7 +106,7 @@ 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) {
size_t call_size =
ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)) +
ROUND_UP_TO_ALIGNMENT_SIZE(filter_count * sizeof(grpc_call_element));
@@ -126,7 +126,7 @@ void grpc_channel_stack_init(const grpc_channel_filter **filters,
elems[i].channel_data = user_data;
elems[i].filter->init_channel_elem(&elems[i], master, args,
metadata_context, i == 0,
- i == (filter_count - 1), call_list);
+ i == (filter_count - 1), closure_list);
user_data += ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_channel_data);
call_size += ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_call_data);
}
@@ -139,14 +139,15 @@ void grpc_channel_stack_init(const grpc_channel_filter **filters,
}
void grpc_channel_stack_destroy(grpc_channel_stack *stack,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_channel_element *channel_elems = CHANNEL_ELEMS_FROM_STACK(stack);
size_t count = stack->count;
size_t i;
/* destroy per-filter data */
for (i = 0; i < count; i++) {
- channel_elems[i].filter->destroy_channel_elem(&channel_elems[i], call_list);
+ channel_elems[i].filter->destroy_channel_elem(&channel_elems[i],
+ closure_list);
}
}
@@ -154,7 +155,7 @@ 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) {
grpc_channel_element *channel_elems = CHANNEL_ELEMS_FROM_STACK(channel_stack);
size_t count = channel_stack->count;
grpc_call_element *call_elems;
@@ -172,40 +173,40 @@ void grpc_call_stack_init(grpc_channel_stack *channel_stack,
call_elems[i].channel_data = channel_elems[i].channel_data;
call_elems[i].call_data = user_data;
call_elems[i].filter->init_call_elem(&call_elems[i], transport_server_data,
- initial_op, call_list);
+ initial_op, closure_list);
user_data +=
ROUND_UP_TO_ALIGNMENT_SIZE(call_elems[i].filter->sizeof_call_data);
}
}
void grpc_call_stack_destroy(grpc_call_stack *stack,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_call_element *elems = CALL_ELEMS_FROM_STACK(stack);
size_t count = stack->count;
size_t i;
/* destroy per-filter data */
for (i = 0; i < count; i++) {
- elems[i].filter->destroy_call_elem(&elems[i], call_list);
+ elems[i].filter->destroy_call_elem(&elems[i], closure_list);
}
}
void grpc_call_next_op(grpc_call_element *elem, grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_call_element *next_elem = elem + 1;
- next_elem->filter->start_transport_stream_op(next_elem, op, call_list);
+ next_elem->filter->start_transport_stream_op(next_elem, op, closure_list);
}
char *grpc_call_next_get_peer(grpc_call_element *elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_call_element *next_elem = elem + 1;
- return next_elem->filter->get_peer(next_elem, call_list);
+ return next_elem->filter->get_peer(next_elem, closure_list);
}
void grpc_channel_next_op(grpc_channel_element *elem, grpc_transport_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_channel_element *next_elem = elem + 1;
- next_elem->filter->start_transport_op(next_elem, op, call_list);
+ next_elem->filter->start_transport_op(next_elem, op, closure_list);
}
grpc_channel_stack *grpc_channel_stack_from_top_element(
@@ -220,9 +221,9 @@ grpc_call_stack *grpc_call_stack_from_top_element(grpc_call_element *elem) {
}
void grpc_call_element_send_cancel(grpc_call_element *cur_elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_transport_stream_op op;
memset(&op, 0, sizeof(op));
op.cancel_with_status = GRPC_STATUS_CANCELLED;
- grpc_call_next_op(cur_elem, &op, call_list);
+ grpc_call_next_op(cur_elem, &op, closure_list);
}
diff --git a/src/core/channel/channel_stack.h b/src/core/channel/channel_stack.h
index 5afe7f258a0593d7df038cf498c7ed44c3a30596..b3facd4f014ebf8b0c85bb0014f542bf5fa67e59 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;
diff --git a/src/core/channel/client_channel.c b/src/core/channel/client_channel.c
index 62f81daf44756c5dcb18404cc739b41fa45a930f..54adeaee9d993818b1fa5f1ed7ea3fcd6c63ad4c 100644
--- a/src/core/channel/client_channel.c
+++ b/src/core/channel/client_channel.c
@@ -73,7 +73,7 @@ typedef struct {
guarded by mu_config */
grpc_client_config *incoming_configuration;
/** a list of closures that are all waiting for config to come in */
- grpc_call_list waiting_for_config_closures;
+ grpc_closure_list waiting_for_config_closures;
/** resolver callback */
grpc_closure on_config_changed;
/** connectivity state being tracked */
@@ -129,12 +129,12 @@ static grpc_closure *merge_into_waiting_op(grpc_call_element *elem,
static void handle_op_after_cancellation(grpc_call_element *elem,
grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
call_data *calld = elem->call_data;
channel_data *chand = elem->channel_data;
if (op->send_ops) {
grpc_stream_ops_unref_owned_objects(op->send_ops->ops, op->send_ops->nops);
- op->on_done_send->cb(op->on_done_send->cb_arg, 0, call_list);
+ op->on_done_send->cb(op->on_done_send->cb_arg, 0, closure_list);
}
if (op->recv_ops) {
char status[GPR_LTOA_MIN_BUFSIZE];
@@ -153,10 +153,10 @@ static void handle_op_after_cancellation(grpc_call_element *elem,
mdb.deadline = gpr_inf_future(GPR_CLOCK_REALTIME);
grpc_sopb_add_metadata(op->recv_ops, mdb);
*op->recv_state = GRPC_STREAM_CLOSED;
- op->on_done_recv->cb(op->on_done_recv->cb_arg, 1, call_list);
+ op->on_done_recv->cb(op->on_done_recv->cb_arg, 1, closure_list);
}
if (op->on_consumed) {
- op->on_consumed->cb(op->on_consumed->cb_arg, 0, call_list);
+ op->on_consumed->cb(op->on_consumed->cb_arg, 0, closure_list);
}
}
@@ -168,13 +168,13 @@ typedef struct {
static void perform_transport_stream_op(grpc_call_element *elem,
grpc_transport_stream_op *op,
int continuation,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
static void continue_with_pick(void *arg, int iomgr_success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
waiting_call *wc = arg;
call_data *calld = wc->elem->call_data;
- perform_transport_stream_op(wc->elem, &calld->waiting_op, 1, call_list);
+ perform_transport_stream_op(wc->elem, &calld->waiting_op, 1, closure_list);
gpr_free(wc);
}
@@ -184,7 +184,7 @@ static void add_to_lb_policy_wait_queue_locked_state_config(
waiting_call *wc = gpr_malloc(sizeof(*wc));
grpc_closure_init(&wc->closure, continue_with_pick, wc);
wc->elem = elem;
- grpc_call_list_add(&chand->waiting_for_config_closures, &wc->closure, 1);
+ grpc_closure_list_add(&chand->waiting_for_config_closures, &wc->closure, 1);
}
static int is_empty(void *p, int len) {
@@ -197,7 +197,7 @@ static int is_empty(void *p, int len) {
}
static void started_call(void *arg, int iomgr_success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
call_data *calld = arg;
grpc_transport_stream_op op;
int have_waiting;
@@ -207,7 +207,7 @@ static void started_call(void *arg, int iomgr_success,
memset(&op, 0, sizeof(op));
op.cancel_with_status = GRPC_STATUS_CANCELLED;
gpr_mu_unlock(&calld->mu_state);
- grpc_subchannel_call_process_op(calld->subchannel_call, &op, call_list);
+ grpc_subchannel_call_process_op(calld->subchannel_call, &op, closure_list);
} else if (calld->state == CALL_WAITING_FOR_CALL) {
have_waiting = !is_empty(&calld->waiting_op, sizeof(calld->waiting_op));
if (calld->subchannel_call != NULL) {
@@ -215,14 +215,14 @@ static void started_call(void *arg, int iomgr_success,
gpr_mu_unlock(&calld->mu_state);
if (have_waiting) {
grpc_subchannel_call_process_op(calld->subchannel_call,
- &calld->waiting_op, call_list);
+ &calld->waiting_op, closure_list);
}
} else {
calld->state = CALL_CANCELLED;
gpr_mu_unlock(&calld->mu_state);
if (have_waiting) {
handle_op_after_cancellation(calld->elem, &calld->waiting_op,
- call_list);
+ closure_list);
}
}
} else {
@@ -232,19 +232,21 @@ static void started_call(void *arg, int iomgr_success,
}
static void picked_target(void *arg, int iomgr_success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
call_data *calld = arg;
grpc_pollset *pollset;
if (calld->picked_channel == NULL) {
/* treat this like a cancellation */
calld->waiting_op.cancel_with_status = GRPC_STATUS_UNAVAILABLE;
- perform_transport_stream_op(calld->elem, &calld->waiting_op, 1, call_list);
+ perform_transport_stream_op(calld->elem, &calld->waiting_op, 1,
+ closure_list);
} else {
gpr_mu_lock(&calld->mu_state);
if (calld->state == CALL_CANCELLED) {
gpr_mu_unlock(&calld->mu_state);
- handle_op_after_cancellation(calld->elem, &calld->waiting_op, call_list);
+ handle_op_after_cancellation(calld->elem, &calld->waiting_op,
+ closure_list);
} else {
GPR_ASSERT(calld->state == CALL_WAITING_FOR_PICK);
calld->state = CALL_WAITING_FOR_CALL;
@@ -253,7 +255,7 @@ static void picked_target(void *arg, int iomgr_success,
grpc_closure_init(&calld->async_setup_task, started_call, calld);
grpc_subchannel_create_call(calld->picked_channel, pollset,
&calld->subchannel_call,
- &calld->async_setup_task, call_list);
+ &calld->async_setup_task, closure_list);
}
}
}
@@ -287,7 +289,8 @@ static grpc_closure *merge_into_waiting_op(grpc_call_element *elem,
return consumed_op;
}
-static char *cc_get_peer(grpc_call_element *elem, grpc_call_list *call_list) {
+static char *cc_get_peer(grpc_call_element *elem,
+ grpc_closure_list *closure_list) {
call_data *calld = elem->call_data;
channel_data *chand = elem->channel_data;
grpc_subchannel_call *subchannel_call;
@@ -298,8 +301,8 @@ static char *cc_get_peer(grpc_call_element *elem, grpc_call_list *call_list) {
subchannel_call = calld->subchannel_call;
GRPC_SUBCHANNEL_CALL_REF(subchannel_call, "get_peer");
gpr_mu_unlock(&calld->mu_state);
- result = grpc_subchannel_call_get_peer(subchannel_call, call_list);
- GRPC_SUBCHANNEL_CALL_UNREF(subchannel_call, "get_peer", call_list);
+ result = grpc_subchannel_call_get_peer(subchannel_call, closure_list);
+ GRPC_SUBCHANNEL_CALL_UNREF(subchannel_call, "get_peer", closure_list);
return result;
} else {
gpr_mu_unlock(&calld->mu_state);
@@ -310,7 +313,7 @@ static char *cc_get_peer(grpc_call_element *elem, grpc_call_list *call_list) {
static void perform_transport_stream_op(grpc_call_element *elem,
grpc_transport_stream_op *op,
int continuation,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
call_data *calld = elem->call_data;
channel_data *chand = elem->channel_data;
grpc_subchannel_call *subchannel_call;
@@ -325,15 +328,15 @@ static void perform_transport_stream_op(grpc_call_element *elem,
GPR_ASSERT(!continuation);
subchannel_call = calld->subchannel_call;
gpr_mu_unlock(&calld->mu_state);
- grpc_subchannel_call_process_op(subchannel_call, op, call_list);
+ grpc_subchannel_call_process_op(subchannel_call, op, closure_list);
break;
case CALL_CANCELLED:
gpr_mu_unlock(&calld->mu_state);
- handle_op_after_cancellation(elem, op, call_list);
+ handle_op_after_cancellation(elem, op, closure_list);
break;
case CALL_WAITING_FOR_SEND:
GPR_ASSERT(!continuation);
- grpc_call_list_add(call_list, merge_into_waiting_op(elem, op), 1);
+ grpc_closure_list_add(closure_list, merge_into_waiting_op(elem, op), 1);
if (!calld->waiting_op.send_ops &&
calld->waiting_op.cancel_with_status == GRPC_STATUS_OK) {
gpr_mu_unlock(&calld->mu_state);
@@ -359,10 +362,11 @@ static void perform_transport_stream_op(grpc_call_element *elem,
op2.on_consumed = NULL;
}
gpr_mu_unlock(&calld->mu_state);
- handle_op_after_cancellation(elem, op, call_list);
- handle_op_after_cancellation(elem, &op2, call_list);
+ handle_op_after_cancellation(elem, op, closure_list);
+ handle_op_after_cancellation(elem, &op2, closure_list);
} else {
- grpc_call_list_add(call_list, merge_into_waiting_op(elem, op), 1);
+ grpc_closure_list_add(closure_list, merge_into_waiting_op(elem, op),
+ 1);
gpr_mu_unlock(&calld->mu_state);
}
break;
@@ -372,7 +376,7 @@ static void perform_transport_stream_op(grpc_call_element *elem,
if (op->cancel_with_status != GRPC_STATUS_OK) {
calld->state = CALL_CANCELLED;
gpr_mu_unlock(&calld->mu_state);
- handle_op_after_cancellation(elem, op, call_list);
+ handle_op_after_cancellation(elem, op, closure_list);
} else {
calld->waiting_op = *op;
@@ -402,9 +406,9 @@ static void perform_transport_stream_op(grpc_call_element *elem,
grpc_closure_init(&calld->async_setup_task, picked_target, calld);
grpc_lb_policy_pick(lb_policy, bind_pollset, initial_metadata,
&calld->picked_channel,
- &calld->async_setup_task, call_list);
+ &calld->async_setup_task, closure_list);
- GRPC_LB_POLICY_UNREF(lb_policy, "pick", call_list);
+ GRPC_LB_POLICY_UNREF(lb_policy, "pick", closure_list);
} else if (chand->resolver != NULL) {
calld->state = CALL_WAITING_FOR_CONFIG;
add_to_lb_policy_wait_queue_locked_state_config(elem);
@@ -413,7 +417,7 @@ static void perform_transport_stream_op(grpc_call_element *elem,
chand->started_resolving = 1;
grpc_resolver_next(chand->resolver,
&chand->incoming_configuration,
- &chand->on_config_changed, call_list);
+ &chand->on_config_changed, closure_list);
}
gpr_mu_unlock(&chand->mu_config);
gpr_mu_unlock(&calld->mu_state);
@@ -421,7 +425,7 @@ static void perform_transport_stream_op(grpc_call_element *elem,
calld->state = CALL_CANCELLED;
gpr_mu_unlock(&chand->mu_config);
gpr_mu_unlock(&calld->mu_state);
- handle_op_after_cancellation(elem, op, call_list);
+ handle_op_after_cancellation(elem, op, closure_list);
}
}
}
@@ -431,16 +435,16 @@ static void perform_transport_stream_op(grpc_call_element *elem,
static void cc_start_transport_stream_op(grpc_call_element *elem,
grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
- perform_transport_stream_op(elem, op, 0, call_list);
+ grpc_closure_list *closure_list) {
+ perform_transport_stream_op(elem, op, 0, closure_list);
}
static void watch_lb_policy(channel_data *chand, grpc_lb_policy *lb_policy,
grpc_connectivity_state current_state,
- grpc_call_list *cl);
+ grpc_closure_list *cl);
static void on_lb_policy_state_changed_locked(lb_policy_connectivity_watcher *w,
- grpc_call_list *cl) {
+ grpc_closure_list *cl) {
/* check if the notification is for a stale policy */
if (w->lb_policy != w->chand->lb_policy) return;
@@ -452,20 +456,21 @@ static void on_lb_policy_state_changed_locked(lb_policy_connectivity_watcher *w,
}
static void on_lb_policy_state_changed(void *arg, int iomgr_success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
lb_policy_connectivity_watcher *w = arg;
gpr_mu_lock(&w->chand->mu_config);
- on_lb_policy_state_changed_locked(w, call_list);
+ on_lb_policy_state_changed_locked(w, closure_list);
gpr_mu_unlock(&w->chand->mu_config);
- GRPC_CHANNEL_INTERNAL_UNREF(w->chand->master, "watch_lb_policy", call_list);
+ GRPC_CHANNEL_INTERNAL_UNREF(w->chand->master, "watch_lb_policy",
+ closure_list);
gpr_free(w);
}
static void watch_lb_policy(channel_data *chand, grpc_lb_policy *lb_policy,
grpc_connectivity_state current_state,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
lb_policy_connectivity_watcher *w = gpr_malloc(sizeof(*w));
GRPC_CHANNEL_INTERNAL_REF(chand->master, "watch_lb_policy");
@@ -474,11 +479,11 @@ static void watch_lb_policy(channel_data *chand, grpc_lb_policy *lb_policy,
w->state = current_state;
w->lb_policy = lb_policy;
grpc_lb_policy_notify_on_state_change(lb_policy, &w->state, &w->on_changed,
- call_list);
+ closure_list);
}
static void cc_on_config_changed(void *arg, int iomgr_success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
channel_data *chand = arg;
grpc_lb_policy *lb_policy = NULL;
grpc_lb_policy *old_lb_policy;
@@ -491,10 +496,10 @@ static void cc_on_config_changed(void *arg, int iomgr_success,
if (lb_policy != NULL) {
GRPC_LB_POLICY_REF(lb_policy, "channel");
GRPC_LB_POLICY_REF(lb_policy, "config_change");
- state = grpc_lb_policy_check_connectivity(lb_policy, call_list);
+ state = grpc_lb_policy_check_connectivity(lb_policy, closure_list);
}
- grpc_client_config_unref(chand->incoming_configuration, call_list);
+ grpc_client_config_unref(chand->incoming_configuration, closure_list);
}
chand->incoming_configuration = NULL;
@@ -503,7 +508,7 @@ static void cc_on_config_changed(void *arg, int iomgr_success,
old_lb_policy = chand->lb_policy;
chand->lb_policy = lb_policy;
if (lb_policy != NULL || chand->resolver == NULL /* disconnected */) {
- grpc_call_list_move(&chand->waiting_for_config_closures, call_list);
+ grpc_closure_list_move(&chand->waiting_for_config_closures, closure_list);
}
if (lb_policy != NULL && chand->exit_idle_when_lb_policy_arrives) {
GRPC_LB_POLICY_REF(lb_policy, "exit_idle");
@@ -515,53 +520,53 @@ static void cc_on_config_changed(void *arg, int iomgr_success,
grpc_resolver *resolver = chand->resolver;
GRPC_RESOLVER_REF(resolver, "channel-next");
grpc_connectivity_state_set(&chand->state_tracker, state, "new_lb+resolver",
- call_list);
+ closure_list);
if (lb_policy != NULL) {
- watch_lb_policy(chand, lb_policy, state, call_list);
+ watch_lb_policy(chand, lb_policy, state, closure_list);
}
gpr_mu_unlock(&chand->mu_config);
GRPC_CHANNEL_INTERNAL_REF(chand->master, "resolver");
grpc_resolver_next(resolver, &chand->incoming_configuration,
- &chand->on_config_changed, call_list);
- GRPC_RESOLVER_UNREF(resolver, "channel-next", call_list);
+ &chand->on_config_changed, closure_list);
+ GRPC_RESOLVER_UNREF(resolver, "channel-next", closure_list);
} else {
old_resolver = chand->resolver;
chand->resolver = NULL;
grpc_connectivity_state_set(&chand->state_tracker,
GRPC_CHANNEL_FATAL_FAILURE, "resolver_gone",
- call_list);
+ closure_list);
gpr_mu_unlock(&chand->mu_config);
if (old_resolver != NULL) {
- grpc_resolver_shutdown(old_resolver, call_list);
- GRPC_RESOLVER_UNREF(old_resolver, "channel", call_list);
+ grpc_resolver_shutdown(old_resolver, closure_list);
+ GRPC_RESOLVER_UNREF(old_resolver, "channel", closure_list);
}
}
if (exit_idle) {
- grpc_lb_policy_exit_idle(lb_policy, call_list);
- GRPC_LB_POLICY_UNREF(lb_policy, "exit_idle", call_list);
+ grpc_lb_policy_exit_idle(lb_policy, closure_list);
+ GRPC_LB_POLICY_UNREF(lb_policy, "exit_idle", closure_list);
}
if (old_lb_policy != NULL) {
- grpc_lb_policy_shutdown(old_lb_policy, call_list);
- GRPC_LB_POLICY_UNREF(old_lb_policy, "channel", call_list);
+ grpc_lb_policy_shutdown(old_lb_policy, closure_list);
+ GRPC_LB_POLICY_UNREF(old_lb_policy, "channel", closure_list);
}
if (lb_policy != NULL) {
- GRPC_LB_POLICY_UNREF(lb_policy, "config_change", call_list);
+ GRPC_LB_POLICY_UNREF(lb_policy, "config_change", closure_list);
}
- GRPC_CHANNEL_INTERNAL_UNREF(chand->master, "resolver", call_list);
+ GRPC_CHANNEL_INTERNAL_UNREF(chand->master, "resolver", closure_list);
}
static void cc_start_transport_op(grpc_channel_element *elem,
grpc_transport_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_lb_policy *lb_policy = NULL;
channel_data *chand = elem->channel_data;
grpc_resolver *destroy_resolver = NULL;
- grpc_call_list_add(call_list, op->on_consumed, 1);
+ grpc_closure_list_add(closure_list, op->on_consumed, 1);
GPR_ASSERT(op->set_accept_stream == NULL);
GPR_ASSERT(op->bind_pollset == NULL);
@@ -570,7 +575,7 @@ static void cc_start_transport_op(grpc_channel_element *elem,
if (op->on_connectivity_state_change != NULL) {
grpc_connectivity_state_notify_on_state_change(
&chand->state_tracker, op->connectivity_state,
- op->on_connectivity_state_change, call_list);
+ op->on_connectivity_state_change, closure_list);
op->on_connectivity_state_change = NULL;
op->connectivity_state = NULL;
}
@@ -585,25 +590,25 @@ static void cc_start_transport_op(grpc_channel_element *elem,
if (op->disconnect && chand->resolver != NULL) {
grpc_connectivity_state_set(&chand->state_tracker,
GRPC_CHANNEL_FATAL_FAILURE, "disconnect",
- call_list);
+ closure_list);
destroy_resolver = chand->resolver;
chand->resolver = NULL;
if (chand->lb_policy != NULL) {
- grpc_lb_policy_shutdown(chand->lb_policy, call_list);
- GRPC_LB_POLICY_UNREF(chand->lb_policy, "channel", call_list);
+ grpc_lb_policy_shutdown(chand->lb_policy, closure_list);
+ GRPC_LB_POLICY_UNREF(chand->lb_policy, "channel", closure_list);
chand->lb_policy = NULL;
}
}
gpr_mu_unlock(&chand->mu_config);
if (destroy_resolver) {
- grpc_resolver_shutdown(destroy_resolver, call_list);
- GRPC_RESOLVER_UNREF(destroy_resolver, "channel", call_list);
+ grpc_resolver_shutdown(destroy_resolver, closure_list);
+ GRPC_RESOLVER_UNREF(destroy_resolver, "channel", closure_list);
}
if (lb_policy) {
- grpc_lb_policy_broadcast(lb_policy, op, call_list);
- GRPC_LB_POLICY_UNREF(lb_policy, "broadcast", call_list);
+ grpc_lb_policy_broadcast(lb_policy, op, closure_list);
+ GRPC_LB_POLICY_UNREF(lb_policy, "broadcast", closure_list);
}
}
@@ -611,7 +616,7 @@ static void cc_start_transport_op(grpc_channel_element *elem,
static 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) {
call_data *calld = elem->call_data;
/* TODO(ctiller): is there something useful we can do here? */
@@ -627,7 +632,7 @@ static void init_call_elem(grpc_call_element *elem,
/* Destructor for call_data */
static void destroy_call_elem(grpc_call_element *elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
call_data *calld = elem->call_data;
grpc_subchannel_call *subchannel_call;
@@ -639,7 +644,8 @@ static void destroy_call_elem(grpc_call_element *elem,
case CALL_ACTIVE:
subchannel_call = calld->subchannel_call;
gpr_mu_unlock(&calld->mu_state);
- GRPC_SUBCHANNEL_CALL_UNREF(subchannel_call, "client_channel", call_list);
+ GRPC_SUBCHANNEL_CALL_UNREF(subchannel_call, "client_channel",
+ closure_list);
break;
case CALL_CREATED:
case CALL_CANCELLED:
@@ -659,7 +665,7 @@ static void destroy_call_elem(grpc_call_element *elem,
static 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) {
channel_data *chand = elem->channel_data;
memset(chand, 0, sizeof(*chand));
@@ -679,17 +685,17 @@ static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
/* Destructor for channel_data */
static void destroy_channel_elem(grpc_channel_element *elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
channel_data *chand = elem->channel_data;
if (chand->resolver != NULL) {
- grpc_resolver_shutdown(chand->resolver, call_list);
- GRPC_RESOLVER_UNREF(chand->resolver, "channel", call_list);
+ grpc_resolver_shutdown(chand->resolver, closure_list);
+ GRPC_RESOLVER_UNREF(chand->resolver, "channel", closure_list);
}
if (chand->lb_policy != NULL) {
- GRPC_LB_POLICY_UNREF(chand->lb_policy, "channel", call_list);
+ GRPC_LB_POLICY_UNREF(chand->lb_policy, "channel", closure_list);
}
- grpc_connectivity_state_destroy(&chand->state_tracker, call_list);
+ grpc_connectivity_state_destroy(&chand->state_tracker, closure_list);
grpc_pollset_set_destroy(&chand->pollset_set);
gpr_mu_destroy(&chand->mu_config);
}
@@ -709,7 +715,7 @@ const grpc_channel_filter grpc_client_channel_filter = {
void grpc_client_channel_set_resolver(grpc_channel_stack *channel_stack,
grpc_resolver *resolver,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
/* post construction initialization: set the transport setup pointer */
grpc_channel_element *elem = grpc_channel_stack_last_element(channel_stack);
channel_data *chand = elem->channel_data;
@@ -717,32 +723,33 @@ void grpc_client_channel_set_resolver(grpc_channel_stack *channel_stack,
GPR_ASSERT(!chand->resolver);
chand->resolver = resolver;
GRPC_RESOLVER_REF(resolver, "channel");
- if (!grpc_call_list_empty(chand->waiting_for_config_closures) ||
+ if (!grpc_closure_list_empty(chand->waiting_for_config_closures) ||
chand->exit_idle_when_lb_policy_arrives) {
chand->started_resolving = 1;
GRPC_CHANNEL_INTERNAL_REF(chand->master, "resolver");
grpc_resolver_next(resolver, &chand->incoming_configuration,
- &chand->on_config_changed, call_list);
+ &chand->on_config_changed, closure_list);
}
gpr_mu_unlock(&chand->mu_config);
}
grpc_connectivity_state grpc_client_channel_check_connectivity_state(
- grpc_channel_element *elem, int try_to_connect, grpc_call_list *call_list) {
+ grpc_channel_element *elem, int try_to_connect,
+ grpc_closure_list *closure_list) {
channel_data *chand = elem->channel_data;
grpc_connectivity_state out;
gpr_mu_lock(&chand->mu_config);
out = grpc_connectivity_state_check(&chand->state_tracker);
if (out == GRPC_CHANNEL_IDLE && try_to_connect) {
if (chand->lb_policy != NULL) {
- grpc_lb_policy_exit_idle(chand->lb_policy, call_list);
+ grpc_lb_policy_exit_idle(chand->lb_policy, closure_list);
} else {
chand->exit_idle_when_lb_policy_arrives = 1;
if (!chand->started_resolving && chand->resolver != NULL) {
GRPC_CHANNEL_INTERNAL_REF(chand->master, "resolver");
chand->started_resolving = 1;
grpc_resolver_next(chand->resolver, &chand->incoming_configuration,
- &chand->on_config_changed, call_list);
+ &chand->on_config_changed, closure_list);
}
}
}
@@ -752,11 +759,11 @@ grpc_connectivity_state grpc_client_channel_check_connectivity_state(
void grpc_client_channel_watch_connectivity_state(
grpc_channel_element *elem, grpc_connectivity_state *state,
- grpc_closure *on_complete, grpc_call_list *call_list) {
+ grpc_closure *on_complete, grpc_closure_list *closure_list) {
channel_data *chand = elem->channel_data;
gpr_mu_lock(&chand->mu_config);
grpc_connectivity_state_notify_on_state_change(&chand->state_tracker, state,
- on_complete, call_list);
+ on_complete, closure_list);
gpr_mu_unlock(&chand->mu_config);
}
@@ -768,14 +775,14 @@ grpc_pollset_set *grpc_client_channel_get_connecting_pollset_set(
void grpc_client_channel_add_interested_party(grpc_channel_element *elem,
grpc_pollset *pollset,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
channel_data *chand = elem->channel_data;
- grpc_pollset_set_add_pollset(&chand->pollset_set, pollset, call_list);
+ grpc_pollset_set_add_pollset(&chand->pollset_set, pollset, closure_list);
}
void grpc_client_channel_del_interested_party(grpc_channel_element *elem,
grpc_pollset *pollset,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
channel_data *chand = elem->channel_data;
- grpc_pollset_set_del_pollset(&chand->pollset_set, pollset, call_list);
+ grpc_pollset_set_del_pollset(&chand->pollset_set, pollset, closure_list);
}
diff --git a/src/core/channel/client_channel.h b/src/core/channel/client_channel.h
index 7afc7f8544baa9d1170c2f61008fce86c2854583..d200f6e4b04456e2c938d8ecbe2a6fd038693de5 100644
--- a/src/core/channel/client_channel.h
+++ b/src/core/channel/client_channel.h
@@ -51,23 +51,24 @@ extern const grpc_channel_filter grpc_client_channel_filter;
a connection */
void grpc_client_channel_set_resolver(grpc_channel_stack *channel_stack,
grpc_resolver *resolver,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
grpc_connectivity_state grpc_client_channel_check_connectivity_state(
- grpc_channel_element *elem, int try_to_connect, grpc_call_list *call_list);
+ grpc_channel_element *elem, int try_to_connect,
+ grpc_closure_list *closure_list);
void grpc_client_channel_watch_connectivity_state(
grpc_channel_element *elem, grpc_connectivity_state *state,
- grpc_closure *on_complete, grpc_call_list *call_list);
+ grpc_closure *on_complete, grpc_closure_list *closure_list);
grpc_pollset_set *grpc_client_channel_get_connecting_pollset_set(
grpc_channel_element *elem);
void grpc_client_channel_add_interested_party(grpc_channel_element *channel,
grpc_pollset *pollset,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void grpc_client_channel_del_interested_party(grpc_channel_element *channel,
grpc_pollset *pollset,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_CHANNEL_CLIENT_CHANNEL_H */
diff --git a/src/core/channel/compress_filter.c b/src/core/channel/compress_filter.c
index e2be603e26664af7c8525f01dd472004f8fd7994..911c689d54d5a2e17c6a0444a688d367d20e9a46 100644
--- a/src/core/channel/compress_filter.c
+++ b/src/core/channel/compress_filter.c
@@ -268,22 +268,22 @@ static void process_send_ops(grpc_call_element *elem,
- a network event (or similar) from below, to receive something
op contains type and call direction information, in addition to the data
that is being sent or received. */
-static void compress_start_transport_stream_op(grpc_call_element *elem,
- grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+static void compress_start_transport_stream_op(
+ grpc_call_element *elem, grpc_transport_stream_op *op,
+ grpc_closure_list *closure_list) {
if (op->send_ops && op->send_ops->nops > 0) {
process_send_ops(elem, op->send_ops);
}
/* pass control down the stack */
- grpc_call_next_op(elem, op, call_list);
+ grpc_call_next_op(elem, op, closure_list);
}
/* Constructor for call_data */
static 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) {
/* grab pointers to our data from the call element */
call_data *calld = elem->call_data;
@@ -301,7 +301,7 @@ static void init_call_elem(grpc_call_element *elem,
/* Destructor for call_data */
static void destroy_call_elem(grpc_call_element *elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
/* grab pointers to our data from the call element */
call_data *calld = elem->call_data;
gpr_slice_buffer_destroy(&calld->slices);
@@ -311,7 +311,7 @@ static void destroy_call_elem(grpc_call_element *elem,
static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
const grpc_channel_args *args, grpc_mdctx *mdctx,
int is_first, int is_last,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
channel_data *channeld = elem->channel_data;
grpc_compression_algorithm algo_idx;
const char *supported_algorithms_names[GRPC_COMPRESS_ALGORITHMS_COUNT - 1];
@@ -374,7 +374,7 @@ static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
/* Destructor for channel data */
static void destroy_channel_elem(grpc_channel_element *elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
channel_data *channeld = elem->channel_data;
grpc_compression_algorithm algo_idx;
diff --git a/src/core/channel/connected_channel.c b/src/core/channel/connected_channel.c
index 1af5eae9478f57f1e8551e5aa25250f6c5ad148b..b58e180a43d0303dc5a2f652f1b478bd739c7ec3 100644
--- a/src/core/channel/connected_channel.c
+++ b/src/core/channel/connected_channel.c
@@ -63,54 +63,55 @@ typedef struct connected_channel_call_data { void *unused; } call_data;
into transport stream operations */
static void con_start_transport_stream_op(grpc_call_element *elem,
grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
call_data *calld = elem->call_data;
channel_data *chand = elem->channel_data;
GPR_ASSERT(elem->filter == &grpc_connected_channel_filter);
GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
- grpc_transport_perform_stream_op(
- chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA(calld), op, call_list);
+ grpc_transport_perform_stream_op(chand->transport,
+ TRANSPORT_STREAM_FROM_CALL_DATA(calld), op,
+ closure_list);
}
static void con_start_transport_op(grpc_channel_element *elem,
grpc_transport_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
channel_data *chand = elem->channel_data;
- grpc_transport_perform_op(chand->transport, op, call_list);
+ grpc_transport_perform_op(chand->transport, op, closure_list);
}
/* Constructor for call_data */
static 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) {
call_data *calld = elem->call_data;
channel_data *chand = elem->channel_data;
int r;
GPR_ASSERT(elem->filter == &grpc_connected_channel_filter);
- r = grpc_transport_init_stream(chand->transport,
- TRANSPORT_STREAM_FROM_CALL_DATA(calld),
- server_transport_data, initial_op, call_list);
+ r = grpc_transport_init_stream(
+ chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA(calld),
+ server_transport_data, initial_op, closure_list);
GPR_ASSERT(r == 0);
}
/* Destructor for call_data */
static void destroy_call_elem(grpc_call_element *elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
call_data *calld = elem->call_data;
channel_data *chand = elem->channel_data;
GPR_ASSERT(elem->filter == &grpc_connected_channel_filter);
grpc_transport_destroy_stream(
- chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA(calld), call_list);
+ chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA(calld), closure_list);
}
/* Constructor for channel_data */
static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
const grpc_channel_args *args, grpc_mdctx *mdctx,
int is_first, int is_last,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
channel_data *cd = (channel_data *)elem->channel_data;
GPR_ASSERT(is_last);
GPR_ASSERT(elem->filter == &grpc_connected_channel_filter);
@@ -119,15 +120,16 @@ static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
/* Destructor for channel_data */
static void destroy_channel_elem(grpc_channel_element *elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
channel_data *cd = (channel_data *)elem->channel_data;
GPR_ASSERT(elem->filter == &grpc_connected_channel_filter);
- grpc_transport_destroy(cd->transport, call_list);
+ grpc_transport_destroy(cd->transport, closure_list);
}
-static char *con_get_peer(grpc_call_element *elem, grpc_call_list *call_list) {
+static char *con_get_peer(grpc_call_element *elem,
+ grpc_closure_list *closure_list) {
channel_data *chand = elem->channel_data;
- return grpc_transport_get_peer(chand->transport, call_list);
+ return grpc_transport_get_peer(chand->transport, closure_list);
}
const grpc_channel_filter grpc_connected_channel_filter = {
diff --git a/src/core/channel/http_client_filter.c b/src/core/channel/http_client_filter.c
index 0aa708694df2dfc312dc88bc22b6aa16e0d8a2e1..6fbe4738e75afdedfb317bd7255af28080b696e2 100644
--- a/src/core/channel/http_client_filter.c
+++ b/src/core/channel/http_client_filter.c
@@ -69,7 +69,7 @@ typedef struct channel_data {
typedef struct {
grpc_call_element *elem;
- grpc_call_list *call_list;
+ grpc_closure_list *closure_list;
} client_recv_filter_args;
static grpc_mdelem *client_recv_filter(void *user_data, grpc_mdelem *md) {
@@ -79,7 +79,7 @@ static grpc_mdelem *client_recv_filter(void *user_data, grpc_mdelem *md) {
if (md == channeld->status) {
return NULL;
} else if (md->key == channeld->status->key) {
- grpc_call_element_send_cancel(elem, a->call_list);
+ grpc_call_element_send_cancel(elem, a->closure_list);
return NULL;
} else if (md->key == channeld->content_type->key) {
return NULL;
@@ -88,7 +88,7 @@ static grpc_mdelem *client_recv_filter(void *user_data, grpc_mdelem *md) {
}
static void hc_on_recv(void *user_data, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_call_element *elem = user_data;
call_data *calld = elem->call_data;
size_t i;
@@ -100,10 +100,10 @@ static void hc_on_recv(void *user_data, int success,
if (op->type != GRPC_OP_METADATA) continue;
calld->got_initial_metadata = 1;
a.elem = elem;
- a.call_list = call_list;
+ a.closure_list = closure_list;
grpc_metadata_batch_filter(&op->data.metadata, client_recv_filter, &a);
}
- calld->on_done_recv->cb(calld->on_done_recv->cb_arg, success, call_list);
+ calld->on_done_recv->cb(calld->on_done_recv->cb_arg, success, closure_list);
}
static grpc_mdelem *client_strip_filter(void *user_data, grpc_mdelem *md) {
@@ -158,17 +158,17 @@ static void hc_mutate_op(grpc_call_element *elem,
static void hc_start_transport_op(grpc_call_element *elem,
grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
hc_mutate_op(elem, op);
- grpc_call_next_op(elem, op, call_list);
+ grpc_call_next_op(elem, op, closure_list);
}
/* Constructor for call_data */
static 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) {
call_data *calld = elem->call_data;
calld->sent_initial_metadata = 0;
calld->got_initial_metadata = 0;
@@ -179,7 +179,7 @@ static void init_call_elem(grpc_call_element *elem,
/* Destructor for call_data */
static void destroy_call_elem(grpc_call_element *elem,
- grpc_call_list *call_list) {}
+ grpc_closure_list *closure_list) {}
static const char *scheme_from_args(const grpc_channel_args *args) {
unsigned i;
@@ -247,7 +247,7 @@ static grpc_mdstr *user_agent_from_args(grpc_mdctx *mdctx,
static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
const grpc_channel_args *channel_args,
grpc_mdctx *mdctx, int is_first, int is_last,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
/* grab pointers to our data from the channel element */
channel_data *channeld = elem->channel_data;
@@ -271,7 +271,7 @@ static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
/* Destructor for channel data */
static void destroy_channel_elem(grpc_channel_element *elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
/* grab pointers to our data from the channel element */
channel_data *channeld = elem->channel_data;
diff --git a/src/core/channel/http_server_filter.c b/src/core/channel/http_server_filter.c
index 448ce9a5b1a8527415bde01d61c6e7547f48a2f3..fb1f0b055441038eecb199906adccebe1bb29dfc 100644
--- a/src/core/channel/http_server_filter.c
+++ b/src/core/channel/http_server_filter.c
@@ -76,7 +76,7 @@ typedef struct channel_data {
typedef struct {
grpc_call_element *elem;
- grpc_call_list *call_list;
+ grpc_closure_list *closure_list;
} server_filter_args;
static grpc_mdelem *server_filter(void *user_data, grpc_mdelem *md) {
@@ -123,7 +123,7 @@ static grpc_mdelem *server_filter(void *user_data, grpc_mdelem *md) {
/* swallow it and error everything out. */
/* TODO(klempner): We ought to generate more descriptive error messages
on the wire here. */
- grpc_call_element_send_cancel(elem, a->call_list);
+ grpc_call_element_send_cancel(elem, a->closure_list);
return NULL;
} else if (md->key == channeld->path_key) {
if (calld->seen_path) {
@@ -150,7 +150,7 @@ static grpc_mdelem *server_filter(void *user_data, grpc_mdelem *md) {
}
static void hs_on_recv(void *user_data, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_call_element *elem = user_data;
call_data *calld = elem->call_data;
if (success) {
@@ -163,7 +163,7 @@ static void hs_on_recv(void *user_data, int success,
if (op->type != GRPC_OP_METADATA) continue;
calld->got_initial_metadata = 1;
a.elem = elem;
- a.call_list = call_list;
+ a.closure_list = closure_list;
grpc_metadata_batch_filter(&op->data.metadata, server_filter, &a);
/* Have we seen the required http2 transport headers?
(:method, :scheme, content-type, with :path and :authority covered
@@ -189,11 +189,11 @@ static void hs_on_recv(void *user_data, int success,
}
/* Error this call out */
success = 0;
- grpc_call_element_send_cancel(elem, call_list);
+ grpc_call_element_send_cancel(elem, closure_list);
}
}
}
- calld->on_done_recv->cb(calld->on_done_recv->cb_arg, success, call_list);
+ calld->on_done_recv->cb(calld->on_done_recv->cb_arg, success, closure_list);
}
static void hs_mutate_op(grpc_call_element *elem,
@@ -228,17 +228,17 @@ static void hs_mutate_op(grpc_call_element *elem,
static void hs_start_transport_op(grpc_call_element *elem,
grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
hs_mutate_op(elem, op);
- grpc_call_next_op(elem, op, call_list);
+ grpc_call_next_op(elem, op, closure_list);
}
/* Constructor for call_data */
static 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) {
/* grab pointers to our data from the call element */
call_data *calld = elem->call_data;
/* initialize members */
@@ -249,13 +249,13 @@ static void init_call_elem(grpc_call_element *elem,
/* Destructor for call_data */
static void destroy_call_elem(grpc_call_element *elem,
- grpc_call_list *call_list) {}
+ grpc_closure_list *closure_list) {}
/* Constructor for channel_data */
static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
const grpc_channel_args *args, grpc_mdctx *mdctx,
int is_first, int is_last,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
/* grab pointers to our data from the channel element */
channel_data *channeld = elem->channel_data;
@@ -285,7 +285,7 @@ static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
/* Destructor for channel data */
static void destroy_channel_elem(grpc_channel_element *elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
/* grab pointers to our data from the channel element */
channel_data *channeld = elem->channel_data;
diff --git a/src/core/channel/noop_filter.c b/src/core/channel/noop_filter.c
index de75f83654170813315fdf4025b0214eea947048..e4f6c7f837529f4a32b63e31a7993503d1ff7eca 100644
--- a/src/core/channel/noop_filter.c
+++ b/src/core/channel/noop_filter.c
@@ -64,18 +64,18 @@ static void noop_mutate_op(grpc_call_element *elem,
that is being sent or received. */
static void noop_start_transport_stream_op(grpc_call_element *elem,
grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
noop_mutate_op(elem, op);
/* pass control down the stack */
- grpc_call_next_op(elem, op, call_list);
+ grpc_call_next_op(elem, op, closure_list);
}
/* Constructor for call_data */
static 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) {
/* grab pointers to our data from the call element */
call_data *calld = elem->call_data;
channel_data *channeld = elem->channel_data;
@@ -88,13 +88,13 @@ static void init_call_elem(grpc_call_element *elem,
/* Destructor for call_data */
static void destroy_call_elem(grpc_call_element *elem,
- grpc_call_list *call_list) {}
+ grpc_closure_list *closure_list) {}
/* Constructor for channel_data */
static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
const grpc_channel_args *args, grpc_mdctx *mdctx,
int is_first, int is_last,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
/* grab pointers to our data from the channel element */
channel_data *channeld = elem->channel_data;
@@ -110,7 +110,7 @@ static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
/* Destructor for channel data */
static void destroy_channel_elem(grpc_channel_element *elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
/* grab pointers to our data from the channel element */
channel_data *channeld = elem->channel_data;
diff --git a/src/core/client_config/client_config.c b/src/core/client_config/client_config.c
index 07808804730ea7706a1866c4935c783fb06633cb..636ab6d1da3980d6b67400aab27e2099e8643ed7 100644
--- a/src/core/client_config/client_config.c
+++ b/src/core/client_config/client_config.c
@@ -52,9 +52,9 @@ grpc_client_config *grpc_client_config_create() {
void grpc_client_config_ref(grpc_client_config *c) { gpr_ref(&c->refs); }
void grpc_client_config_unref(grpc_client_config *c,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
if (gpr_unref(&c->refs)) {
- GRPC_LB_POLICY_UNREF(c->lb_policy, "client_config", call_list);
+ GRPC_LB_POLICY_UNREF(c->lb_policy, "client_config", closure_list);
gpr_free(c);
}
}
diff --git a/src/core/client_config/client_config.h b/src/core/client_config/client_config.h
index 76a5c6659451e0943c21e1dc6c28c8a1e1028174..8281dbe662f36cdda03c8cc58f7ee56f76e685b1 100644
--- a/src/core/client_config/client_config.h
+++ b/src/core/client_config/client_config.h
@@ -43,7 +43,7 @@ typedef struct grpc_client_config grpc_client_config;
grpc_client_config *grpc_client_config_create();
void grpc_client_config_ref(grpc_client_config *client_config);
void grpc_client_config_unref(grpc_client_config *client_config,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void grpc_client_config_set_lb_policy(grpc_client_config *client_config,
grpc_lb_policy *lb_policy);
diff --git a/src/core/client_config/connector.c b/src/core/client_config/connector.c
index a0f346faeba19b9faf2044abd918a1018d05b9cb..39581b00fc9fba2ae93d5aa4d8d2b25d80f47cf2 100644
--- a/src/core/client_config/connector.c
+++ b/src/core/client_config/connector.c
@@ -38,18 +38,20 @@ void grpc_connector_ref(grpc_connector *connector) {
}
void grpc_connector_unref(grpc_connector *connector,
- grpc_call_list *call_list) {
- connector->vtable->unref(connector, call_list);
+ grpc_closure_list *closure_list) {
+ connector->vtable->unref(connector, closure_list);
}
void grpc_connector_connect(grpc_connector *connector,
const grpc_connect_in_args *in_args,
grpc_connect_out_args *out_args,
- grpc_closure *notify, grpc_call_list *call_list) {
- connector->vtable->connect(connector, in_args, out_args, notify, call_list);
+ grpc_closure *notify,
+ grpc_closure_list *closure_list) {
+ connector->vtable->connect(connector, in_args, out_args, notify,
+ closure_list);
}
void grpc_connector_shutdown(grpc_connector *connector,
- grpc_call_list *call_list) {
- connector->vtable->shutdown(connector, call_list);
+ grpc_closure_list *closure_list) {
+ connector->vtable->shutdown(connector, closure_list);
}
diff --git a/src/core/client_config/connector.h b/src/core/client_config/connector.h
index 388f656c444c03fa2acb3f2343cbd25486324ce2..fd46392dd871dcfb40c4079ebc33b5167012745b 100644
--- a/src/core/client_config/connector.h
+++ b/src/core/client_config/connector.h
@@ -67,25 +67,27 @@ typedef struct {
struct grpc_connector_vtable {
void (*ref)(grpc_connector *connector);
- void (*unref)(grpc_connector *connector, grpc_call_list *call_list);
+ void (*unref)(grpc_connector *connector, grpc_closure_list *closure_list);
/** Implementation of grpc_connector_shutdown */
- void (*shutdown)(grpc_connector *connector, grpc_call_list *call_list);
+ void (*shutdown)(grpc_connector *connector, grpc_closure_list *closure_list);
/** Implementation of grpc_connector_connect */
void (*connect)(grpc_connector *connector,
const grpc_connect_in_args *in_args,
grpc_connect_out_args *out_args, grpc_closure *notify,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
};
void grpc_connector_ref(grpc_connector *connector);
-void grpc_connector_unref(grpc_connector *connector, grpc_call_list *call_list);
+void grpc_connector_unref(grpc_connector *connector,
+ grpc_closure_list *closure_list);
/** Connect using the connector: max one outstanding call at a time */
void grpc_connector_connect(grpc_connector *connector,
const grpc_connect_in_args *in_args,
grpc_connect_out_args *out_args,
- grpc_closure *notify, grpc_call_list *call_list);
+ grpc_closure *notify,
+ grpc_closure_list *closure_list);
/** Cancel any pending connection */
void grpc_connector_shutdown(grpc_connector *connector,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
#endif
diff --git a/src/core/client_config/lb_policies/pick_first.c b/src/core/client_config/lb_policies/pick_first.c
index eebc7191ba2e2b0a26fdd7fb7820c5a42df45f0e..39e9e6c0d747188cd4d18ad76e48862246e2bc3e 100644
--- a/src/core/client_config/lb_policies/pick_first.c
+++ b/src/core/client_config/lb_policies/pick_first.c
@@ -77,91 +77,92 @@ typedef struct {
} pick_first_lb_policy;
static void del_interested_parties_locked(pick_first_lb_policy *p,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
pending_pick *pp;
for (pp = p->pending_picks; pp; pp = pp->next) {
grpc_subchannel_del_interested_party(p->subchannels[p->checking_subchannel],
- pp->pollset, call_list);
+ pp->pollset, closure_list);
}
}
static void add_interested_parties_locked(pick_first_lb_policy *p,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
pending_pick *pp;
for (pp = p->pending_picks; pp; pp = pp->next) {
grpc_subchannel_add_interested_party(p->subchannels[p->checking_subchannel],
- pp->pollset, call_list);
+ pp->pollset, closure_list);
}
}
-void pf_destroy(grpc_lb_policy *pol, grpc_call_list *call_list) {
+void pf_destroy(grpc_lb_policy *pol, grpc_closure_list *closure_list) {
pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
size_t i;
GPR_ASSERT(p->pending_picks == NULL);
for (i = 0; i < p->num_subchannels; i++) {
- GRPC_SUBCHANNEL_UNREF(p->subchannels[i], "pick_first", call_list);
+ GRPC_SUBCHANNEL_UNREF(p->subchannels[i], "pick_first", closure_list);
}
- grpc_connectivity_state_destroy(&p->state_tracker, call_list);
+ grpc_connectivity_state_destroy(&p->state_tracker, closure_list);
gpr_free(p->subchannels);
gpr_mu_destroy(&p->mu);
gpr_free(p);
}
-void pf_shutdown(grpc_lb_policy *pol, grpc_call_list *call_list) {
+void pf_shutdown(grpc_lb_policy *pol, grpc_closure_list *closure_list) {
pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
pending_pick *pp;
gpr_mu_lock(&p->mu);
- del_interested_parties_locked(p, call_list);
+ del_interested_parties_locked(p, closure_list);
p->shutdown = 1;
pp = p->pending_picks;
p->pending_picks = NULL;
grpc_connectivity_state_set(&p->state_tracker, GRPC_CHANNEL_FATAL_FAILURE,
- "shutdown", call_list);
+ "shutdown", closure_list);
gpr_mu_unlock(&p->mu);
while (pp != NULL) {
pending_pick *next = pp->next;
*pp->target = NULL;
- grpc_call_list_add(call_list, pp->on_complete, 1);
+ grpc_closure_list_add(closure_list, pp->on_complete, 1);
gpr_free(pp);
pp = next;
}
}
-static void start_picking(pick_first_lb_policy *p, grpc_call_list *call_list) {
+static void start_picking(pick_first_lb_policy *p,
+ grpc_closure_list *closure_list) {
p->started_picking = 1;
p->checking_subchannel = 0;
p->checking_connectivity = GRPC_CHANNEL_IDLE;
GRPC_LB_POLICY_REF(&p->base, "pick_first_connectivity");
- grpc_subchannel_notify_on_state_change(p->subchannels[p->checking_subchannel],
- &p->checking_connectivity,
- &p->connectivity_changed, call_list);
+ grpc_subchannel_notify_on_state_change(
+ p->subchannels[p->checking_subchannel], &p->checking_connectivity,
+ &p->connectivity_changed, closure_list);
}
-void pf_exit_idle(grpc_lb_policy *pol, grpc_call_list *call_list) {
+void pf_exit_idle(grpc_lb_policy *pol, grpc_closure_list *closure_list) {
pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
gpr_mu_lock(&p->mu);
if (!p->started_picking) {
- start_picking(p, call_list);
+ start_picking(p, closure_list);
}
gpr_mu_unlock(&p->mu);
}
void pf_pick(grpc_lb_policy *pol, grpc_pollset *pollset,
grpc_metadata_batch *initial_metadata, grpc_subchannel **target,
- grpc_closure *on_complete, grpc_call_list *call_list) {
+ grpc_closure *on_complete, grpc_closure_list *closure_list) {
pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
pending_pick *pp;
gpr_mu_lock(&p->mu);
if (p->selected) {
gpr_mu_unlock(&p->mu);
*target = p->selected;
- grpc_call_list_add(call_list, on_complete, 1);
+ grpc_closure_list_add(closure_list, on_complete, 1);
} else {
if (!p->started_picking) {
- start_picking(p, call_list);
+ start_picking(p, closure_list);
}
grpc_subchannel_add_interested_party(p->subchannels[p->checking_subchannel],
- pollset, call_list);
+ pollset, closure_list);
pp = gpr_malloc(sizeof(*pp));
pp->next = p->pending_picks;
pp->pollset = pollset;
@@ -173,7 +174,7 @@ void pf_pick(grpc_lb_policy *pol, grpc_pollset *pollset,
}
static void pf_connectivity_changed(void *arg, int iomgr_success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
pick_first_lb_policy *p = arg;
pending_pick *pp;
@@ -181,51 +182,51 @@ static void pf_connectivity_changed(void *arg, int iomgr_success,
if (p->shutdown) {
gpr_mu_unlock(&p->mu);
- GRPC_LB_POLICY_UNREF(&p->base, "pick_first_connectivity", call_list);
+ GRPC_LB_POLICY_UNREF(&p->base, "pick_first_connectivity", closure_list);
return;
} else if (p->selected != NULL) {
grpc_connectivity_state_set(&p->state_tracker, p->checking_connectivity,
- "selected_changed", call_list);
+ "selected_changed", closure_list);
if (p->checking_connectivity != GRPC_CHANNEL_FATAL_FAILURE) {
grpc_subchannel_notify_on_state_change(
p->selected, &p->checking_connectivity, &p->connectivity_changed,
- call_list);
+ closure_list);
} else {
- GRPC_LB_POLICY_UNREF(&p->base, "pick_first_connectivity", call_list);
+ GRPC_LB_POLICY_UNREF(&p->base, "pick_first_connectivity", closure_list);
}
} else {
loop:
switch (p->checking_connectivity) {
case GRPC_CHANNEL_READY:
grpc_connectivity_state_set(&p->state_tracker, GRPC_CHANNEL_READY,
- "connecting_ready", call_list);
+ "connecting_ready", closure_list);
p->selected = p->subchannels[p->checking_subchannel];
while ((pp = p->pending_picks)) {
p->pending_picks = pp->next;
*pp->target = p->selected;
grpc_subchannel_del_interested_party(p->selected, pp->pollset,
- call_list);
- grpc_call_list_add(call_list, pp->on_complete, 1);
+ closure_list);
+ grpc_closure_list_add(closure_list, pp->on_complete, 1);
gpr_free(pp);
}
grpc_subchannel_notify_on_state_change(
p->selected, &p->checking_connectivity, &p->connectivity_changed,
- call_list);
+ closure_list);
break;
case GRPC_CHANNEL_TRANSIENT_FAILURE:
- grpc_connectivity_state_set(&p->state_tracker,
- GRPC_CHANNEL_TRANSIENT_FAILURE,
- "connecting_transient_failure", call_list);
- del_interested_parties_locked(p, call_list);
+ grpc_connectivity_state_set(
+ &p->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE,
+ "connecting_transient_failure", closure_list);
+ del_interested_parties_locked(p, closure_list);
p->checking_subchannel =
(p->checking_subchannel + 1) % p->num_subchannels;
p->checking_connectivity = grpc_subchannel_check_connectivity(
p->subchannels[p->checking_subchannel]);
- add_interested_parties_locked(p, call_list);
+ add_interested_parties_locked(p, closure_list);
if (p->checking_connectivity == GRPC_CHANNEL_TRANSIENT_FAILURE) {
grpc_subchannel_notify_on_state_change(
p->subchannels[p->checking_subchannel], &p->checking_connectivity,
- &p->connectivity_changed, call_list);
+ &p->connectivity_changed, closure_list);
} else {
goto loop;
}
@@ -233,37 +234,38 @@ static void pf_connectivity_changed(void *arg, int iomgr_success,
case GRPC_CHANNEL_CONNECTING:
case GRPC_CHANNEL_IDLE:
grpc_connectivity_state_set(&p->state_tracker, GRPC_CHANNEL_CONNECTING,
- "connecting_changed", call_list);
+ "connecting_changed", closure_list);
grpc_subchannel_notify_on_state_change(
p->subchannels[p->checking_subchannel], &p->checking_connectivity,
- &p->connectivity_changed, call_list);
+ &p->connectivity_changed, closure_list);
break;
case GRPC_CHANNEL_FATAL_FAILURE:
- del_interested_parties_locked(p, call_list);
+ del_interested_parties_locked(p, closure_list);
GPR_SWAP(grpc_subchannel *, p->subchannels[p->checking_subchannel],
p->subchannels[p->num_subchannels - 1]);
p->num_subchannels--;
GRPC_SUBCHANNEL_UNREF(p->subchannels[p->num_subchannels], "pick_first",
- call_list);
+ closure_list);
if (p->num_subchannels == 0) {
grpc_connectivity_state_set(&p->state_tracker,
GRPC_CHANNEL_FATAL_FAILURE,
- "no_more_channels", call_list);
+ "no_more_channels", closure_list);
while ((pp = p->pending_picks)) {
p->pending_picks = pp->next;
*pp->target = NULL;
- grpc_call_list_add(call_list, pp->on_complete, 1);
+ grpc_closure_list_add(closure_list, pp->on_complete, 1);
gpr_free(pp);
}
- GRPC_LB_POLICY_UNREF(&p->base, "pick_first_connectivity", call_list);
+ GRPC_LB_POLICY_UNREF(&p->base, "pick_first_connectivity",
+ closure_list);
} else {
grpc_connectivity_state_set(&p->state_tracker,
GRPC_CHANNEL_TRANSIENT_FAILURE,
- "subchannel_failed", call_list);
+ "subchannel_failed", closure_list);
p->checking_subchannel %= p->num_subchannels;
p->checking_connectivity = grpc_subchannel_check_connectivity(
p->subchannels[p->checking_subchannel]);
- add_interested_parties_locked(p, call_list);
+ add_interested_parties_locked(p, closure_list);
goto loop;
}
}
@@ -273,7 +275,7 @@ static void pf_connectivity_changed(void *arg, int iomgr_success,
}
static void pf_broadcast(grpc_lb_policy *pol, grpc_transport_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
size_t i;
size_t n;
@@ -289,14 +291,14 @@ static void pf_broadcast(grpc_lb_policy *pol, grpc_transport_op *op,
gpr_mu_unlock(&p->mu);
for (i = 0; i < n; i++) {
- grpc_subchannel_process_transport_op(subchannels[i], op, call_list);
- GRPC_SUBCHANNEL_UNREF(subchannels[i], "pf_broadcast", call_list);
+ grpc_subchannel_process_transport_op(subchannels[i], op, closure_list);
+ GRPC_SUBCHANNEL_UNREF(subchannels[i], "pf_broadcast", closure_list);
}
gpr_free(subchannels);
}
static grpc_connectivity_state pf_check_connectivity(
- grpc_lb_policy *pol, grpc_call_list *call_list) {
+ grpc_lb_policy *pol, grpc_closure_list *closure_list) {
pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
grpc_connectivity_state st;
gpr_mu_lock(&p->mu);
@@ -308,11 +310,11 @@ static grpc_connectivity_state pf_check_connectivity(
void pf_notify_on_state_change(grpc_lb_policy *pol,
grpc_connectivity_state *current,
grpc_closure *notify,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
gpr_mu_lock(&p->mu);
grpc_connectivity_state_notify_on_state_change(&p->state_tracker, current,
- notify, call_list);
+ notify, closure_list);
gpr_mu_unlock(&p->mu);
}
diff --git a/src/core/client_config/lb_policies/round_robin.c b/src/core/client_config/lb_policies/round_robin.c
index a346007aca226a4d658fac657d6c3fbcab5a2a58..b4139719f40dedf53ff22606c27714a2d5ee9354 100644
--- a/src/core/client_config/lb_policies/round_robin.c
+++ b/src/core/client_config/lb_policies/round_robin.c
@@ -202,28 +202,28 @@ static void remove_disconnected_sc_locked(round_robin_lb_policy *p,
static void del_interested_parties_locked(round_robin_lb_policy *p,
const size_t subchannel_idx,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
pending_pick *pp;
for (pp = p->pending_picks; pp; pp = pp->next) {
grpc_subchannel_del_interested_party(p->subchannels[subchannel_idx],
- pp->pollset, call_list);
+ pp->pollset, closure_list);
}
}
-void rr_destroy(grpc_lb_policy *pol, grpc_call_list *call_list) {
+void rr_destroy(grpc_lb_policy *pol, grpc_closure_list *closure_list) {
round_robin_lb_policy *p = (round_robin_lb_policy *)pol;
size_t i;
ready_list *elem;
for (i = 0; i < p->num_subchannels; i++) {
- del_interested_parties_locked(p, i, call_list);
+ del_interested_parties_locked(p, i, closure_list);
}
for (i = 0; i < p->num_subchannels; i++) {
- GRPC_SUBCHANNEL_UNREF(p->subchannels[i], "round_robin", call_list);
+ GRPC_SUBCHANNEL_UNREF(p->subchannels[i], "round_robin", closure_list);
}
gpr_free(p->connectivity_changed_cbs);
gpr_free(p->subchannel_connectivity);
- grpc_connectivity_state_destroy(&p->state_tracker, call_list);
+ grpc_connectivity_state_destroy(&p->state_tracker, closure_list);
gpr_free(p->subchannels);
gpr_mu_destroy(&p->mu);
@@ -242,29 +242,30 @@ void rr_destroy(grpc_lb_policy *pol, grpc_call_list *call_list) {
gpr_free(p);
}
-void rr_shutdown(grpc_lb_policy *pol, grpc_call_list *call_list) {
+void rr_shutdown(grpc_lb_policy *pol, grpc_closure_list *closure_list) {
size_t i;
round_robin_lb_policy *p = (round_robin_lb_policy *)pol;
pending_pick *pp;
gpr_mu_lock(&p->mu);
for (i = 0; i < p->num_subchannels; i++) {
- del_interested_parties_locked(p, i, call_list);
+ del_interested_parties_locked(p, i, closure_list);
}
p->shutdown = 1;
while ((pp = p->pending_picks)) {
p->pending_picks = pp->next;
*pp->target = NULL;
- grpc_call_list_add(call_list, pp->on_complete, 0);
+ grpc_closure_list_add(closure_list, pp->on_complete, 0);
gpr_free(pp);
}
grpc_connectivity_state_set(&p->state_tracker, GRPC_CHANNEL_FATAL_FAILURE,
- "shutdown", call_list);
+ "shutdown", closure_list);
gpr_mu_unlock(&p->mu);
}
-static void start_picking(round_robin_lb_policy *p, grpc_call_list *call_list) {
+static void start_picking(round_robin_lb_policy *p,
+ grpc_closure_list *closure_list) {
size_t i;
p->started_picking = 1;
@@ -272,23 +273,23 @@ static void start_picking(round_robin_lb_policy *p, grpc_call_list *call_list) {
p->subchannel_connectivity[i] = GRPC_CHANNEL_IDLE;
grpc_subchannel_notify_on_state_change(
p->subchannels[i], &p->subchannel_connectivity[i],
- &p->connectivity_changed_cbs[i], call_list);
+ &p->connectivity_changed_cbs[i], closure_list);
GRPC_LB_POLICY_REF(&p->base, "round_robin_connectivity");
}
}
-void rr_exit_idle(grpc_lb_policy *pol, grpc_call_list *call_list) {
+void rr_exit_idle(grpc_lb_policy *pol, grpc_closure_list *closure_list) {
round_robin_lb_policy *p = (round_robin_lb_policy *)pol;
gpr_mu_lock(&p->mu);
if (!p->started_picking) {
- start_picking(p, call_list);
+ start_picking(p, closure_list);
}
gpr_mu_unlock(&p->mu);
}
void rr_pick(grpc_lb_policy *pol, grpc_pollset *pollset,
grpc_metadata_batch *initial_metadata, grpc_subchannel **target,
- grpc_closure *on_complete, grpc_call_list *call_list) {
+ grpc_closure *on_complete, grpc_closure_list *closure_list) {
size_t i;
round_robin_lb_policy *p = (round_robin_lb_policy *)pol;
pending_pick *pp;
@@ -303,14 +304,14 @@ void rr_pick(grpc_lb_policy *pol, grpc_pollset *pollset,
}
/* only advance the last picked pointer if the selection was used */
advance_last_picked_locked(p);
- on_complete->cb(on_complete->cb_arg, 1, call_list);
+ on_complete->cb(on_complete->cb_arg, 1, closure_list);
} else {
if (!p->started_picking) {
- start_picking(p, call_list);
+ start_picking(p, closure_list);
}
for (i = 0; i < p->num_subchannels; i++) {
grpc_subchannel_add_interested_party(p->subchannels[i], pollset,
- call_list);
+ closure_list);
}
pp = gpr_malloc(sizeof(*pp));
pp->next = p->pending_picks;
@@ -323,7 +324,7 @@ void rr_pick(grpc_lb_policy *pol, grpc_pollset *pollset,
}
static void rr_connectivity_changed(void *arg, int iomgr_success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
connectivity_changed_cb_arg *cb_arg = arg;
round_robin_lb_policy *p = cb_arg->p;
/* index over p->subchannels of this cb's subchannel */
@@ -346,7 +347,7 @@ static void rr_connectivity_changed(void *arg, int iomgr_success,
switch (*this_connectivity) {
case GRPC_CHANNEL_READY:
grpc_connectivity_state_set(&p->state_tracker, GRPC_CHANNEL_READY,
- "connecting_ready", call_list);
+ "connecting_ready", closure_list);
/* add the newly connected subchannel to the list of connected ones.
* Note that it goes to the "end of the line". */
p->subchannel_index_to_readylist_node[this_idx] =
@@ -369,28 +370,28 @@ static void rr_connectivity_changed(void *arg, int iomgr_success,
selected->subchannel, selected);
}
grpc_subchannel_del_interested_party(selected->subchannel,
- pp->pollset, call_list);
- grpc_call_list_add(call_list, pp->on_complete, 1);
+ pp->pollset, closure_list);
+ grpc_closure_list_add(closure_list, pp->on_complete, 1);
gpr_free(pp);
}
grpc_subchannel_notify_on_state_change(
p->subchannels[this_idx], this_connectivity,
- &p->connectivity_changed_cbs[this_idx], call_list);
+ &p->connectivity_changed_cbs[this_idx], closure_list);
break;
case GRPC_CHANNEL_CONNECTING:
case GRPC_CHANNEL_IDLE:
grpc_connectivity_state_set(&p->state_tracker, *this_connectivity,
- "connecting_changed", call_list);
+ "connecting_changed", closure_list);
grpc_subchannel_notify_on_state_change(
p->subchannels[this_idx], this_connectivity,
- &p->connectivity_changed_cbs[this_idx], call_list);
+ &p->connectivity_changed_cbs[this_idx], closure_list);
break;
case GRPC_CHANNEL_TRANSIENT_FAILURE:
- del_interested_parties_locked(p, this_idx, call_list);
+ del_interested_parties_locked(p, this_idx, closure_list);
/* renew state notification */
grpc_subchannel_notify_on_state_change(
p->subchannels[this_idx], this_connectivity,
- &p->connectivity_changed_cbs[this_idx], call_list);
+ &p->connectivity_changed_cbs[this_idx], closure_list);
/* remove from ready list if still present */
if (p->subchannel_index_to_readylist_node[this_idx] != NULL) {
@@ -398,12 +399,12 @@ static void rr_connectivity_changed(void *arg, int iomgr_success,
p, p->subchannel_index_to_readylist_node[this_idx]);
p->subchannel_index_to_readylist_node[this_idx] = NULL;
}
- grpc_connectivity_state_set(&p->state_tracker,
- GRPC_CHANNEL_TRANSIENT_FAILURE,
- "connecting_transient_failure", call_list);
+ grpc_connectivity_state_set(
+ &p->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE,
+ "connecting_transient_failure", closure_list);
break;
case GRPC_CHANNEL_FATAL_FAILURE:
- del_interested_parties_locked(p, this_idx, call_list);
+ del_interested_parties_locked(p, this_idx, closure_list);
if (p->subchannel_index_to_readylist_node[this_idx] != NULL) {
remove_disconnected_sc_locked(
p, p->subchannel_index_to_readylist_node[this_idx]);
@@ -414,23 +415,23 @@ static void rr_connectivity_changed(void *arg, int iomgr_success,
p->subchannels[p->num_subchannels - 1]);
p->num_subchannels--;
GRPC_SUBCHANNEL_UNREF(p->subchannels[p->num_subchannels], "round_robin",
- call_list);
+ closure_list);
if (p->num_subchannels == 0) {
grpc_connectivity_state_set(&p->state_tracker,
GRPC_CHANNEL_FATAL_FAILURE,
- "no_more_channels", call_list);
+ "no_more_channels", closure_list);
while ((pp = p->pending_picks)) {
p->pending_picks = pp->next;
*pp->target = NULL;
- grpc_call_list_add(call_list, pp->on_complete, 1);
+ grpc_closure_list_add(closure_list, pp->on_complete, 1);
gpr_free(pp);
}
unref = 1;
} else {
grpc_connectivity_state_set(&p->state_tracker,
GRPC_CHANNEL_TRANSIENT_FAILURE,
- "subchannel_failed", call_list);
+ "subchannel_failed", closure_list);
}
} /* switch */
} /* !unref */
@@ -438,12 +439,12 @@ static void rr_connectivity_changed(void *arg, int iomgr_success,
gpr_mu_unlock(&p->mu);
if (unref) {
- GRPC_LB_POLICY_UNREF(&p->base, "round_robin_connectivity", call_list);
+ GRPC_LB_POLICY_UNREF(&p->base, "round_robin_connectivity", closure_list);
}
}
static void rr_broadcast(grpc_lb_policy *pol, grpc_transport_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
round_robin_lb_policy *p = (round_robin_lb_policy *)pol;
size_t i;
size_t n;
@@ -459,14 +460,14 @@ static void rr_broadcast(grpc_lb_policy *pol, grpc_transport_op *op,
gpr_mu_unlock(&p->mu);
for (i = 0; i < n; i++) {
- grpc_subchannel_process_transport_op(subchannels[i], op, call_list);
- GRPC_SUBCHANNEL_UNREF(subchannels[i], "rr_broadcast", call_list);
+ grpc_subchannel_process_transport_op(subchannels[i], op, closure_list);
+ GRPC_SUBCHANNEL_UNREF(subchannels[i], "rr_broadcast", closure_list);
}
gpr_free(subchannels);
}
static grpc_connectivity_state rr_check_connectivity(
- grpc_lb_policy *pol, grpc_call_list *call_list) {
+ grpc_lb_policy *pol, grpc_closure_list *closure_list) {
round_robin_lb_policy *p = (round_robin_lb_policy *)pol;
grpc_connectivity_state st;
gpr_mu_lock(&p->mu);
@@ -478,11 +479,11 @@ static grpc_connectivity_state rr_check_connectivity(
static void rr_notify_on_state_change(grpc_lb_policy *pol,
grpc_connectivity_state *current,
grpc_closure *notify,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
round_robin_lb_policy *p = (round_robin_lb_policy *)pol;
gpr_mu_lock(&p->mu);
grpc_connectivity_state_notify_on_state_change(&p->state_tracker, current,
- notify, call_list);
+ notify, closure_list);
gpr_mu_unlock(&p->mu);
}
diff --git a/src/core/client_config/lb_policy.c b/src/core/client_config/lb_policy.c
index 84a033d583eeabe1adb23476765707fb50b48cd1..99eb69613b8754be20c95f2c9810d62d33266b79 100644
--- a/src/core/client_config/lb_policy.c
+++ b/src/core/client_config/lb_policy.c
@@ -51,49 +51,51 @@ void grpc_lb_policy_ref(grpc_lb_policy *policy) {
}
#ifdef GRPC_LB_POLICY_REFCOUNT_DEBUG
-void grpc_lb_policy_unref(grpc_lb_policy *policy, grpc_call_list *call_list,
- const char *file, int line, const char *reason) {
+void grpc_lb_policy_unref(grpc_lb_policy *policy,
+ grpc_closure_list *closure_list, const char *file,
+ int line, const char *reason) {
gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "LB_POLICY:%p unref %d -> %d %s",
policy, (int)policy->refs.count, (int)policy->refs.count - 1, reason);
#else
-void grpc_lb_policy_unref(grpc_lb_policy *policy, grpc_call_list *call_list) {
+void grpc_lb_policy_unref(grpc_lb_policy *policy,
+ grpc_closure_list *closure_list) {
#endif
if (gpr_unref(&policy->refs)) {
- policy->vtable->destroy(policy, call_list);
+ policy->vtable->destroy(policy, closure_list);
}
}
void grpc_lb_policy_shutdown(grpc_lb_policy *policy,
- grpc_call_list *call_list) {
- policy->vtable->shutdown(policy, call_list);
+ grpc_closure_list *closure_list) {
+ policy->vtable->shutdown(policy, closure_list);
}
void grpc_lb_policy_pick(grpc_lb_policy *policy, grpc_pollset *pollset,
grpc_metadata_batch *initial_metadata,
grpc_subchannel **target, grpc_closure *on_complete,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
policy->vtable->pick(policy, pollset, initial_metadata, target, on_complete,
- call_list);
+ closure_list);
}
void grpc_lb_policy_broadcast(grpc_lb_policy *policy, grpc_transport_op *op,
- grpc_call_list *call_list) {
- policy->vtable->broadcast(policy, op, call_list);
+ grpc_closure_list *closure_list) {
+ policy->vtable->broadcast(policy, op, closure_list);
}
void grpc_lb_policy_exit_idle(grpc_lb_policy *policy,
- grpc_call_list *call_list) {
- policy->vtable->exit_idle(policy, call_list);
+ grpc_closure_list *closure_list) {
+ policy->vtable->exit_idle(policy, closure_list);
}
void grpc_lb_policy_notify_on_state_change(grpc_lb_policy *policy,
grpc_connectivity_state *state,
grpc_closure *closure,
- grpc_call_list *call_list) {
- policy->vtable->notify_on_state_change(policy, state, closure, call_list);
+ grpc_closure_list *closure_list) {
+ policy->vtable->notify_on_state_change(policy, state, closure, closure_list);
}
grpc_connectivity_state grpc_lb_policy_check_connectivity(
- grpc_lb_policy *policy, grpc_call_list *call_list) {
- return policy->vtable->check_connectivity(policy, call_list);
+ grpc_lb_policy *policy, grpc_closure_list *closure_list) {
+ return policy->vtable->check_connectivity(policy, closure_list);
}
diff --git a/src/core/client_config/lb_policy.h b/src/core/client_config/lb_policy.h
index f9430b425061cb2ddc3e614f765a10f50f99fb5a..5e3c016eb26524eda5a7794f06f2beaf71dbd291 100644
--- a/src/core/client_config/lb_policy.h
+++ b/src/core/client_config/lb_policy.h
@@ -51,32 +51,32 @@ struct grpc_lb_policy {
};
struct grpc_lb_policy_vtable {
- void (*destroy)(grpc_lb_policy *policy, grpc_call_list *call_list);
+ void (*destroy)(grpc_lb_policy *policy, grpc_closure_list *closure_list);
- void (*shutdown)(grpc_lb_policy *policy, grpc_call_list *call_list);
+ void (*shutdown)(grpc_lb_policy *policy, grpc_closure_list *closure_list);
/** implement grpc_lb_policy_pick */
void (*pick)(grpc_lb_policy *policy, grpc_pollset *pollset,
grpc_metadata_batch *initial_metadata, grpc_subchannel **target,
- grpc_closure *on_complete, grpc_call_list *call_list);
+ grpc_closure *on_complete, grpc_closure_list *closure_list);
/** try to enter a READY connectivity state */
- void (*exit_idle)(grpc_lb_policy *policy, grpc_call_list *call_list);
+ void (*exit_idle)(grpc_lb_policy *policy, grpc_closure_list *closure_list);
/** broadcast a transport op to all subchannels */
void (*broadcast)(grpc_lb_policy *policy, grpc_transport_op *op,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** check the current connectivity of the lb_policy */
- grpc_connectivity_state (*check_connectivity)(grpc_lb_policy *policy,
- grpc_call_list *call_list);
+ grpc_connectivity_state (*check_connectivity)(
+ grpc_lb_policy *policy, grpc_closure_list *closure_list);
/** call notify when the connectivity state of a channel changes from *state.
Updates *state with the new state of the policy */
void (*notify_on_state_change)(grpc_lb_policy *policy,
grpc_connectivity_state *state,
grpc_closure *closure,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
};
#ifdef GRPC_LB_POLICY_REFCOUNT_DEBUG
@@ -86,13 +86,15 @@ struct grpc_lb_policy_vtable {
grpc_lb_policy_unref((p), (cl), __FILE__, __LINE__, (r))
void grpc_lb_policy_ref(grpc_lb_policy *policy, const char *file, int line,
const char *reason);
-void grpc_lb_policy_unref(grpc_lb_policy *policy, grpc_call_list *call_list,
- const char *file, int line, const char *reason);
+void grpc_lb_policy_unref(grpc_lb_policy *policy,
+ grpc_closure_list *closure_list, const char *file,
+ int line, const char *reason);
#else
#define GRPC_LB_POLICY_REF(p, r) grpc_lb_policy_ref((p))
#define GRPC_LB_POLICY_UNREF(p, r, cl) grpc_lb_policy_unref((p), (cl))
void grpc_lb_policy_ref(grpc_lb_policy *policy);
-void grpc_lb_policy_unref(grpc_lb_policy *policy, grpc_call_list *call_list);
+void grpc_lb_policy_unref(grpc_lb_policy *policy,
+ grpc_closure_list *closure_list);
#endif
/** called by concrete implementations to initialize the base struct */
@@ -100,7 +102,8 @@ void grpc_lb_policy_init(grpc_lb_policy *policy,
const grpc_lb_policy_vtable *vtable);
/** Start shutting down (fail any pending picks) */
-void grpc_lb_policy_shutdown(grpc_lb_policy *policy, grpc_call_list *call_list);
+void grpc_lb_policy_shutdown(grpc_lb_policy *policy,
+ grpc_closure_list *closure_list);
/** Given initial metadata in \a initial_metadata, find an appropriate
target for this rpc, and 'return' it by calling \a on_complete after setting
@@ -109,20 +112,20 @@ void grpc_lb_policy_shutdown(grpc_lb_policy *policy, grpc_call_list *call_list);
void grpc_lb_policy_pick(grpc_lb_policy *policy, grpc_pollset *pollset,
grpc_metadata_batch *initial_metadata,
grpc_subchannel **target, grpc_closure *on_complete,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void grpc_lb_policy_broadcast(grpc_lb_policy *policy, grpc_transport_op *op,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void grpc_lb_policy_exit_idle(grpc_lb_policy *policy,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void grpc_lb_policy_notify_on_state_change(grpc_lb_policy *policy,
grpc_connectivity_state *state,
grpc_closure *closure,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
grpc_connectivity_state grpc_lb_policy_check_connectivity(
- grpc_lb_policy *policy, grpc_call_list *call_list);
+ grpc_lb_policy *policy, grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_CONFIG_LB_POLICY_H */
diff --git a/src/core/client_config/resolver.c b/src/core/client_config/resolver.c
index eae8ec6ddf0855c7ac917c2ac2ba8b8a2ed8e895..21186d7aa188c722319102ccee458770dbf5353f 100644
--- a/src/core/client_config/resolver.c
+++ b/src/core/client_config/resolver.c
@@ -40,7 +40,7 @@ void grpc_resolver_init(grpc_resolver *resolver,
}
#ifdef GRPC_RESOLVER_REFCOUNT_DEBUG
-void grpc_resolver_ref(grpc_resolver *resolver, grpc_call_list *call_list,
+void grpc_resolver_ref(grpc_resolver *resolver, grpc_closure_list *closure_list,
const char *file, int line, const char *reason) {
gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "RESOLVER:%p ref %d -> %d %s",
resolver, (int)resolver->refs.count, (int)resolver->refs.count + 1,
@@ -52,34 +52,37 @@ void grpc_resolver_ref(grpc_resolver *resolver) {
}
#ifdef GRPC_RESOLVER_REFCOUNT_DEBUG
-void grpc_resolver_unref(grpc_resolver *resolver, grpc_call_list *call_list,
- const char *file, int line, const char *reason) {
+void grpc_resolver_unref(grpc_resolver *resolver,
+ grpc_closure_list *closure_list, const char *file,
+ int line, const char *reason) {
gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "RESOLVER:%p unref %d -> %d %s",
resolver, (int)resolver->refs.count, (int)resolver->refs.count - 1,
reason);
#else
-void grpc_resolver_unref(grpc_resolver *resolver, grpc_call_list *call_list) {
+void grpc_resolver_unref(grpc_resolver *resolver,
+ grpc_closure_list *closure_list) {
#endif
if (gpr_unref(&resolver->refs)) {
- resolver->vtable->destroy(resolver, call_list);
+ resolver->vtable->destroy(resolver, closure_list);
}
}
void grpc_resolver_shutdown(grpc_resolver *resolver,
- grpc_call_list *call_list) {
- resolver->vtable->shutdown(resolver, call_list);
+ grpc_closure_list *closure_list) {
+ resolver->vtable->shutdown(resolver, closure_list);
}
void grpc_resolver_channel_saw_error(grpc_resolver *resolver,
struct sockaddr *failing_address,
int failing_address_len,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
resolver->vtable->channel_saw_error(resolver, failing_address,
- failing_address_len, call_list);
+ failing_address_len, closure_list);
}
void grpc_resolver_next(grpc_resolver *resolver,
grpc_client_config **target_config,
- grpc_closure *on_complete, grpc_call_list *call_list) {
- resolver->vtable->next(resolver, target_config, on_complete, call_list);
+ grpc_closure *on_complete,
+ grpc_closure_list *closure_list) {
+ resolver->vtable->next(resolver, target_config, on_complete, closure_list);
}
diff --git a/src/core/client_config/resolver.h b/src/core/client_config/resolver.h
index 7960bcb92f412ad125ffa0e31a6b569f0879445f..0c39d37018a05647c80f44d0c83ee880c8ae0cb0 100644
--- a/src/core/client_config/resolver.h
+++ b/src/core/client_config/resolver.h
@@ -49,13 +49,14 @@ struct grpc_resolver {
};
struct grpc_resolver_vtable {
- void (*destroy)(grpc_resolver *resolver, grpc_call_list *call_list);
- void (*shutdown)(grpc_resolver *resolver, grpc_call_list *call_list);
+ void (*destroy)(grpc_resolver *resolver, grpc_closure_list *closure_list);
+ void (*shutdown)(grpc_resolver *resolver, grpc_closure_list *closure_list);
void (*channel_saw_error)(grpc_resolver *resolver,
struct sockaddr *failing_address,
- int failing_address_len, grpc_call_list *call_list);
+ int failing_address_len,
+ grpc_closure_list *closure_list);
void (*next)(grpc_resolver *resolver, grpc_client_config **target_config,
- grpc_closure *on_complete, grpc_call_list *call_list);
+ grpc_closure *on_complete, grpc_closure_list *closure_list);
};
#ifdef GRPC_RESOLVER_REFCOUNT_DEBUG
@@ -64,26 +65,28 @@ struct grpc_resolver_vtable {
grpc_resolver_unref((p), (cl), __FILE__, __LINE__, (r))
void grpc_resolver_ref(grpc_resolver *policy, const char *file, int line,
const char *reason);
-void grpc_resolver_unref(grpc_resolver *policy, grpc_call_list *call_list,
+void grpc_resolver_unref(grpc_resolver *policy, grpc_closure_list *closure_list,
const char *file, int line, const char *reason);
#else
#define GRPC_RESOLVER_REF(p, r) grpc_resolver_ref((p))
#define GRPC_RESOLVER_UNREF(p, r, cl) grpc_resolver_unref((p), (cl))
void grpc_resolver_ref(grpc_resolver *policy);
-void grpc_resolver_unref(grpc_resolver *policy, grpc_call_list *call_list);
+void grpc_resolver_unref(grpc_resolver *policy,
+ grpc_closure_list *closure_list);
#endif
void grpc_resolver_init(grpc_resolver *resolver,
const grpc_resolver_vtable *vtable);
-void grpc_resolver_shutdown(grpc_resolver *resolver, grpc_call_list *call_list);
+void grpc_resolver_shutdown(grpc_resolver *resolver,
+ grpc_closure_list *closure_list);
/** Notification that the channel has seen an error on some address.
Can be used as a hint that re-resolution is desirable soon. */
void grpc_resolver_channel_saw_error(grpc_resolver *resolver,
struct sockaddr *failing_address,
int failing_address_len,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** Get the next client config. Called by the channel to fetch a new
configuration. Expected to set *target_config with a new configuration,
@@ -93,6 +96,7 @@ void grpc_resolver_channel_saw_error(grpc_resolver *resolver,
schedule on_complete. */
void grpc_resolver_next(grpc_resolver *resolver,
grpc_client_config **target_config,
- grpc_closure *on_complete, grpc_call_list *call_list);
+ grpc_closure *on_complete,
+ grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_CONFIG_RESOLVER_H */
diff --git a/src/core/client_config/resolvers/dns_resolver.c b/src/core/client_config/resolvers/dns_resolver.c
index 0fc89ed864b6a365fa97a9e6fdbbdb3deb1b866b..73723350cb246eec32ab22dd135f43942a3795ab 100644
--- a/src/core/client_config/resolvers/dns_resolver.c
+++ b/src/core/client_config/resolvers/dns_resolver.c
@@ -74,36 +74,38 @@ typedef struct {
grpc_client_config *resolved_config;
} dns_resolver;
-static void dns_destroy(grpc_resolver *r, grpc_call_list *call_list);
+static void dns_destroy(grpc_resolver *r, grpc_closure_list *closure_list);
static void dns_start_resolving_locked(dns_resolver *r);
static void dns_maybe_finish_next_locked(dns_resolver *r,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
-static void dns_shutdown(grpc_resolver *r, grpc_call_list *call_list);
+static void dns_shutdown(grpc_resolver *r, grpc_closure_list *closure_list);
static void dns_channel_saw_error(grpc_resolver *r,
struct sockaddr *failing_address,
int failing_address_len,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
static void dns_next(grpc_resolver *r, grpc_client_config **target_config,
- grpc_closure *on_complete, grpc_call_list *call_list);
+ grpc_closure *on_complete,
+ grpc_closure_list *closure_list);
static const grpc_resolver_vtable dns_resolver_vtable = {
dns_destroy, dns_shutdown, dns_channel_saw_error, dns_next};
-static void dns_shutdown(grpc_resolver *resolver, grpc_call_list *call_list) {
+static void dns_shutdown(grpc_resolver *resolver,
+ grpc_closure_list *closure_list) {
dns_resolver *r = (dns_resolver *)resolver;
gpr_mu_lock(&r->mu);
if (r->next_completion != NULL) {
*r->target_config = NULL;
- grpc_call_list_add(call_list, r->next_completion, 1);
+ grpc_closure_list_add(closure_list, r->next_completion, 1);
r->next_completion = NULL;
}
gpr_mu_unlock(&r->mu);
}
static void dns_channel_saw_error(grpc_resolver *resolver, struct sockaddr *sa,
- int len, grpc_call_list *call_list) {
+ int len, grpc_closure_list *closure_list) {
dns_resolver *r = (dns_resolver *)resolver;
gpr_mu_lock(&r->mu);
if (!r->resolving) {
@@ -114,7 +116,8 @@ static void dns_channel_saw_error(grpc_resolver *resolver, struct sockaddr *sa,
static void dns_next(grpc_resolver *resolver,
grpc_client_config **target_config,
- grpc_closure *on_complete, grpc_call_list *call_list) {
+ grpc_closure *on_complete,
+ grpc_closure_list *closure_list) {
dns_resolver *r = (dns_resolver *)resolver;
gpr_mu_lock(&r->mu);
GPR_ASSERT(!r->next_completion);
@@ -123,13 +126,13 @@ static void dns_next(grpc_resolver *resolver,
if (r->resolved_version == 0 && !r->resolving) {
dns_start_resolving_locked(r);
} else {
- dns_maybe_finish_next_locked(r, call_list);
+ dns_maybe_finish_next_locked(r, closure_list);
}
gpr_mu_unlock(&r->mu);
}
static void dns_on_resolved(void *arg, grpc_resolved_addresses *addresses,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
dns_resolver *r = arg;
grpc_client_config *config = NULL;
grpc_subchannel **subchannels;
@@ -145,14 +148,14 @@ static void dns_on_resolved(void *arg, grpc_resolved_addresses *addresses,
args.addr = (struct sockaddr *)(addresses->addrs[i].addr);
args.addr_len = (size_t)addresses->addrs[i].len;
subchannels[i] = grpc_subchannel_factory_create_subchannel(
- r->subchannel_factory, &args, call_list);
+ r->subchannel_factory, &args, closure_list);
}
memset(&lb_policy_args, 0, sizeof(lb_policy_args));
lb_policy_args.subchannels = subchannels;
lb_policy_args.num_subchannels = addresses->naddrs;
lb_policy = grpc_lb_policy_create(r->lb_policy_name, &lb_policy_args);
grpc_client_config_set_lb_policy(config, lb_policy);
- GRPC_LB_POLICY_UNREF(lb_policy, "construction", call_list);
+ GRPC_LB_POLICY_UNREF(lb_policy, "construction", closure_list);
grpc_resolved_addresses_destroy(addresses);
gpr_free(subchannels);
}
@@ -160,14 +163,14 @@ static void dns_on_resolved(void *arg, grpc_resolved_addresses *addresses,
GPR_ASSERT(r->resolving);
r->resolving = 0;
if (r->resolved_config) {
- grpc_client_config_unref(r->resolved_config, call_list);
+ grpc_client_config_unref(r->resolved_config, closure_list);
}
r->resolved_config = config;
r->resolved_version++;
- dns_maybe_finish_next_locked(r, call_list);
+ dns_maybe_finish_next_locked(r, closure_list);
gpr_mu_unlock(&r->mu);
- GRPC_RESOLVER_UNREF(&r->base, "dns-resolving", call_list);
+ GRPC_RESOLVER_UNREF(&r->base, "dns-resolving", closure_list);
}
static void dns_start_resolving_locked(dns_resolver *r) {
@@ -178,26 +181,26 @@ static void dns_start_resolving_locked(dns_resolver *r) {
}
static void dns_maybe_finish_next_locked(dns_resolver *r,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
if (r->next_completion != NULL &&
r->resolved_version != r->published_version) {
*r->target_config = r->resolved_config;
if (r->resolved_config) {
grpc_client_config_ref(r->resolved_config);
}
- grpc_call_list_add(call_list, r->next_completion, 1);
+ grpc_closure_list_add(closure_list, r->next_completion, 1);
r->next_completion = NULL;
r->published_version = r->resolved_version;
}
}
-static void dns_destroy(grpc_resolver *gr, grpc_call_list *call_list) {
+static void dns_destroy(grpc_resolver *gr, grpc_closure_list *closure_list) {
dns_resolver *r = (dns_resolver *)gr;
gpr_mu_destroy(&r->mu);
if (r->resolved_config) {
- grpc_client_config_unref(r->resolved_config, call_list);
+ grpc_client_config_unref(r->resolved_config, closure_list);
}
- grpc_subchannel_factory_unref(r->subchannel_factory, call_list);
+ grpc_subchannel_factory_unref(r->subchannel_factory, closure_list);
gpr_free(r->name);
gpr_free(r->default_port);
gpr_free(r->lb_policy_name);
diff --git a/src/core/client_config/resolvers/sockaddr_resolver.c b/src/core/client_config/resolvers/sockaddr_resolver.c
index f0e207624456df7964251edd40450c5e83b9698a..da6b5518f8aefe75d95975bce718a438839bc31b 100644
--- a/src/core/client_config/resolvers/sockaddr_resolver.c
+++ b/src/core/client_config/resolvers/sockaddr_resolver.c
@@ -76,30 +76,32 @@ typedef struct {
grpc_client_config **target_config;
} sockaddr_resolver;
-static void sockaddr_destroy(grpc_resolver *r, grpc_call_list *call_list);
+static void sockaddr_destroy(grpc_resolver *r, grpc_closure_list *closure_list);
static void sockaddr_maybe_finish_next_locked(sockaddr_resolver *r,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
-static void sockaddr_shutdown(grpc_resolver *r, grpc_call_list *call_list);
+static void sockaddr_shutdown(grpc_resolver *r,
+ grpc_closure_list *closure_list);
static void sockaddr_channel_saw_error(grpc_resolver *r,
struct sockaddr *failing_address,
int failing_address_len,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
static void sockaddr_next(grpc_resolver *r, grpc_client_config **target_config,
- grpc_closure *on_complete, grpc_call_list *call_list);
+ grpc_closure *on_complete,
+ grpc_closure_list *closure_list);
static const grpc_resolver_vtable sockaddr_resolver_vtable = {
sockaddr_destroy, sockaddr_shutdown, sockaddr_channel_saw_error,
sockaddr_next};
static void sockaddr_shutdown(grpc_resolver *resolver,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
sockaddr_resolver *r = (sockaddr_resolver *)resolver;
gpr_mu_lock(&r->mu);
if (r->next_completion != NULL) {
*r->target_config = NULL;
- grpc_call_list_add(call_list, r->next_completion, 1);
+ grpc_closure_list_add(closure_list, r->next_completion, 1);
r->next_completion = NULL;
}
gpr_mu_unlock(&r->mu);
@@ -107,23 +109,23 @@ static void sockaddr_shutdown(grpc_resolver *resolver,
static void sockaddr_channel_saw_error(grpc_resolver *resolver,
struct sockaddr *sa, int len,
- grpc_call_list *call_list) {}
+ grpc_closure_list *closure_list) {}
static void sockaddr_next(grpc_resolver *resolver,
grpc_client_config **target_config,
grpc_closure *on_complete,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
sockaddr_resolver *r = (sockaddr_resolver *)resolver;
gpr_mu_lock(&r->mu);
GPR_ASSERT(!r->next_completion);
r->next_completion = on_complete;
r->target_config = target_config;
- sockaddr_maybe_finish_next_locked(r, call_list);
+ sockaddr_maybe_finish_next_locked(r, closure_list);
gpr_mu_unlock(&r->mu);
}
static void sockaddr_maybe_finish_next_locked(sockaddr_resolver *r,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_client_config *cfg;
grpc_lb_policy *lb_policy;
grpc_lb_policy_args lb_policy_args;
@@ -139,7 +141,7 @@ static void sockaddr_maybe_finish_next_locked(sockaddr_resolver *r,
args.addr = (struct sockaddr *)&r->addrs[i];
args.addr_len = r->addrs_len[i];
subchannels[i] = grpc_subchannel_factory_create_subchannel(
- r->subchannel_factory, &args, call_list);
+ r->subchannel_factory, &args, closure_list);
}
memset(&lb_policy_args, 0, sizeof(lb_policy_args));
lb_policy_args.subchannels = subchannels;
@@ -148,18 +150,19 @@ static void sockaddr_maybe_finish_next_locked(sockaddr_resolver *r,
grpc_lb_policy_create(r->lb_policy_name, &lb_policy_args);
gpr_free(subchannels);
grpc_client_config_set_lb_policy(cfg, lb_policy);
- GRPC_LB_POLICY_UNREF(lb_policy, "sockaddr", call_list);
+ GRPC_LB_POLICY_UNREF(lb_policy, "sockaddr", closure_list);
r->published = 1;
*r->target_config = cfg;
- grpc_call_list_add(call_list, r->next_completion, 1);
+ grpc_closure_list_add(closure_list, r->next_completion, 1);
r->next_completion = NULL;
}
}
-static void sockaddr_destroy(grpc_resolver *gr, grpc_call_list *call_list) {
+static void sockaddr_destroy(grpc_resolver *gr,
+ grpc_closure_list *closure_list) {
sockaddr_resolver *r = (sockaddr_resolver *)gr;
gpr_mu_destroy(&r->mu);
- grpc_subchannel_factory_unref(r->subchannel_factory, call_list);
+ grpc_subchannel_factory_unref(r->subchannel_factory, closure_list);
gpr_free(r->addrs);
gpr_free(r->addrs_len);
gpr_free(r->lb_policy_name);
diff --git a/src/core/client_config/subchannel.c b/src/core/client_config/subchannel.c
index c570c55267404bb66b5242c90eed70f13268c228..d41bf8f566a744ae9ee40ae81cccbe140d9c9049 100644
--- a/src/core/client_config/subchannel.c
+++ b/src/core/client_config/subchannel.c
@@ -144,14 +144,14 @@ struct grpc_subchannel_call {
#define CHANNEL_STACK_FROM_CONNECTION(con) ((grpc_channel_stack *)((con) + 1))
static grpc_subchannel_call *create_call(connection *con,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
static void connectivity_state_changed_locked(grpc_subchannel *c,
const char *reason,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
static grpc_connectivity_state compute_connectivity_locked(grpc_subchannel *c);
static gpr_timespec compute_connect_deadline(grpc_subchannel *c);
static void subchannel_connected(void *subchannel, int iomgr_success,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
static void subchannel_ref_locked(
grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
@@ -159,9 +159,10 @@ static int subchannel_unref_locked(
grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) GRPC_MUST_USE_RESULT;
static void connection_ref_locked(connection *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
static grpc_subchannel *connection_unref_locked(
- connection *c, grpc_call_list *call_list GRPC_SUBCHANNEL_REF_EXTRA_ARGS)
- GRPC_MUST_USE_RESULT;
-static void subchannel_destroy(grpc_subchannel *c, grpc_call_list *call_list);
+ connection *c, grpc_closure_list *closure_list
+ GRPC_SUBCHANNEL_REF_EXTRA_ARGS) GRPC_MUST_USE_RESULT;
+static void subchannel_destroy(grpc_subchannel *c,
+ grpc_closure_list *closure_list);
#ifdef GRPC_SUBCHANNEL_REFCOUNT_DEBUG
#define SUBCHANNEL_REF_LOCKED(p, r) \
@@ -197,9 +198,9 @@ static void subchannel_destroy(grpc_subchannel *c, grpc_call_list *call_list);
* connection implementation
*/
-static void connection_destroy(connection *c, grpc_call_list *call_list) {
+static void connection_destroy(connection *c, grpc_closure_list *closure_list) {
GPR_ASSERT(c->refs == 0);
- grpc_channel_stack_destroy(CHANNEL_STACK_FROM_CONNECTION(c), call_list);
+ grpc_channel_stack_destroy(CHANNEL_STACK_FROM_CONNECTION(c), closure_list);
gpr_free(c);
}
@@ -211,14 +212,15 @@ static void connection_ref_locked(
}
static grpc_subchannel *connection_unref_locked(
- connection *c, grpc_call_list *call_list GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+ connection *c,
+ grpc_closure_list *closure_list GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
grpc_subchannel *destroy = NULL;
UNREF_LOG("CONNECTION", c);
if (subchannel_unref_locked(c->subchannel REF_PASS_ARGS)) {
destroy = c->subchannel;
}
if (--c->refs == 0 && c->subchannel->active != c) {
- connection_destroy(c, call_list);
+ connection_destroy(c, closure_list);
}
return destroy;
}
@@ -246,38 +248,39 @@ void grpc_subchannel_ref(grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
}
void grpc_subchannel_unref(grpc_subchannel *c,
- grpc_call_list *call_list
+ grpc_closure_list *closure_list
GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
int destroy;
gpr_mu_lock(&c->mu);
destroy = subchannel_unref_locked(c REF_PASS_ARGS);
gpr_mu_unlock(&c->mu);
- if (destroy) subchannel_destroy(c, call_list);
+ if (destroy) subchannel_destroy(c, closure_list);
}
-static void subchannel_destroy(grpc_subchannel *c, grpc_call_list *call_list) {
+static void subchannel_destroy(grpc_subchannel *c,
+ grpc_closure_list *closure_list) {
if (c->active != NULL) {
- connection_destroy(c->active, call_list);
+ connection_destroy(c->active, closure_list);
}
gpr_free(c->filters);
grpc_channel_args_destroy(c->args);
gpr_free(c->addr);
grpc_mdctx_unref(c->mdctx);
- grpc_connectivity_state_destroy(&c->state_tracker, call_list);
- grpc_connector_unref(c->connector, call_list);
+ grpc_connectivity_state_destroy(&c->state_tracker, closure_list);
+ grpc_connector_unref(c->connector, closure_list);
gpr_free(c);
}
void grpc_subchannel_add_interested_party(grpc_subchannel *c,
grpc_pollset *pollset,
- grpc_call_list *call_list) {
- grpc_pollset_set_add_pollset(c->pollset_set, pollset, call_list);
+ grpc_closure_list *closure_list) {
+ grpc_pollset_set_add_pollset(c->pollset_set, pollset, closure_list);
}
void grpc_subchannel_del_interested_party(grpc_subchannel *c,
grpc_pollset *pollset,
- grpc_call_list *call_list) {
- grpc_pollset_set_del_pollset(c->pollset_set, pollset, call_list);
+ grpc_closure_list *closure_list) {
+ grpc_pollset_set_del_pollset(c->pollset_set, pollset, closure_list);
}
static gpr_uint32 random_seed() {
@@ -313,7 +316,8 @@ grpc_subchannel *grpc_subchannel_create(grpc_connector *connector,
return c;
}
-static void continue_connect(grpc_subchannel *c, grpc_call_list *call_list) {
+static void continue_connect(grpc_subchannel *c,
+ grpc_closure_list *closure_list) {
grpc_connect_in_args args;
args.interested_parties = c->pollset_set;
@@ -323,32 +327,32 @@ static void continue_connect(grpc_subchannel *c, grpc_call_list *call_list) {
args.channel_args = c->args;
grpc_connector_connect(c->connector, &args, &c->connecting_result,
- &c->connected, call_list);
+ &c->connected, closure_list);
}
-static void start_connect(grpc_subchannel *c, grpc_call_list *call_list) {
+static void start_connect(grpc_subchannel *c, grpc_closure_list *closure_list) {
c->backoff_delta = gpr_time_from_seconds(
GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS, GPR_TIMESPAN);
c->next_attempt =
gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC), c->backoff_delta);
- continue_connect(c, call_list);
+ continue_connect(c, closure_list);
}
static void continue_creating_call(void *arg, int iomgr_success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
waiting_for_connect *w4c = arg;
grpc_subchannel_del_interested_party(w4c->subchannel, w4c->pollset,
- call_list);
+ closure_list);
grpc_subchannel_create_call(w4c->subchannel, w4c->pollset, w4c->target,
- w4c->notify, call_list);
- GRPC_SUBCHANNEL_UNREF(w4c->subchannel, "waiting_for_connect", call_list);
+ w4c->notify, closure_list);
+ GRPC_SUBCHANNEL_UNREF(w4c->subchannel, "waiting_for_connect", closure_list);
gpr_free(w4c);
}
void grpc_subchannel_create_call(grpc_subchannel *c, grpc_pollset *pollset,
grpc_subchannel_call **target,
grpc_closure *notify,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
connection *con;
gpr_mu_lock(&c->mu);
if (c->active != NULL) {
@@ -356,8 +360,8 @@ void grpc_subchannel_create_call(grpc_subchannel *c, grpc_pollset *pollset,
CONNECTION_REF_LOCKED(con, "call");
gpr_mu_unlock(&c->mu);
- *target = create_call(con, call_list);
- notify->cb(notify->cb_arg, 1, call_list);
+ *target = create_call(con, closure_list);
+ notify->cb(notify->cb_arg, 1, closure_list);
} else {
waiting_for_connect *w4c = gpr_malloc(sizeof(*w4c));
w4c->next = c->waiting;
@@ -369,16 +373,16 @@ void grpc_subchannel_create_call(grpc_subchannel *c, grpc_pollset *pollset,
SUBCHANNEL_REF_LOCKED(c, "waiting_for_connect");
grpc_closure_init(&w4c->continuation, continue_creating_call, w4c);
c->waiting = w4c;
- grpc_subchannel_add_interested_party(c, pollset, call_list);
+ grpc_subchannel_add_interested_party(c, pollset, closure_list);
if (!c->connecting) {
c->connecting = 1;
- connectivity_state_changed_locked(c, "create_call", call_list);
+ connectivity_state_changed_locked(c, "create_call", closure_list);
/* released by connection */
SUBCHANNEL_REF_LOCKED(c, "connecting");
GRPC_CHANNEL_INTERNAL_REF(c->master, "connecting");
gpr_mu_unlock(&c->mu);
- start_connect(c, call_list);
+ start_connect(c, closure_list);
} else {
gpr_mu_unlock(&c->mu);
}
@@ -396,28 +400,28 @@ grpc_connectivity_state grpc_subchannel_check_connectivity(grpc_subchannel *c) {
void grpc_subchannel_notify_on_state_change(grpc_subchannel *c,
grpc_connectivity_state *state,
grpc_closure *notify,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
int do_connect = 0;
gpr_mu_lock(&c->mu);
if (grpc_connectivity_state_notify_on_state_change(&c->state_tracker, state,
- notify, call_list)) {
+ notify, closure_list)) {
do_connect = 1;
c->connecting = 1;
/* released by connection */
SUBCHANNEL_REF_LOCKED(c, "connecting");
GRPC_CHANNEL_INTERNAL_REF(c->master, "connecting");
- connectivity_state_changed_locked(c, "state_change", call_list);
+ connectivity_state_changed_locked(c, "state_change", closure_list);
}
gpr_mu_unlock(&c->mu);
if (do_connect) {
- start_connect(c, call_list);
+ start_connect(c, closure_list);
}
}
void grpc_subchannel_process_transport_op(grpc_subchannel *c,
grpc_transport_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
connection *con = NULL;
grpc_subchannel *destroy;
int cancel_alarm = 0;
@@ -428,7 +432,7 @@ void grpc_subchannel_process_transport_op(grpc_subchannel *c,
}
if (op->disconnect) {
c->disconnected = 1;
- connectivity_state_changed_locked(c, "disconnect", call_list);
+ connectivity_state_changed_locked(c, "disconnect", closure_list);
if (c->have_alarm) {
cancel_alarm = 1;
}
@@ -439,27 +443,27 @@ void grpc_subchannel_process_transport_op(grpc_subchannel *c,
grpc_channel_stack *channel_stack = CHANNEL_STACK_FROM_CONNECTION(con);
grpc_channel_element *top_elem =
grpc_channel_stack_element(channel_stack, 0);
- top_elem->filter->start_transport_op(top_elem, op, call_list);
+ top_elem->filter->start_transport_op(top_elem, op, closure_list);
gpr_mu_lock(&c->mu);
- destroy = CONNECTION_UNREF_LOCKED(con, "transport-op", call_list);
+ destroy = CONNECTION_UNREF_LOCKED(con, "transport-op", closure_list);
gpr_mu_unlock(&c->mu);
if (destroy) {
- subchannel_destroy(destroy, call_list);
+ subchannel_destroy(destroy, closure_list);
}
}
if (cancel_alarm) {
- grpc_alarm_cancel(&c->alarm, call_list);
+ grpc_alarm_cancel(&c->alarm, closure_list);
}
if (op->disconnect) {
- grpc_connector_shutdown(c->connector, call_list);
+ grpc_connector_shutdown(c->connector, closure_list);
}
}
static void on_state_changed(void *p, int iomgr_success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
state_watcher *sw = p;
grpc_subchannel *c = sw->subchannel;
gpr_mu *mu = &c->mu;
@@ -486,7 +490,7 @@ static void on_state_changed(void *p, int iomgr_success,
op.on_connectivity_state_change = &sw->closure;
elem = grpc_channel_stack_element(
CHANNEL_STACK_FROM_CONNECTION(c->active), 0);
- elem->filter->start_transport_op(elem, &op, call_list);
+ elem->filter->start_transport_op(elem, &op, closure_list);
/* early out */
gpr_mu_unlock(mu);
return;
@@ -500,24 +504,25 @@ static void on_state_changed(void *p, int iomgr_success,
grpc_connectivity_state_set(
&c->state_tracker, c->disconnected ? GRPC_CHANNEL_FATAL_FAILURE
: GRPC_CHANNEL_TRANSIENT_FAILURE,
- "connection_failed", call_list);
+ "connection_failed", closure_list);
break;
}
done:
- connectivity_state_changed_locked(c, "transport_state_changed", call_list);
+ connectivity_state_changed_locked(c, "transport_state_changed", closure_list);
destroy = SUBCHANNEL_UNREF_LOCKED(c, "state_watcher");
gpr_free(sw);
gpr_mu_unlock(mu);
if (destroy) {
- subchannel_destroy(c, call_list);
+ subchannel_destroy(c, closure_list);
}
if (destroy_connection != NULL) {
- connection_destroy(destroy_connection, call_list);
+ connection_destroy(destroy_connection, closure_list);
}
}
-static void publish_transport(grpc_subchannel *c, grpc_call_list *call_list) {
+static void publish_transport(grpc_subchannel *c,
+ grpc_closure_list *closure_list) {
size_t channel_stack_size;
connection *con;
grpc_channel_stack *stk;
@@ -544,7 +549,7 @@ static void publish_transport(grpc_subchannel *c, grpc_call_list *call_list) {
con->refs = 0;
con->subchannel = c;
grpc_channel_stack_init(filters, num_filters, c->master, c->args, c->mdctx,
- stk, call_list);
+ stk, closure_list);
grpc_connected_channel_bind_transport(stk, c->connecting_result.transport);
gpr_free(c->connecting_result.filters);
memset(&c->connecting_result, 0, sizeof(c->connecting_result));
@@ -561,9 +566,9 @@ static void publish_transport(grpc_subchannel *c, grpc_call_list *call_list) {
gpr_mu_unlock(&c->mu);
gpr_free(sw);
gpr_free(filters);
- grpc_channel_stack_destroy(stk, call_list);
- GRPC_CHANNEL_INTERNAL_UNREF(c->master, "connecting", call_list);
- GRPC_SUBCHANNEL_UNREF(c, "connecting", call_list);
+ grpc_channel_stack_destroy(stk, closure_list);
+ GRPC_CHANNEL_INTERNAL_UNREF(c->master, "connecting", closure_list);
+ GRPC_SUBCHANNEL_UNREF(c, "connecting", closure_list);
return;
}
@@ -583,14 +588,14 @@ static void publish_transport(grpc_subchannel *c, grpc_call_list *call_list) {
op.on_connectivity_state_change = &sw->closure;
op.bind_pollset_set = c->pollset_set;
SUBCHANNEL_REF_LOCKED(c, "state_watcher");
- GRPC_CHANNEL_INTERNAL_UNREF(c->master, "connecting", call_list);
+ GRPC_CHANNEL_INTERNAL_UNREF(c->master, "connecting", closure_list);
GPR_ASSERT(!SUBCHANNEL_UNREF_LOCKED(c, "connecting"));
elem =
grpc_channel_stack_element(CHANNEL_STACK_FROM_CONNECTION(c->active), 0);
- elem->filter->start_transport_op(elem, &op, call_list);
+ elem->filter->start_transport_op(elem, &op, closure_list);
/* signal completion */
- connectivity_state_changed_locked(c, "connected", call_list);
+ connectivity_state_changed_locked(c, "connected", closure_list);
w4c = c->waiting;
c->waiting = NULL;
@@ -598,14 +603,14 @@ static void publish_transport(grpc_subchannel *c, grpc_call_list *call_list) {
while (w4c != NULL) {
waiting_for_connect *next = w4c->next;
- grpc_call_list_add(call_list, &w4c->continuation, 1);
+ grpc_closure_list_add(closure_list, &w4c->continuation, 1);
w4c = next;
}
gpr_free(filters);
if (destroy_connection != NULL) {
- connection_destroy(destroy_connection, call_list);
+ connection_destroy(destroy_connection, closure_list);
}
}
@@ -638,36 +643,37 @@ static void update_reconnect_parameters(grpc_subchannel *c) {
gpr_time_add(c->next_attempt, gpr_time_from_millis(jitter, GPR_TIMESPAN));
}
-static void on_alarm(void *arg, int iomgr_success, grpc_call_list *call_list) {
+static void on_alarm(void *arg, int iomgr_success,
+ grpc_closure_list *closure_list) {
grpc_subchannel *c = arg;
gpr_mu_lock(&c->mu);
c->have_alarm = 0;
if (c->disconnected) {
iomgr_success = 0;
}
- connectivity_state_changed_locked(c, "alarm", call_list);
+ connectivity_state_changed_locked(c, "alarm", closure_list);
gpr_mu_unlock(&c->mu);
if (iomgr_success) {
update_reconnect_parameters(c);
- continue_connect(c, call_list);
+ continue_connect(c, closure_list);
} else {
- GRPC_CHANNEL_INTERNAL_UNREF(c->master, "connecting", call_list);
- GRPC_SUBCHANNEL_UNREF(c, "connecting", call_list);
+ GRPC_CHANNEL_INTERNAL_UNREF(c->master, "connecting", closure_list);
+ GRPC_SUBCHANNEL_UNREF(c, "connecting", closure_list);
}
}
static void subchannel_connected(void *arg, int iomgr_success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_subchannel *c = arg;
if (c->connecting_result.transport != NULL) {
- publish_transport(c, call_list);
+ publish_transport(c, closure_list);
} else {
gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
gpr_mu_lock(&c->mu);
GPR_ASSERT(!c->have_alarm);
c->have_alarm = 1;
- connectivity_state_changed_locked(c, "connect_failed", call_list);
- grpc_alarm_init(&c->alarm, c->next_attempt, on_alarm, c, now, call_list);
+ connectivity_state_changed_locked(c, "connect_failed", closure_list);
+ grpc_alarm_init(&c->alarm, c->next_attempt, on_alarm, c, now, closure_list);
gpr_mu_unlock(&c->mu);
}
}
@@ -701,9 +707,9 @@ static grpc_connectivity_state compute_connectivity_locked(grpc_subchannel *c) {
static void connectivity_state_changed_locked(grpc_subchannel *c,
const char *reason,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_connectivity_state current = compute_connectivity_locked(c);
- grpc_connectivity_state_set(&c->state_tracker, current, reason, call_list);
+ grpc_connectivity_state_set(&c->state_tracker, current, reason, closure_list);
}
/*
@@ -716,45 +722,45 @@ void grpc_subchannel_call_ref(
}
void grpc_subchannel_call_unref(grpc_subchannel_call *c,
- grpc_call_list *call_list
+ grpc_closure_list *closure_list
GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
if (gpr_unref(&c->refs)) {
gpr_mu *mu = &c->connection->subchannel->mu;
grpc_subchannel *destroy;
- grpc_call_stack_destroy(SUBCHANNEL_CALL_TO_CALL_STACK(c), call_list);
+ grpc_call_stack_destroy(SUBCHANNEL_CALL_TO_CALL_STACK(c), closure_list);
gpr_mu_lock(mu);
- destroy = CONNECTION_UNREF_LOCKED(c->connection, "call", call_list);
+ destroy = CONNECTION_UNREF_LOCKED(c->connection, "call", closure_list);
gpr_mu_unlock(mu);
gpr_free(c);
if (destroy != NULL) {
- subchannel_destroy(destroy, call_list);
+ subchannel_destroy(destroy, closure_list);
}
}
}
char *grpc_subchannel_call_get_peer(grpc_subchannel_call *call,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_call_stack *call_stack = SUBCHANNEL_CALL_TO_CALL_STACK(call);
grpc_call_element *top_elem = grpc_call_stack_element(call_stack, 0);
- return top_elem->filter->get_peer(top_elem, call_list);
+ return top_elem->filter->get_peer(top_elem, closure_list);
}
void grpc_subchannel_call_process_op(grpc_subchannel_call *call,
grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_call_stack *call_stack = SUBCHANNEL_CALL_TO_CALL_STACK(call);
grpc_call_element *top_elem = grpc_call_stack_element(call_stack, 0);
- top_elem->filter->start_transport_stream_op(top_elem, op, call_list);
+ top_elem->filter->start_transport_stream_op(top_elem, op, closure_list);
}
static grpc_subchannel_call *create_call(connection *con,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_channel_stack *chanstk = CHANNEL_STACK_FROM_CONNECTION(con);
grpc_subchannel_call *call =
gpr_malloc(sizeof(grpc_subchannel_call) + chanstk->call_stack_size);
grpc_call_stack *callstk = SUBCHANNEL_CALL_TO_CALL_STACK(call);
call->connection = con;
gpr_ref_init(&call->refs, 1);
- grpc_call_stack_init(chanstk, NULL, NULL, callstk, call_list);
+ grpc_call_stack_init(chanstk, NULL, NULL, callstk, closure_list);
return call;
}
diff --git a/src/core/client_config/subchannel.h b/src/core/client_config/subchannel.h
index 0ebfc7c29aece6bebee76ec2b85f7d8caee5a4be..57cc248fecc9358024d1fb2c9b64441ed940484e 100644
--- a/src/core/client_config/subchannel.h
+++ b/src/core/client_config/subchannel.h
@@ -67,12 +67,12 @@ typedef struct grpc_subchannel_args grpc_subchannel_args;
void grpc_subchannel_ref(
grpc_subchannel *channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
void grpc_subchannel_unref(grpc_subchannel *channel,
- grpc_call_list *call_list
+ grpc_closure_list *closure_list
GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
void grpc_subchannel_call_ref(
grpc_subchannel_call *call GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
void grpc_subchannel_call_unref(grpc_subchannel_call *call,
- grpc_call_list *call_list
+ grpc_closure_list *closure_list
GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
/** construct a call (possibly asynchronously) */
@@ -80,12 +80,12 @@ void grpc_subchannel_create_call(grpc_subchannel *subchannel,
grpc_pollset *pollset,
grpc_subchannel_call **target,
grpc_closure *notify,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** process a transport level op */
void grpc_subchannel_process_transport_op(grpc_subchannel *subchannel,
grpc_transport_op *op,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** poll the current connectivity state of a channel */
grpc_connectivity_state grpc_subchannel_check_connectivity(
@@ -96,25 +96,25 @@ grpc_connectivity_state grpc_subchannel_check_connectivity(
void grpc_subchannel_notify_on_state_change(grpc_subchannel *channel,
grpc_connectivity_state *state,
grpc_closure *notify,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** express interest in \a channel's activities through \a pollset. */
void grpc_subchannel_add_interested_party(grpc_subchannel *channel,
grpc_pollset *pollset,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** stop following \a channel's activity through \a pollset. */
void grpc_subchannel_del_interested_party(grpc_subchannel *channel,
grpc_pollset *pollset,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** continue processing a transport op */
void grpc_subchannel_call_process_op(grpc_subchannel_call *subchannel_call,
grpc_transport_stream_op *op,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** continue querying for peer */
char *grpc_subchannel_call_get_peer(grpc_subchannel_call *subchannel_call,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
struct grpc_subchannel_args {
/** Channel filters for this channel - wrapped factories will likely
diff --git a/src/core/client_config/subchannel_factory.c b/src/core/client_config/subchannel_factory.c
index e2526650000d3895b6393bcf69418f7235f8d88c..51b805f2f52e9a66dfbc9ae045cc1c20b3cfc441 100644
--- a/src/core/client_config/subchannel_factory.c
+++ b/src/core/client_config/subchannel_factory.c
@@ -38,12 +38,12 @@ void grpc_subchannel_factory_ref(grpc_subchannel_factory *factory) {
}
void grpc_subchannel_factory_unref(grpc_subchannel_factory *factory,
- grpc_call_list *call_list) {
- factory->vtable->unref(factory, call_list);
+ grpc_closure_list *closure_list) {
+ factory->vtable->unref(factory, closure_list);
}
grpc_subchannel *grpc_subchannel_factory_create_subchannel(
grpc_subchannel_factory *factory, grpc_subchannel_args *args,
- grpc_call_list *call_list) {
- return factory->vtable->create_subchannel(factory, args, call_list);
+ grpc_closure_list *closure_list) {
+ return factory->vtable->create_subchannel(factory, args, closure_list);
}
diff --git a/src/core/client_config/subchannel_factory.h b/src/core/client_config/subchannel_factory.h
index 2ff9d3c4027cc66637291f7aa2af6c0baf40f6b5..ea19ab894477a9016ea866f5d0e2c1be96bec6b5 100644
--- a/src/core/client_config/subchannel_factory.h
+++ b/src/core/client_config/subchannel_factory.h
@@ -48,19 +48,20 @@ struct grpc_subchannel_factory {
struct grpc_subchannel_factory_vtable {
void (*ref)(grpc_subchannel_factory *factory);
- void (*unref)(grpc_subchannel_factory *factory, grpc_call_list *call_list);
+ void (*unref)(grpc_subchannel_factory *factory,
+ grpc_closure_list *closure_list);
grpc_subchannel *(*create_subchannel)(grpc_subchannel_factory *factory,
grpc_subchannel_args *args,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
};
void grpc_subchannel_factory_ref(grpc_subchannel_factory *factory);
void grpc_subchannel_factory_unref(grpc_subchannel_factory *factory,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** Create a new grpc_subchannel */
grpc_subchannel *grpc_subchannel_factory_create_subchannel(
grpc_subchannel_factory *factory, grpc_subchannel_args *args,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_CLIENT_CONFIG_SUBCHANNEL_FACTORY_H */
diff --git a/src/core/client_config/subchannel_factory_decorators/merge_channel_args.c b/src/core/client_config/subchannel_factory_decorators/merge_channel_args.c
index 00dff6343c1d258735dabec5cf1f694d6c7aef10..cf5fb00cdf8f43c729672c059931db7f87d7e33a 100644
--- a/src/core/client_config/subchannel_factory_decorators/merge_channel_args.c
+++ b/src/core/client_config/subchannel_factory_decorators/merge_channel_args.c
@@ -48,10 +48,10 @@ static void merge_args_factory_ref(grpc_subchannel_factory *scf) {
}
static void merge_args_factory_unref(grpc_subchannel_factory *scf,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
merge_args_factory *f = (merge_args_factory *)scf;
if (gpr_unref(&f->refs)) {
- grpc_subchannel_factory_unref(f->wrapped, call_list);
+ grpc_subchannel_factory_unref(f->wrapped, closure_list);
grpc_channel_args_destroy(f->merge_args);
gpr_free(f);
}
@@ -59,13 +59,13 @@ static void merge_args_factory_unref(grpc_subchannel_factory *scf,
static grpc_subchannel *merge_args_factory_create_subchannel(
grpc_subchannel_factory *scf, grpc_subchannel_args *args,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
merge_args_factory *f = (merge_args_factory *)scf;
grpc_channel_args *final_args =
grpc_channel_args_merge(args->args, f->merge_args);
grpc_subchannel *s;
args->args = final_args;
- s = grpc_subchannel_factory_create_subchannel(f->wrapped, args, call_list);
+ s = grpc_subchannel_factory_create_subchannel(f->wrapped, args, closure_list);
grpc_channel_args_destroy(final_args);
return s;
}
diff --git a/src/core/httpcli/httpcli.c b/src/core/httpcli/httpcli.c
index fc45eda2de62f18a09c8a8f743cc1876838c5c4f..6422bfb840a2a33d7be62b07ba81a535b2532e59 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 6d19da37fbe8345f67f3954417ef844d889aaea2..2460c6ca606afd0d99ce250368a9485995cc2532 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 a340a90c4b24a0e2ee756bfef112d58adc0644c7..1ae1d7f09b08851d5d8f1f36e435abd92ea6cabc 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");
}
diff --git a/src/core/iomgr/alarm.c b/src/core/iomgr/alarm.c
index da265d4e506f2748c31b5067af8eb622e33c78be..d26dc57b096e34de5917099195b74f41f0b9ef7b 100644
--- a/src/core/iomgr/alarm.c
+++ b/src/core/iomgr/alarm.c
@@ -73,7 +73,8 @@ static shard_type g_shards[NUM_SHARDS];
static shard_type *g_shard_queue[NUM_SHARDS];
static int run_some_expired_alarms(gpr_timespec now, gpr_timespec *next,
- int success, grpc_call_list *call_list);
+ int success,
+ grpc_closure_list *closure_list);
static gpr_timespec compute_min_deadline(shard_type *shard) {
return grpc_alarm_heap_is_empty(&shard->heap)
@@ -102,9 +103,9 @@ void grpc_alarm_list_init(gpr_timespec now) {
}
}
-void grpc_alarm_list_shutdown(grpc_call_list *call_list) {
+void grpc_alarm_list_shutdown(grpc_closure_list *closure_list) {
int i;
- run_some_expired_alarms(gpr_inf_future(g_clock_type), NULL, 0, call_list);
+ run_some_expired_alarms(gpr_inf_future(g_clock_type), NULL, 0, closure_list);
for (i = 0; i < NUM_SHARDS; i++) {
shard_type *shard = &g_shards[i];
gpr_mu_destroy(&shard->mu);
@@ -172,7 +173,7 @@ static void note_deadline_change(shard_type *shard) {
void grpc_alarm_init(grpc_alarm *alarm, gpr_timespec deadline,
grpc_iomgr_cb_func alarm_cb, void *alarm_cb_arg,
- gpr_timespec now, grpc_call_list *call_list) {
+ gpr_timespec now, grpc_closure_list *closure_list) {
int is_first_alarm = 0;
shard_type *shard = &g_shards[shard_idx(alarm)];
GPR_ASSERT(deadline.clock_type == g_clock_type);
@@ -220,11 +221,11 @@ void grpc_alarm_init(grpc_alarm *alarm, gpr_timespec deadline,
}
}
-void grpc_alarm_cancel(grpc_alarm *alarm, grpc_call_list *call_list) {
+void grpc_alarm_cancel(grpc_alarm *alarm, grpc_closure_list *closure_list) {
shard_type *shard = &g_shards[shard_idx(alarm)];
gpr_mu_lock(&shard->mu);
if (!alarm->triggered) {
- grpc_call_list_add(call_list, &alarm->closure, 0);
+ grpc_closure_list_add(closure_list, &alarm->closure, 0);
alarm->triggered = 1;
if (alarm->heap_index == INVALID_HEAP_INDEX) {
list_remove(alarm);
@@ -285,12 +286,12 @@ static grpc_alarm *pop_one(shard_type *shard, gpr_timespec now) {
/* REQUIRES: shard->mu unlocked */
static size_t pop_alarms(shard_type *shard, gpr_timespec now,
gpr_timespec *new_min_deadline, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t n = 0;
grpc_alarm *alarm;
gpr_mu_lock(&shard->mu);
while ((alarm = pop_one(shard, now))) {
- grpc_call_list_add(call_list, &alarm->closure, success);
+ grpc_closure_list_add(closure_list, &alarm->closure, success);
n++;
}
*new_min_deadline = compute_min_deadline(shard);
@@ -299,7 +300,8 @@ static size_t pop_alarms(shard_type *shard, gpr_timespec now,
}
static int run_some_expired_alarms(gpr_timespec now, gpr_timespec *next,
- int success, grpc_call_list *call_list) {
+ int success,
+ grpc_closure_list *closure_list) {
size_t n = 0;
/* TODO(ctiller): verify that there are any alarms (atomically) here */
@@ -314,7 +316,7 @@ static int run_some_expired_alarms(gpr_timespec now, gpr_timespec *next,
shard. This may violate perfect alarm deadline ordering, but that
shouldn't be a big deal because we don't make ordering guarantees. */
n += pop_alarms(g_shard_queue[0], now, &new_min_deadline, success,
- call_list);
+ closure_list);
/* An grpc_alarm_init() on the shard could intervene here, adding a new
alarm that is earlier than new_min_deadline. However,
@@ -337,11 +339,11 @@ static int run_some_expired_alarms(gpr_timespec now, gpr_timespec *next,
}
int grpc_alarm_check(gpr_timespec now, gpr_timespec *next,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
GPR_ASSERT(now.clock_type == g_clock_type);
return run_some_expired_alarms(
now, next, gpr_time_cmp(now, gpr_inf_future(now.clock_type)) != 0,
- call_list);
+ closure_list);
}
gpr_timespec grpc_alarm_list_next_timeout(void) {
diff --git a/src/core/iomgr/alarm.h b/src/core/iomgr/alarm.h
index 05ca7c27bbdb56e73a4bf8f3d36991e29e9f3581..09bfa887569c953c781c0891f70945862e81c749 100644
--- a/src/core/iomgr/alarm.h
+++ b/src/core/iomgr/alarm.h
@@ -55,7 +55,7 @@ typedef struct grpc_alarm {
information about when to free up any user-level state. */
void grpc_alarm_init(grpc_alarm *alarm, gpr_timespec deadline,
grpc_iomgr_cb_func alarm_cb, void *alarm_cb_arg,
- gpr_timespec now, grpc_call_list *call_list);
+ gpr_timespec now, grpc_closure_list *closure_list);
/* Note that there is no alarm destroy function. This is because the
alarm is a one-time occurrence with a guarantee that the callback will
@@ -83,6 +83,6 @@ void grpc_alarm_init(grpc_alarm *alarm, gpr_timespec deadline,
matches this aim.
Requires: cancel() must happen after add() on a given alarm */
-void grpc_alarm_cancel(grpc_alarm *alarm, grpc_call_list *call_list);
+void grpc_alarm_cancel(grpc_alarm *alarm, grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_IOMGR_ALARM_H */
diff --git a/src/core/iomgr/alarm_internal.h b/src/core/iomgr/alarm_internal.h
index a2e9946f4fdc0b4ce59c85d0cf9293eec6163605..aebc789ec67067804e809dd49a42f785ea7f3a70 100644
--- a/src/core/iomgr/alarm_internal.h
+++ b/src/core/iomgr/alarm_internal.h
@@ -49,9 +49,9 @@
at any time slice. */
int grpc_alarm_check(gpr_timespec now, gpr_timespec *next,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void grpc_alarm_list_init(gpr_timespec now);
-void grpc_alarm_list_shutdown(grpc_call_list *call_list);
+void grpc_alarm_list_shutdown(grpc_closure_list *closure_list);
gpr_timespec grpc_alarm_list_next_timeout(void);
diff --git a/src/core/iomgr/endpoint.c b/src/core/iomgr/endpoint.c
index 769f155a639cdea5695a533b6f4a5ab5943cbb4e..db2a738d09a6a776ef9d67d02ca6bedcbfe34af4 100644
--- a/src/core/iomgr/endpoint.c
+++ b/src/core/iomgr/endpoint.c
@@ -34,32 +34,33 @@
#include "src/core/iomgr/endpoint.h"
void grpc_endpoint_read(grpc_endpoint *ep, gpr_slice_buffer *slices,
- grpc_closure *cb, grpc_call_list *call_list) {
- ep->vtable->read(ep, slices, cb, call_list);
+ grpc_closure *cb, grpc_closure_list *closure_list) {
+ ep->vtable->read(ep, slices, cb, closure_list);
}
void grpc_endpoint_write(grpc_endpoint *ep, gpr_slice_buffer *slices,
- grpc_closure *cb, grpc_call_list *call_list) {
- ep->vtable->write(ep, slices, cb, call_list);
+ grpc_closure *cb, grpc_closure_list *closure_list) {
+ ep->vtable->write(ep, slices, cb, closure_list);
}
void grpc_endpoint_add_to_pollset(grpc_endpoint *ep, grpc_pollset *pollset,
- grpc_call_list *call_list) {
- ep->vtable->add_to_pollset(ep, pollset, call_list);
+ grpc_closure_list *closure_list) {
+ ep->vtable->add_to_pollset(ep, pollset, closure_list);
}
void grpc_endpoint_add_to_pollset_set(grpc_endpoint *ep,
grpc_pollset_set *pollset_set,
- grpc_call_list *call_list) {
- ep->vtable->add_to_pollset_set(ep, pollset_set, call_list);
+ grpc_closure_list *closure_list) {
+ ep->vtable->add_to_pollset_set(ep, pollset_set, closure_list);
}
-void grpc_endpoint_shutdown(grpc_endpoint *ep, grpc_call_list *call_list) {
- ep->vtable->shutdown(ep, call_list);
+void grpc_endpoint_shutdown(grpc_endpoint *ep,
+ grpc_closure_list *closure_list) {
+ ep->vtable->shutdown(ep, closure_list);
}
-void grpc_endpoint_destroy(grpc_endpoint *ep, grpc_call_list *call_list) {
- ep->vtable->destroy(ep, call_list);
+void grpc_endpoint_destroy(grpc_endpoint *ep, grpc_closure_list *closure_list) {
+ ep->vtable->destroy(ep, closure_list);
}
char *grpc_endpoint_get_peer(grpc_endpoint *ep) {
diff --git a/src/core/iomgr/endpoint.h b/src/core/iomgr/endpoint.h
index f9881684ffa76a39a3c0669ae5b264a0375fbb98..cb722e32e9d00f23a58d93296add5489b675a8db 100644
--- a/src/core/iomgr/endpoint.h
+++ b/src/core/iomgr/endpoint.h
@@ -48,15 +48,15 @@ typedef struct grpc_endpoint_vtable grpc_endpoint_vtable;
struct grpc_endpoint_vtable {
void (*read)(grpc_endpoint *ep, gpr_slice_buffer *slices, grpc_closure *cb,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void (*write)(grpc_endpoint *ep, gpr_slice_buffer *slices, grpc_closure *cb,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void (*add_to_pollset)(grpc_endpoint *ep, grpc_pollset *pollset,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void (*add_to_pollset_set)(grpc_endpoint *ep, grpc_pollset_set *pollset,
- grpc_call_list *call_list);
- void (*shutdown)(grpc_endpoint *ep, grpc_call_list *call_list);
- void (*destroy)(grpc_endpoint *ep, grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
+ void (*shutdown)(grpc_endpoint *ep, grpc_closure_list *closure_list);
+ void (*destroy)(grpc_endpoint *ep, grpc_closure_list *closure_list);
char *(*get_peer)(grpc_endpoint *ep);
};
@@ -65,7 +65,7 @@ struct grpc_endpoint_vtable {
indicates the endpoint is closed.
Valid slices may be placed into \a slices even on callback success == 0. */
void grpc_endpoint_read(grpc_endpoint *ep, gpr_slice_buffer *slices,
- grpc_closure *cb, grpc_call_list *call_list);
+ grpc_closure *cb, grpc_closure_list *closure_list);
char *grpc_endpoint_get_peer(grpc_endpoint *ep);
@@ -80,20 +80,20 @@ char *grpc_endpoint_get_peer(grpc_endpoint *ep);
it is a valid slice buffer.
*/
void grpc_endpoint_write(grpc_endpoint *ep, gpr_slice_buffer *slices,
- grpc_closure *cb, grpc_call_list *call_list);
+ grpc_closure *cb, grpc_closure_list *closure_list);
/* Causes any pending read/write callbacks to run immediately with
success==0 */
-void grpc_endpoint_shutdown(grpc_endpoint *ep, grpc_call_list *call_list);
-void grpc_endpoint_destroy(grpc_endpoint *ep, grpc_call_list *call_list);
+void grpc_endpoint_shutdown(grpc_endpoint *ep, grpc_closure_list *closure_list);
+void grpc_endpoint_destroy(grpc_endpoint *ep, grpc_closure_list *closure_list);
/* Add an endpoint to a pollset, so that when the pollset is polled, events from
this endpoint are considered */
void grpc_endpoint_add_to_pollset(grpc_endpoint *ep, grpc_pollset *pollset,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void grpc_endpoint_add_to_pollset_set(grpc_endpoint *ep,
grpc_pollset_set *pollset_set,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
struct grpc_endpoint {
const grpc_endpoint_vtable *vtable;
diff --git a/src/core/iomgr/fd_posix.c b/src/core/iomgr/fd_posix.c
index 7c1db32553fcc0d222887bb784d8bf872cdcb602..5e455f32d77eac7f67f42c4b9a7225cfc2c21509 100644
--- a/src/core/iomgr/fd_posix.c
+++ b/src/core/iomgr/fd_posix.c
@@ -212,7 +212,7 @@ static int has_watchers(grpc_fd *fd) {
}
void grpc_fd_orphan(grpc_fd *fd, grpc_closure *on_done, const char *reason,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
fd->on_done_closure = on_done;
shutdown(fd->fd, SHUT_RDWR);
gpr_mu_lock(&fd->watcher_mu);
@@ -220,7 +220,7 @@ void grpc_fd_orphan(grpc_fd *fd, grpc_closure *on_done, const char *reason,
if (!has_watchers(fd)) {
fd->closed = 1;
close(fd->fd);
- grpc_call_list_add(call_list, fd->on_done_closure, 1);
+ grpc_closure_list_add(closure_list, fd->on_done_closure, 1);
} else {
wake_all_watchers_locked(fd);
}
@@ -245,7 +245,7 @@ void grpc_fd_unref(grpc_fd *fd) { unref_by(fd, 2); }
#endif
static void notify_on(grpc_fd *fd, gpr_atm *st, grpc_closure *closure,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
switch (gpr_atm_acq_load(st)) {
case NOT_READY:
/* There is no race if the descriptor is already ready, so we skip
@@ -267,7 +267,8 @@ static void notify_on(grpc_fd *fd, gpr_atm *st, grpc_closure *closure,
case READY:
GPR_ASSERT(gpr_atm_no_barrier_load(st) == READY);
gpr_atm_rel_store(st, NOT_READY);
- grpc_call_list_add(call_list, closure, !gpr_atm_acq_load(&fd->shutdown));
+ grpc_closure_list_add(closure_list, closure,
+ !gpr_atm_acq_load(&fd->shutdown));
return;
default: /* WAITING */
/* upcallptr was set to a different closure. This is an error! */
@@ -281,7 +282,7 @@ static void notify_on(grpc_fd *fd, gpr_atm *st, grpc_closure *closure,
}
static void set_ready_locked(grpc_fd *fd, gpr_atm *st,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
gpr_intptr state = gpr_atm_acq_load(st);
switch (state) {
@@ -300,38 +301,39 @@ static void set_ready_locked(grpc_fd *fd, gpr_atm *st,
default: /* waiting */
GPR_ASSERT(gpr_atm_no_barrier_load(st) != READY &&
gpr_atm_no_barrier_load(st) != NOT_READY);
- grpc_call_list_add(call_list, (grpc_closure *)state,
- !gpr_atm_acq_load(&fd->shutdown));
+ grpc_closure_list_add(closure_list, (grpc_closure *)state,
+ !gpr_atm_acq_load(&fd->shutdown));
gpr_atm_rel_store(st, NOT_READY);
return;
}
}
-static void set_ready(grpc_fd *fd, gpr_atm *st, grpc_call_list *call_list) {
+static void set_ready(grpc_fd *fd, gpr_atm *st,
+ grpc_closure_list *closure_list) {
/* only one set_ready can be active at once (but there may be a racing
notify_on) */
gpr_mu_lock(&fd->set_state_mu);
- set_ready_locked(fd, st, call_list);
+ set_ready_locked(fd, st, closure_list);
gpr_mu_unlock(&fd->set_state_mu);
}
-void grpc_fd_shutdown(grpc_fd *fd, grpc_call_list *call_list) {
+void grpc_fd_shutdown(grpc_fd *fd, grpc_closure_list *closure_list) {
gpr_mu_lock(&fd->set_state_mu);
GPR_ASSERT(!gpr_atm_no_barrier_load(&fd->shutdown));
gpr_atm_rel_store(&fd->shutdown, 1);
- set_ready_locked(fd, &fd->readst, call_list);
- set_ready_locked(fd, &fd->writest, call_list);
+ set_ready_locked(fd, &fd->readst, closure_list);
+ set_ready_locked(fd, &fd->writest, closure_list);
gpr_mu_unlock(&fd->set_state_mu);
}
void grpc_fd_notify_on_read(grpc_fd *fd, grpc_closure *closure,
- grpc_call_list *call_list) {
- notify_on(fd, &fd->readst, closure, call_list);
+ grpc_closure_list *closure_list) {
+ notify_on(fd, &fd->readst, closure, closure_list);
}
void grpc_fd_notify_on_write(grpc_fd *fd, grpc_closure *closure,
- grpc_call_list *call_list) {
- notify_on(fd, &fd->writest, closure, call_list);
+ grpc_closure_list *closure_list) {
+ notify_on(fd, &fd->writest, closure, closure_list);
}
gpr_uint32 grpc_fd_begin_poll(grpc_fd *fd, grpc_pollset *pollset,
@@ -378,7 +380,7 @@ gpr_uint32 grpc_fd_begin_poll(grpc_fd *fd, grpc_pollset *pollset,
}
void grpc_fd_end_poll(grpc_fd_watcher *watcher, int got_read, int got_write,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
int was_polling = 0;
int kick = 0;
grpc_fd *fd = watcher->fd;
@@ -411,19 +413,19 @@ void grpc_fd_end_poll(grpc_fd_watcher *watcher, int got_read, int got_write,
if (grpc_fd_is_orphaned(fd) && !has_watchers(fd) && !fd->closed) {
fd->closed = 1;
close(fd->fd);
- grpc_call_list_add(call_list, fd->on_done_closure, 1);
+ grpc_closure_list_add(closure_list, fd->on_done_closure, 1);
}
gpr_mu_unlock(&fd->watcher_mu);
GRPC_FD_UNREF(fd, "poll");
}
-void grpc_fd_become_readable(grpc_fd *fd, grpc_call_list *call_list) {
- set_ready(fd, &fd->readst, call_list);
+void grpc_fd_become_readable(grpc_fd *fd, grpc_closure_list *closure_list) {
+ set_ready(fd, &fd->readst, closure_list);
}
-void grpc_fd_become_writable(grpc_fd *fd, grpc_call_list *call_list) {
- set_ready(fd, &fd->writest, call_list);
+void grpc_fd_become_writable(grpc_fd *fd, grpc_closure_list *closure_list) {
+ set_ready(fd, &fd->writest, closure_list);
}
#endif
diff --git a/src/core/iomgr/fd_posix.h b/src/core/iomgr/fd_posix.h
index 607cba6181ae5ad4c5aece59ff1a34111fb63651..eab0daa00d5217081f7b3bb0fd6e167a98cfeeca 100644
--- a/src/core/iomgr/fd_posix.h
+++ b/src/core/iomgr/fd_posix.h
@@ -112,7 +112,7 @@ grpc_fd *grpc_fd_create(int fd, const char *name);
notify_on_write.
MUST NOT be called with a pollset lock taken */
void grpc_fd_orphan(grpc_fd *fd, grpc_closure *on_done, const char *reason,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Begin polling on an fd.
Registers that the given pollset is interested in this fd - so that if read
@@ -131,13 +131,13 @@ gpr_uint32 grpc_fd_begin_poll(grpc_fd *fd, grpc_pollset *pollset,
/* Complete polling previously started with grpc_fd_begin_poll
MUST NOT be called with a pollset lock taken */
void grpc_fd_end_poll(grpc_fd_watcher *rec, int got_read, int got_write,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Return 1 if this fd is orphaned, 0 otherwise */
int grpc_fd_is_orphaned(grpc_fd *fd);
/* Cause any current callbacks to error out with GRPC_CALLBACK_CANCELLED. */
-void grpc_fd_shutdown(grpc_fd *fd, grpc_call_list *call_list);
+void grpc_fd_shutdown(grpc_fd *fd, grpc_closure_list *closure_list);
/* Register read interest, causing read_cb to be called once when fd becomes
readable, on deadline specified by deadline, or on shutdown triggered by
@@ -153,18 +153,18 @@ void grpc_fd_shutdown(grpc_fd *fd, grpc_call_list *call_list);
calling notify_on_read again. Users are also expected to handle spurious
events, i.e read_cb is called while nothing can be readable from fd */
void grpc_fd_notify_on_read(grpc_fd *fd, grpc_closure *closure,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Exactly the same semantics as above, except based on writable events. */
void grpc_fd_notify_on_write(grpc_fd *fd, grpc_closure *closure,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Notification from the poller to an fd that it has become readable or
writable.
If allow_synchronous_callback is 1, allow running the fd callback inline
in this callstack, otherwise register an asynchronous callback and return */
-void grpc_fd_become_readable(grpc_fd *fd, grpc_call_list *call_list);
-void grpc_fd_become_writable(grpc_fd *fd, grpc_call_list *call_list);
+void grpc_fd_become_readable(grpc_fd *fd, grpc_closure_list *closure_list);
+void grpc_fd_become_writable(grpc_fd *fd, grpc_closure_list *closure_list);
/* Reference counting for fds */
#ifdef GRPC_FD_REF_COUNT_DEBUG
diff --git a/src/core/iomgr/iomgr.c b/src/core/iomgr/iomgr.c
index b2c17b1ef201a87397097f0dd38b8212238b10e8..9456bad7169f66d5338edcf9bea02bce03471442 100644
--- a/src/core/iomgr/iomgr.c
+++ b/src/core/iomgr/iomgr.c
@@ -88,7 +88,7 @@ void grpc_iomgr_shutdown(void) {
gpr_timespec shutdown_deadline = gpr_time_add(
gpr_now(GPR_CLOCK_REALTIME), gpr_time_from_seconds(10, GPR_TIMESPAN));
gpr_timespec last_warning_time = gpr_now(GPR_CLOCK_REALTIME);
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
gpr_mu_lock(&g_mu);
g_shutdown = 1;
@@ -103,9 +103,9 @@ void grpc_iomgr_shutdown(void) {
last_warning_time = gpr_now(GPR_CLOCK_REALTIME);
}
if (grpc_alarm_check(gpr_inf_future(GPR_CLOCK_MONOTONIC), NULL,
- &call_list)) {
+ &closure_list)) {
gpr_mu_unlock(&g_mu);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(&g_mu);
continue;
}
@@ -131,8 +131,8 @@ void grpc_iomgr_shutdown(void) {
}
gpr_mu_unlock(&g_mu);
- grpc_alarm_list_shutdown(&call_list);
- grpc_call_list_run(&call_list);
+ grpc_alarm_list_shutdown(&closure_list);
+ grpc_closure_list_run(&closure_list);
/* ensure all threads have left g_mu */
gpr_mu_lock(&g_mu);
@@ -168,36 +168,36 @@ void grpc_closure_init(grpc_closure *closure, grpc_iomgr_cb_func cb,
closure->next = NULL;
}
-void grpc_call_list_add(grpc_call_list *call_list, grpc_closure *closure,
- int success) {
+void grpc_closure_list_add(grpc_closure_list *closure_list,
+ grpc_closure *closure, int success) {
if (closure == NULL) return;
closure->next = NULL;
closure->success = success;
- if (call_list->head == NULL) {
- call_list->head = closure;
+ if (closure_list->head == NULL) {
+ closure_list->head = closure;
} else {
- call_list->tail->next = closure;
+ closure_list->tail->next = closure;
}
- call_list->tail = closure;
+ closure_list->tail = closure;
}
-void grpc_call_list_run(grpc_call_list *call_list) {
- while (!grpc_call_list_empty(*call_list)) {
- grpc_closure *c = call_list->head;
- call_list->head = call_list->tail = NULL;
+void grpc_closure_list_run(grpc_closure_list *closure_list) {
+ while (!grpc_closure_list_empty(*closure_list)) {
+ grpc_closure *c = closure_list->head;
+ closure_list->head = closure_list->tail = NULL;
while (c != NULL) {
grpc_closure *next = c->next;
- c->cb(c->cb_arg, c->success, call_list);
+ c->cb(c->cb_arg, c->success, closure_list);
c = next;
}
}
}
-int grpc_call_list_empty(grpc_call_list call_list) {
- return call_list.head == NULL;
+int grpc_closure_list_empty(grpc_closure_list closure_list) {
+ return closure_list.head == NULL;
}
-void grpc_call_list_move(grpc_call_list *src, grpc_call_list *dst) {
+void grpc_closure_list_move(grpc_closure_list *src, grpc_closure_list *dst) {
if (src->head == NULL) {
return;
}
diff --git a/src/core/iomgr/iomgr.h b/src/core/iomgr/iomgr.h
index 94f3912990c9d1fb667abb4ca7bef43f34903040..bc015706a3195a744f9a8e7fa44dbd2b06097775 100644
--- a/src/core/iomgr/iomgr.h
+++ b/src/core/iomgr/iomgr.h
@@ -37,10 +37,10 @@
struct grpc_closure;
typedef struct grpc_closure grpc_closure;
-typedef struct grpc_call_list {
+typedef struct grpc_closure_list {
grpc_closure *head;
grpc_closure *tail;
-} grpc_call_list;
+} grpc_closure_list;
/** gRPC Callback definition.
*
@@ -48,7 +48,7 @@ typedef struct grpc_call_list {
* \param success An indication on the state of the iomgr. On false, cleanup
* actions should be taken (eg, shutdown). */
typedef void (*grpc_iomgr_cb_func)(void *arg, int success,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** A closure over a grpc_iomgr_cb_func. */
struct grpc_closure {
@@ -71,14 +71,14 @@ struct grpc_closure {
void grpc_closure_init(grpc_closure *closure, grpc_iomgr_cb_func cb,
void *cb_arg);
-#define GRPC_CALL_LIST_INIT \
+#define GRPC_CLOSURE_LIST_INIT \
{ NULL, NULL }
-void grpc_call_list_add(grpc_call_list *list, grpc_closure *closure,
- int success);
-void grpc_call_list_run(grpc_call_list *list);
-void grpc_call_list_move(grpc_call_list *src, grpc_call_list *dst);
-int grpc_call_list_empty(grpc_call_list list);
+void grpc_closure_list_add(grpc_closure_list *list, grpc_closure *closure,
+ int success);
+void grpc_closure_list_run(grpc_closure_list *list);
+void grpc_closure_list_move(grpc_closure_list *src, grpc_closure_list *dst);
+int grpc_closure_list_empty(grpc_closure_list list);
/** Initializes the iomgr. */
void grpc_iomgr_init(void);
diff --git a/src/core/iomgr/pollset.h b/src/core/iomgr/pollset.h
index 95ba694ff6be0eca7eb95aa3a4411d09818affe1..b5d71bfb4ca488f6b34bc71426378c409a1158a5 100644
--- a/src/core/iomgr/pollset.h
+++ b/src/core/iomgr/pollset.h
@@ -56,7 +56,7 @@
void grpc_pollset_init(grpc_pollset *pollset);
void grpc_pollset_shutdown(grpc_pollset *pollset, grpc_closure *closure,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void grpc_pollset_destroy(grpc_pollset *pollset);
/* Do some work on a pollset.
@@ -74,11 +74,12 @@ void grpc_pollset_destroy(grpc_pollset *pollset);
not be released by grpc_pollset_work AFTER worker has been destroyed.
Tries not to block past deadline.
- May call grpc_call_list_run on grpc_call_list, without holding the pollset
+ May call grpc_closure_list_run on grpc_closure_list, without holding the
+ pollset
lock */
void grpc_pollset_work(grpc_pollset *pollset, grpc_pollset_worker *worker,
gpr_timespec now, gpr_timespec deadline,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Break one polling thread out of polling work for this pollset.
If specific_worker is GRPC_POLLSET_KICK_BROADCAST, kick ALL the workers.
diff --git a/src/core/iomgr/pollset_multipoller_with_epoll.c b/src/core/iomgr/pollset_multipoller_with_epoll.c
index e6e0f5cdd4a257e6c4ed9571f54ea4f764d9811a..a83086572e1336eadafd9c65fda30c3b723275dc 100644
--- a/src/core/iomgr/pollset_multipoller_with_epoll.c
+++ b/src/core/iomgr/pollset_multipoller_with_epoll.c
@@ -62,7 +62,7 @@ typedef struct {
} pollset_hdr;
static void finally_add_fd(grpc_pollset *pollset, grpc_fd *fd,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
pollset_hdr *h = pollset->data.ptr;
struct epoll_event ev;
int err;
@@ -84,15 +84,15 @@ static void finally_add_fd(grpc_pollset *pollset, grpc_fd *fd,
}
}
}
- grpc_fd_end_poll(&watcher, 0, 0, call_list);
+ grpc_fd_end_poll(&watcher, 0, 0, closure_list);
}
static void perform_delayed_add(void *arg, int iomgr_status,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
delayed_add *da = arg;
if (!grpc_fd_is_orphaned(da->fd)) {
- finally_add_fd(da->pollset, da->fd, call_list);
+ finally_add_fd(da->pollset, da->fd, closure_list);
}
gpr_mu_lock(&da->pollset->mu);
@@ -101,7 +101,7 @@ static void perform_delayed_add(void *arg, int iomgr_status,
/* We don't care about this pollset anymore. */
if (da->pollset->in_flight_cbs == 0 && !da->pollset->called_shutdown) {
da->pollset->called_shutdown = 1;
- grpc_call_list_add(call_list, da->pollset->shutdown_done, 1);
+ grpc_closure_list_add(closure_list, da->pollset->shutdown_done, 1);
}
}
gpr_mu_unlock(&da->pollset->mu);
@@ -111,13 +111,12 @@ static void perform_delayed_add(void *arg, int iomgr_status,
gpr_free(da);
}
-static void multipoll_with_epoll_pollset_add_fd(grpc_pollset *pollset,
- grpc_fd *fd,
- int and_unlock_pollset,
- grpc_call_list *call_list) {
+static void multipoll_with_epoll_pollset_add_fd(
+ grpc_pollset *pollset, grpc_fd *fd, int and_unlock_pollset,
+ grpc_closure_list *closure_list) {
if (and_unlock_pollset) {
gpr_mu_unlock(&pollset->mu);
- finally_add_fd(pollset, fd, call_list);
+ finally_add_fd(pollset, fd, closure_list);
} else {
delayed_add *da = gpr_malloc(sizeof(*da));
da->pollset = pollset;
@@ -125,14 +124,13 @@ static void multipoll_with_epoll_pollset_add_fd(grpc_pollset *pollset,
GRPC_FD_REF(fd, "delayed_add");
grpc_closure_init(&da->closure, perform_delayed_add, da);
pollset->in_flight_cbs++;
- grpc_call_list_add(call_list, &da->closure, 1);
+ grpc_closure_list_add(closure_list, &da->closure, 1);
}
}
-static void multipoll_with_epoll_pollset_del_fd(grpc_pollset *pollset,
- grpc_fd *fd,
- int and_unlock_pollset,
- grpc_call_list *call_list) {
+static void multipoll_with_epoll_pollset_del_fd(
+ grpc_pollset *pollset, grpc_fd *fd, int and_unlock_pollset,
+ grpc_closure_list *closure_list) {
pollset_hdr *h = pollset->data.ptr;
int err;
@@ -154,7 +152,7 @@ static void multipoll_with_epoll_pollset_del_fd(grpc_pollset *pollset,
static void multipoll_with_epoll_pollset_maybe_work_and_unlock(
grpc_pollset *pollset, grpc_pollset_worker *worker, gpr_timespec deadline,
- gpr_timespec now, grpc_call_list *call_list) {
+ gpr_timespec now, grpc_closure_list *closure_list) {
struct epoll_event ep_ev[GRPC_EPOLL_MAX_EVENTS];
int ep_rv;
int poll_rv;
@@ -208,10 +206,10 @@ static void multipoll_with_epoll_pollset_maybe_work_and_unlock(
int read = ep_ev[i].events & (EPOLLIN | EPOLLPRI);
int write = ep_ev[i].events & EPOLLOUT;
if (read || cancel) {
- grpc_fd_become_readable(fd, call_list);
+ grpc_fd_become_readable(fd, closure_list);
}
if (write || cancel) {
- grpc_fd_become_writable(fd, call_list);
+ grpc_fd_become_writable(fd, closure_list);
}
}
}
@@ -236,7 +234,8 @@ static const grpc_pollset_vtable multipoll_with_epoll_pollset = {
multipoll_with_epoll_pollset_destroy};
static void epoll_become_multipoller(grpc_pollset *pollset, grpc_fd **fds,
- size_t nfds, grpc_call_list *call_list) {
+ size_t nfds,
+ grpc_closure_list *closure_list) {
size_t i;
pollset_hdr *h = gpr_malloc(sizeof(pollset_hdr));
@@ -249,7 +248,7 @@ static void epoll_become_multipoller(grpc_pollset *pollset, grpc_fd **fds,
abort();
}
for (i = 0; i < nfds; i++) {
- multipoll_with_epoll_pollset_add_fd(pollset, fds[i], 0, call_list);
+ multipoll_with_epoll_pollset_add_fd(pollset, fds[i], 0, closure_list);
}
}
diff --git a/src/core/iomgr/pollset_multipoller_with_poll_posix.c b/src/core/iomgr/pollset_multipoller_with_poll_posix.c
index 03a28894f06a07f2df97254bcd99302052319398..a3aa7e69fac7dcf9c2d5d0467d8bf695478ae3f2 100644
--- a/src/core/iomgr/pollset_multipoller_with_poll_posix.c
+++ b/src/core/iomgr/pollset_multipoller_with_poll_posix.c
@@ -59,10 +59,9 @@ typedef struct {
grpc_fd **dels;
} pollset_hdr;
-static void multipoll_with_poll_pollset_add_fd(grpc_pollset *pollset,
- grpc_fd *fd,
- int and_unlock_pollset,
- grpc_call_list *call_list) {
+static void multipoll_with_poll_pollset_add_fd(
+ grpc_pollset *pollset, grpc_fd *fd, int and_unlock_pollset,
+ grpc_closure_list *closure_list) {
size_t i;
pollset_hdr *h = pollset->data.ptr;
/* TODO(ctiller): this is O(num_fds^2); maybe switch to a hash set here */
@@ -81,10 +80,9 @@ exit:
}
}
-static void multipoll_with_poll_pollset_del_fd(grpc_pollset *pollset,
- grpc_fd *fd,
- int and_unlock_pollset,
- grpc_call_list *call_list) {
+static void multipoll_with_poll_pollset_del_fd(
+ grpc_pollset *pollset, grpc_fd *fd, int and_unlock_pollset,
+ grpc_closure_list *closure_list) {
/* will get removed next poll cycle */
pollset_hdr *h = pollset->data.ptr;
if (h->del_count == h->del_capacity) {
@@ -100,7 +98,7 @@ static void multipoll_with_poll_pollset_del_fd(grpc_pollset *pollset,
static void multipoll_with_poll_pollset_maybe_work_and_unlock(
grpc_pollset *pollset, grpc_pollset_worker *worker, gpr_timespec deadline,
- gpr_timespec now, grpc_call_list *call_list) {
+ gpr_timespec now, grpc_closure_list *closure_list) {
int timeout;
int r;
size_t i, j, fd_count;
@@ -151,7 +149,7 @@ static void multipoll_with_poll_pollset_maybe_work_and_unlock(
for (i = 1; i < pfd_count; i++) {
grpc_fd_end_poll(&watchers[i], pfds[i].revents & POLLIN,
- pfds[i].revents & POLLOUT, call_list);
+ pfds[i].revents & POLLOUT, closure_list);
}
if (r < 0) {
@@ -169,10 +167,10 @@ static void multipoll_with_poll_pollset_maybe_work_and_unlock(
continue;
}
if (pfds[i].revents & (POLLIN | POLLHUP | POLLERR)) {
- grpc_fd_become_readable(watchers[i].fd, call_list);
+ grpc_fd_become_readable(watchers[i].fd, closure_list);
}
if (pfds[i].revents & (POLLOUT | POLLHUP | POLLERR)) {
- grpc_fd_become_writable(watchers[i].fd, call_list);
+ grpc_fd_become_writable(watchers[i].fd, closure_list);
}
}
}
@@ -209,7 +207,8 @@ static const grpc_pollset_vtable multipoll_with_poll_pollset = {
multipoll_with_poll_pollset_destroy};
void grpc_poll_become_multipoller(grpc_pollset *pollset, grpc_fd **fds,
- size_t nfds, grpc_call_list *call_list) {
+ size_t nfds,
+ grpc_closure_list *closure_list) {
size_t i;
pollset_hdr *h = gpr_malloc(sizeof(pollset_hdr));
pollset->vtable = &multipoll_with_poll_pollset;
diff --git a/src/core/iomgr/pollset_posix.c b/src/core/iomgr/pollset_posix.c
index daca2f6daa564424cb16c5025acaf816962500b6..82ef0298a23c62dc10f46af7df2756c00da8e70e 100644
--- a/src/core/iomgr/pollset_posix.c
+++ b/src/core/iomgr/pollset_posix.c
@@ -141,9 +141,9 @@ void grpc_pollset_init(grpc_pollset *pollset) {
}
void grpc_pollset_add_fd(grpc_pollset *pollset, grpc_fd *fd,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
gpr_mu_lock(&pollset->mu);
- pollset->vtable->add_fd(pollset, fd, 1, call_list);
+ pollset->vtable->add_fd(pollset, fd, 1, closure_list);
/* the following (enabled only in debug) will reacquire and then release
our lock - meaning that if the unlocking flag passed to del_fd above is
not respected, the code will deadlock (in a way that we have a chance of
@@ -155,9 +155,9 @@ void grpc_pollset_add_fd(grpc_pollset *pollset, grpc_fd *fd,
}
void grpc_pollset_del_fd(grpc_pollset *pollset, grpc_fd *fd,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
gpr_mu_lock(&pollset->mu);
- pollset->vtable->del_fd(pollset, fd, 1, call_list);
+ pollset->vtable->del_fd(pollset, fd, 1, closure_list);
/* the following (enabled only in debug) will reacquire and then release
our lock - meaning that if the unlocking flag passed to del_fd above is
not respected, the code will deadlock (in a way that we have a chance of
@@ -168,14 +168,15 @@ void grpc_pollset_del_fd(grpc_pollset *pollset, grpc_fd *fd,
#endif
}
-static void finish_shutdown(grpc_pollset *pollset, grpc_call_list *call_list) {
+static void finish_shutdown(grpc_pollset *pollset,
+ grpc_closure_list *closure_list) {
pollset->vtable->finish_shutdown(pollset);
- grpc_call_list_add(call_list, pollset->shutdown_done, 1);
+ grpc_closure_list_add(closure_list, pollset->shutdown_done, 1);
}
void grpc_pollset_work(grpc_pollset *pollset, grpc_pollset_worker *worker,
gpr_timespec now, gpr_timespec deadline,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
/* pollset->mu already held */
int added_worker = 0;
int locked = 1;
@@ -184,11 +185,11 @@ void grpc_pollset_work(grpc_pollset *pollset, grpc_pollset_worker *worker,
/* TODO(ctiller): pool these */
grpc_wakeup_fd_init(&worker->wakeup_fd);
if (!grpc_pollset_has_workers(pollset) &&
- !grpc_call_list_empty(pollset->idle_jobs)) {
- grpc_call_list_move(&pollset->idle_jobs, call_list);
+ !grpc_closure_list_empty(pollset->idle_jobs)) {
+ grpc_closure_list_move(&pollset->idle_jobs, closure_list);
goto done;
}
- if (grpc_alarm_check(now, &deadline, call_list)) {
+ if (grpc_alarm_check(now, &deadline, closure_list)) {
goto done;
}
if (pollset->shutting_down) {
@@ -205,7 +206,7 @@ void grpc_pollset_work(grpc_pollset *pollset, grpc_pollset_worker *worker,
added_worker = 1;
gpr_tls_set(&g_current_thread_poller, (gpr_intptr)pollset);
pollset->vtable->maybe_work_and_unlock(pollset, worker, deadline, now,
- call_list);
+ closure_list);
locked = 0;
gpr_tls_set(&g_current_thread_poller, 0);
} else {
@@ -213,7 +214,7 @@ void grpc_pollset_work(grpc_pollset *pollset, grpc_pollset_worker *worker,
}
done:
if (!locked) {
- grpc_call_list_run(call_list);
+ grpc_closure_list_run(closure_list);
gpr_mu_lock(&pollset->mu);
locked = 1;
}
@@ -227,8 +228,8 @@ done:
} else if (!pollset->called_shutdown && pollset->in_flight_cbs == 0) {
pollset->called_shutdown = 1;
gpr_mu_unlock(&pollset->mu);
- finish_shutdown(pollset, call_list);
- grpc_call_list_run(call_list);
+ finish_shutdown(pollset, closure_list);
+ grpc_closure_list_run(closure_list);
/* Continuing to access pollset here is safe -- it is the caller's
* responsibility to not destroy when it has outstanding calls to
* grpc_pollset_work.
@@ -239,7 +240,7 @@ done:
}
void grpc_pollset_shutdown(grpc_pollset *pollset, grpc_closure *closure,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
int call_shutdown = 0;
gpr_mu_lock(&pollset->mu);
GPR_ASSERT(!pollset->shutting_down);
@@ -254,7 +255,7 @@ void grpc_pollset_shutdown(grpc_pollset *pollset, grpc_closure *closure,
gpr_mu_unlock(&pollset->mu);
if (call_shutdown) {
- finish_shutdown(pollset, call_list);
+ finish_shutdown(pollset, closure_list);
}
}
@@ -296,7 +297,7 @@ typedef struct grpc_unary_promote_args {
} grpc_unary_promote_args;
static void basic_do_promote(void *args, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_unary_promote_args *up_args = args;
const grpc_pollset_vtable *original_vtable = up_args->original_vtable;
grpc_pollset *pollset = up_args->pollset;
@@ -327,12 +328,12 @@ static void basic_do_promote(void *args, int success,
if (pollset->in_flight_cbs == 0 && !pollset->called_shutdown) {
GPR_ASSERT(!grpc_pollset_has_workers(pollset));
pollset->called_shutdown = 1;
- grpc_call_list_add(call_list, pollset->shutdown_done, 1);
+ grpc_closure_list_add(closure_list, pollset->shutdown_done, 1);
}
} else if (grpc_fd_is_orphaned(fd)) {
/* Don't try to add it to anything, we'll drop our ref on it below */
} else if (pollset->vtable != original_vtable) {
- pollset->vtable->add_fd(pollset, fd, 0, call_list);
+ pollset->vtable->add_fd(pollset, fd, 0, closure_list);
} else if (fd != pollset->data.ptr) {
grpc_fd *fds[2];
fds[0] = pollset->data.ptr;
@@ -340,7 +341,7 @@ static void basic_do_promote(void *args, int success,
if (fds[0] && !grpc_fd_is_orphaned(fds[0])) {
grpc_platform_become_multipoller(pollset, fds, GPR_ARRAY_SIZE(fds),
- call_list);
+ closure_list);
GRPC_FD_UNREF(fds[0], "basicpoll");
} else {
/* old fd is orphaned and we haven't cleaned it up until now, so remain a
@@ -358,12 +359,12 @@ static void basic_do_promote(void *args, int success,
/* Matching ref in basic_pollset_add_fd */
GRPC_FD_UNREF(fd, "basicpoll_add");
- grpc_call_list_run(call_list);
+ grpc_closure_list_run(closure_list);
}
static void basic_pollset_add_fd(grpc_pollset *pollset, grpc_fd *fd,
int and_unlock_pollset,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_unary_promote_args *up_args;
GPR_ASSERT(fd);
if (fd == pollset->data.ptr) goto exit;
@@ -381,7 +382,7 @@ static void basic_pollset_add_fd(grpc_pollset *pollset, grpc_fd *fd,
GRPC_FD_REF(fd, "basicpoll");
} else if (!grpc_fd_is_orphaned(fds[0])) {
grpc_platform_become_multipoller(pollset, fds, GPR_ARRAY_SIZE(fds),
- call_list);
+ closure_list);
GRPC_FD_UNREF(fds[0], "basicpoll");
} else {
/* old fd is orphaned and we haven't cleaned it up until now, so remain a
@@ -404,7 +405,7 @@ static void basic_pollset_add_fd(grpc_pollset *pollset, grpc_fd *fd,
up_args->promotion_closure.cb = basic_do_promote;
up_args->promotion_closure.cb_arg = up_args;
- grpc_call_list_add(&pollset->idle_jobs, &up_args->promotion_closure, 1);
+ grpc_closure_list_add(&pollset->idle_jobs, &up_args->promotion_closure, 1);
grpc_pollset_kick(pollset, GRPC_POLLSET_KICK_BROADCAST);
exit:
@@ -415,7 +416,7 @@ exit:
static void basic_pollset_del_fd(grpc_pollset *pollset, grpc_fd *fd,
int and_unlock_pollset,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
GPR_ASSERT(fd);
if (fd == pollset->data.ptr) {
GRPC_FD_UNREF(pollset->data.ptr, "basicpoll");
@@ -427,11 +428,9 @@ static void basic_pollset_del_fd(grpc_pollset *pollset, grpc_fd *fd,
}
}
-static void basic_pollset_maybe_work_and_unlock(grpc_pollset *pollset,
- grpc_pollset_worker *worker,
- gpr_timespec deadline,
- gpr_timespec now,
- grpc_call_list *call_list) {
+static void basic_pollset_maybe_work_and_unlock(
+ grpc_pollset *pollset, grpc_pollset_worker *worker, gpr_timespec deadline,
+ gpr_timespec now, grpc_closure_list *closure_list) {
struct pollfd pfd[2];
grpc_fd *fd;
grpc_fd_watcher fd_watcher;
@@ -469,7 +468,7 @@ static void basic_pollset_maybe_work_and_unlock(grpc_pollset *pollset,
if (fd) {
grpc_fd_end_poll(&fd_watcher, pfd[1].revents & POLLIN,
- pfd[1].revents & POLLOUT, call_list);
+ pfd[1].revents & POLLOUT, closure_list);
}
if (r < 0) {
@@ -484,10 +483,10 @@ static void basic_pollset_maybe_work_and_unlock(grpc_pollset *pollset,
}
if (nfds > 1) {
if (pfd[1].revents & (POLLIN | POLLHUP | POLLERR)) {
- grpc_fd_become_readable(fd, call_list);
+ grpc_fd_become_readable(fd, closure_list);
}
if (pfd[1].revents & (POLLOUT | POLLHUP | POLLERR)) {
- grpc_fd_become_writable(fd, call_list);
+ grpc_fd_become_writable(fd, closure_list);
}
}
}
diff --git a/src/core/iomgr/pollset_posix.h b/src/core/iomgr/pollset_posix.h
index c65f25fd18ceef9557d7f8c312139aff25858c46..2f50cd22091b005758d57d21b87ff38fe86525f8 100644
--- a/src/core/iomgr/pollset_posix.h
+++ b/src/core/iomgr/pollset_posix.h
@@ -66,7 +66,7 @@ typedef struct grpc_pollset {
int called_shutdown;
int kicked_without_pollers;
grpc_closure *shutdown_done;
- grpc_call_list idle_jobs;
+ grpc_closure_list idle_jobs;
union {
int fd;
void *ptr;
@@ -75,13 +75,13 @@ typedef struct grpc_pollset {
struct grpc_pollset_vtable {
void (*add_fd)(grpc_pollset *pollset, struct grpc_fd *fd,
- int and_unlock_pollset, grpc_call_list *call_list);
+ int and_unlock_pollset, grpc_closure_list *closure_list);
void (*del_fd)(grpc_pollset *pollset, struct grpc_fd *fd,
- int and_unlock_pollset, grpc_call_list *call_list);
+ int and_unlock_pollset, grpc_closure_list *closure_list);
void (*maybe_work_and_unlock)(grpc_pollset *pollset,
grpc_pollset_worker *worker,
gpr_timespec deadline, gpr_timespec now,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void (*finish_shutdown)(grpc_pollset *pollset);
void (*destroy)(grpc_pollset *pollset);
};
@@ -90,11 +90,11 @@ struct grpc_pollset_vtable {
/* Add an fd to a pollset */
void grpc_pollset_add_fd(grpc_pollset *pollset, struct grpc_fd *fd,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Force remove an fd from a pollset (normally they are removed on the next
poll after an fd is orphaned) */
void grpc_pollset_del_fd(grpc_pollset *pollset, struct grpc_fd *fd,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Returns the fd to listen on for kicks */
int grpc_kick_read_fd(grpc_pollset *p);
@@ -114,11 +114,12 @@ int grpc_poll_deadline_to_millis_timeout(gpr_timespec deadline,
/* turn a pollset into a multipoller: platform specific */
typedef void (*grpc_platform_become_multipoller_type)(
grpc_pollset *pollset, struct grpc_fd **fds, size_t fd_count,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
extern grpc_platform_become_multipoller_type grpc_platform_become_multipoller;
void grpc_poll_become_multipoller(grpc_pollset *pollset, struct grpc_fd **fds,
- size_t fd_count, grpc_call_list *call_list);
+ size_t fd_count,
+ grpc_closure_list *closure_list);
/* Return 1 if the pollset has active threads in grpc_pollset_work (pollset must
* be locked) */
diff --git a/src/core/iomgr/pollset_set.h b/src/core/iomgr/pollset_set.h
index ca667bf34e591de7338206d265e2a7e55c7e08fa..5b5b20ef66ae62565d8182c159db89dfe06ec523 100644
--- a/src/core/iomgr/pollset_set.h
+++ b/src/core/iomgr/pollset_set.h
@@ -53,9 +53,9 @@ void grpc_pollset_set_init(grpc_pollset_set *pollset_set);
void grpc_pollset_set_destroy(grpc_pollset_set *pollset_set);
void grpc_pollset_set_add_pollset(grpc_pollset_set *pollset_set,
grpc_pollset *pollset,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void grpc_pollset_set_del_pollset(grpc_pollset_set *pollset_set,
grpc_pollset *pollset,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_IOMGR_POLLSET_H */
diff --git a/src/core/iomgr/pollset_set_posix.c b/src/core/iomgr/pollset_set_posix.c
index a2c1f47629770373261c6b6ae0e901ddf8c57096..810543cc2e13f0fae5f492bb8c1277b97f1a02b7 100644
--- a/src/core/iomgr/pollset_set_posix.c
+++ b/src/core/iomgr/pollset_set_posix.c
@@ -60,7 +60,7 @@ void grpc_pollset_set_destroy(grpc_pollset_set *pollset_set) {
void grpc_pollset_set_add_pollset(grpc_pollset_set *pollset_set,
grpc_pollset *pollset,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t i, j;
gpr_mu_lock(&pollset_set->mu);
if (pollset_set->pollset_count == pollset_set->pollset_capacity) {
@@ -75,7 +75,7 @@ void grpc_pollset_set_add_pollset(grpc_pollset_set *pollset_set,
if (grpc_fd_is_orphaned(pollset_set->fds[i])) {
GRPC_FD_UNREF(pollset_set->fds[i], "pollset");
} else {
- grpc_pollset_add_fd(pollset, pollset_set->fds[i], call_list);
+ grpc_pollset_add_fd(pollset, pollset_set->fds[i], closure_list);
pollset_set->fds[j++] = pollset_set->fds[i];
}
}
@@ -85,7 +85,7 @@ void grpc_pollset_set_add_pollset(grpc_pollset_set *pollset_set,
void grpc_pollset_set_del_pollset(grpc_pollset_set *pollset_set,
grpc_pollset *pollset,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t i;
gpr_mu_lock(&pollset_set->mu);
for (i = 0; i < pollset_set->pollset_count; i++) {
@@ -100,7 +100,7 @@ void grpc_pollset_set_del_pollset(grpc_pollset_set *pollset_set,
}
void grpc_pollset_set_add_fd(grpc_pollset_set *pollset_set, grpc_fd *fd,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t i;
gpr_mu_lock(&pollset_set->mu);
if (pollset_set->fd_count == pollset_set->fd_capacity) {
@@ -111,13 +111,13 @@ void grpc_pollset_set_add_fd(grpc_pollset_set *pollset_set, grpc_fd *fd,
GRPC_FD_REF(fd, "pollset_set");
pollset_set->fds[pollset_set->fd_count++] = fd;
for (i = 0; i < pollset_set->pollset_count; i++) {
- grpc_pollset_add_fd(pollset_set->pollsets[i], fd, call_list);
+ grpc_pollset_add_fd(pollset_set->pollsets[i], fd, closure_list);
}
gpr_mu_unlock(&pollset_set->mu);
}
void grpc_pollset_set_del_fd(grpc_pollset_set *pollset_set, grpc_fd *fd,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t i;
gpr_mu_lock(&pollset_set->mu);
for (i = 0; i < pollset_set->fd_count; i++) {
diff --git a/src/core/iomgr/pollset_set_posix.h b/src/core/iomgr/pollset_set_posix.h
index e9969d2c0f5c273c94bb35848e69b712e8deeae5..40d7a9b259be4234ca11cf52772e61efadc53aed 100644
--- a/src/core/iomgr/pollset_set_posix.h
+++ b/src/core/iomgr/pollset_set_posix.h
@@ -50,8 +50,8 @@ typedef struct grpc_pollset_set {
} grpc_pollset_set;
void grpc_pollset_set_add_fd(grpc_pollset_set *pollset_set, grpc_fd *fd,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void grpc_pollset_set_del_fd(grpc_pollset_set *pollset_set, grpc_fd *fd,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_IOMGR_POLLSET_WINDOWS_H */
diff --git a/src/core/iomgr/resolve_address.h b/src/core/iomgr/resolve_address.h
index 72b9c1cc87ecd48960806830b8ee23fa79aac4e7..174432225e7ce51b5be3d28eb3665b83253cf9fa 100644
--- a/src/core/iomgr/resolve_address.h
+++ b/src/core/iomgr/resolve_address.h
@@ -54,7 +54,7 @@ typedef struct {
grpc_resolved_addresses_destroy when it's done with them
On failure: addresses is NULL */
typedef void (*grpc_resolve_cb)(void *arg, grpc_resolved_addresses *addresses,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Asynchronously resolve addr. Use default_port if a port isn't designated
in addr, otherwise use the port in addr. */
/* TODO(ctiller): add a timeout here */
diff --git a/src/core/iomgr/resolve_address_posix.c b/src/core/iomgr/resolve_address_posix.c
index ea64f8176fc531d01e97020da5690c3c57b338ed..f0a230bab2e742fcee8af19020250727cd090e21 100644
--- a/src/core/iomgr/resolve_address_posix.c
+++ b/src/core/iomgr/resolve_address_posix.c
@@ -146,17 +146,17 @@ done:
/* Thread function to asynch-ify grpc_blocking_resolve_address */
static void do_request_thread(void *rp) {
request *r = rp;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_resolved_addresses *resolved =
grpc_blocking_resolve_address(r->name, r->default_port);
void *arg = r->arg;
grpc_resolve_cb cb = r->cb;
gpr_free(r->name);
gpr_free(r->default_port);
- cb(arg, resolved, &call_list);
+ cb(arg, resolved, &closure_list);
grpc_iomgr_unregister_object(&r->iomgr_object);
gpr_free(r);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
void grpc_resolved_addresses_destroy(grpc_resolved_addresses *addrs) {
diff --git a/src/core/iomgr/tcp_client.h b/src/core/iomgr/tcp_client.h
index 8fb5bfda1da8dbae09323db9344d5b3cb5460305..971e984e54095ffa8ce8fd2e4ce5256d24f0a413 100644
--- a/src/core/iomgr/tcp_client.h
+++ b/src/core/iomgr/tcp_client.h
@@ -47,6 +47,7 @@
void grpc_tcp_client_connect(grpc_closure *on_connect, grpc_endpoint **endpoint,
grpc_pollset_set *interested_parties,
const struct sockaddr *addr, size_t addr_len,
- gpr_timespec deadline, grpc_call_list *call_list);
+ gpr_timespec deadline,
+ grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_IOMGR_TCP_CLIENT_H */
diff --git a/src/core/iomgr/tcp_client_posix.c b/src/core/iomgr/tcp_client_posix.c
index fed832fce610f31c141ef48cc74d1aa157af0e29..e23551c4c0c4372d3f2bb744b74b1cb9403398c2 100644
--- a/src/core/iomgr/tcp_client_posix.c
+++ b/src/core/iomgr/tcp_client_posix.c
@@ -91,7 +91,8 @@ error:
return 0;
}
-static void tc_on_alarm(void *acp, int success, grpc_call_list *call_list) {
+static void tc_on_alarm(void *acp, int success,
+ grpc_closure_list *closure_list) {
int done;
async_connect *ac = acp;
if (grpc_tcp_trace) {
@@ -100,7 +101,7 @@ static void tc_on_alarm(void *acp, int success, grpc_call_list *call_list) {
}
gpr_mu_lock(&ac->mu);
if (ac->fd != NULL) {
- grpc_fd_shutdown(ac->fd, call_list);
+ grpc_fd_shutdown(ac->fd, closure_list);
}
done = (--ac->refs == 0);
gpr_mu_unlock(&ac->mu);
@@ -111,7 +112,8 @@ static void tc_on_alarm(void *acp, int success, grpc_call_list *call_list) {
}
}
-static void on_writable(void *acp, int success, grpc_call_list *call_list) {
+static void on_writable(void *acp, int success,
+ grpc_closure_list *closure_list) {
async_connect *ac = acp;
int so_error = 0;
socklen_t so_error_size;
@@ -132,7 +134,7 @@ static void on_writable(void *acp, int success, grpc_call_list *call_list) {
ac->fd = NULL;
gpr_mu_unlock(&ac->mu);
- grpc_alarm_cancel(&ac->alarm, call_list);
+ grpc_alarm_cancel(&ac->alarm, closure_list);
gpr_mu_lock(&ac->mu);
if (success) {
@@ -161,7 +163,7 @@ static void on_writable(void *acp, int success, grpc_call_list *call_list) {
don't do that! */
gpr_log(GPR_ERROR, "kernel out of buffers");
gpr_mu_unlock(&ac->mu);
- grpc_fd_notify_on_write(fd, &ac->write_closure, call_list);
+ grpc_fd_notify_on_write(fd, &ac->write_closure, closure_list);
return;
} else {
switch (so_error) {
@@ -175,7 +177,7 @@ static void on_writable(void *acp, int success, grpc_call_list *call_list) {
goto finish;
}
} else {
- grpc_pollset_set_del_fd(ac->interested_parties, fd, call_list);
+ grpc_pollset_set_del_fd(ac->interested_parties, fd, closure_list);
*ep = grpc_tcp_create(fd, GRPC_TCP_DEFAULT_READ_SLICE_SIZE, ac->addr_str);
fd = NULL;
goto finish;
@@ -189,8 +191,8 @@ static void on_writable(void *acp, int success, grpc_call_list *call_list) {
finish:
if (fd != NULL) {
- grpc_pollset_set_del_fd(ac->interested_parties, fd, call_list);
- grpc_fd_orphan(fd, NULL, "tcp_client_orphan", call_list);
+ grpc_pollset_set_del_fd(ac->interested_parties, fd, closure_list);
+ grpc_fd_orphan(fd, NULL, "tcp_client_orphan", closure_list);
fd = NULL;
}
done = (--ac->refs == 0);
@@ -200,13 +202,14 @@ finish:
gpr_free(ac->addr_str);
gpr_free(ac);
}
- grpc_call_list_add(call_list, closure, *ep != NULL);
+ grpc_closure_list_add(closure_list, closure, *ep != NULL);
}
void grpc_tcp_client_connect(grpc_closure *closure, grpc_endpoint **ep,
grpc_pollset_set *interested_parties,
const struct sockaddr *addr, size_t addr_len,
- gpr_timespec deadline, grpc_call_list *call_list) {
+ gpr_timespec deadline,
+ grpc_closure_list *closure_list) {
int fd;
grpc_dualstack_mode dsmode;
int err;
@@ -236,7 +239,7 @@ void grpc_tcp_client_connect(grpc_closure *closure, grpc_endpoint **ep,
addr_len = sizeof(addr4_copy);
}
if (!prepare_socket(addr, fd)) {
- grpc_call_list_add(call_list, closure, 0);
+ grpc_closure_list_add(closure_list, closure, 0);
return;
}
@@ -252,18 +255,18 @@ void grpc_tcp_client_connect(grpc_closure *closure, grpc_endpoint **ep,
if (err >= 0) {
*ep = grpc_tcp_create(fdobj, GRPC_TCP_DEFAULT_READ_SLICE_SIZE, addr_str);
- grpc_call_list_add(call_list, closure, 1);
+ grpc_closure_list_add(closure_list, closure, 1);
goto done;
}
if (errno != EWOULDBLOCK && errno != EINPROGRESS) {
gpr_log(GPR_ERROR, "connect error to '%s': %s", addr_str, strerror(errno));
- grpc_fd_orphan(fdobj, NULL, "tcp_client_connect_error", call_list);
- grpc_call_list_add(call_list, closure, 0);
+ grpc_fd_orphan(fdobj, NULL, "tcp_client_connect_error", closure_list);
+ grpc_closure_list_add(closure_list, closure, 0);
goto done;
}
- grpc_pollset_set_add_fd(interested_parties, fdobj, call_list);
+ grpc_pollset_set_add_fd(interested_parties, fdobj, closure_list);
ac = gpr_malloc(sizeof(async_connect));
ac->closure = closure;
@@ -285,8 +288,8 @@ void grpc_tcp_client_connect(grpc_closure *closure, grpc_endpoint **ep,
gpr_mu_lock(&ac->mu);
grpc_alarm_init(&ac->alarm,
gpr_convert_clock_type(deadline, GPR_CLOCK_MONOTONIC),
- tc_on_alarm, ac, gpr_now(GPR_CLOCK_MONOTONIC), call_list);
- grpc_fd_notify_on_write(ac->fd, &ac->write_closure, call_list);
+ tc_on_alarm, ac, gpr_now(GPR_CLOCK_MONOTONIC), closure_list);
+ grpc_fd_notify_on_write(ac->fd, &ac->write_closure, closure_list);
gpr_mu_unlock(&ac->mu);
done:
diff --git a/src/core/iomgr/tcp_posix.c b/src/core/iomgr/tcp_posix.c
index 89a85f26dc949f1c4b73934aefc0dc5c1894996e..942ab8b71df8bfb3f3c4676f7c00900d2ad77dcc 100644
--- a/src/core/iomgr/tcp_posix.c
+++ b/src/core/iomgr/tcp_posix.c
@@ -95,17 +95,17 @@ typedef struct {
} grpc_tcp;
static void tcp_handle_read(void *arg /* grpc_tcp */, int success,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
static void tcp_handle_write(void *arg /* grpc_tcp */, int success,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
-static void tcp_shutdown(grpc_endpoint *ep, grpc_call_list *call_list) {
+static void tcp_shutdown(grpc_endpoint *ep, grpc_closure_list *closure_list) {
grpc_tcp *tcp = (grpc_tcp *)ep;
- grpc_fd_shutdown(tcp->em_fd, call_list);
+ grpc_fd_shutdown(tcp->em_fd, closure_list);
}
-static void tcp_free(grpc_tcp *tcp, grpc_call_list *call_list) {
- grpc_fd_orphan(tcp->em_fd, NULL, "tcp_unref_orphan", call_list);
+static void tcp_free(grpc_tcp *tcp, grpc_closure_list *closure_list) {
+ grpc_fd_orphan(tcp->em_fd, NULL, "tcp_unref_orphan", closure_list);
gpr_free(tcp->peer_string);
gpr_free(tcp);
}
@@ -115,12 +115,12 @@ static void tcp_free(grpc_tcp *tcp, grpc_call_list *call_list) {
#define TCP_UNREF(tcp, reason, cl) \
tcp_unref((tcp), (cl), (reason), __FILE__, __LINE__)
#define TCP_REF(tcp, reason) tcp_ref((tcp), (reason), __FILE__, __LINE__)
-static void tcp_unref(grpc_tcp *tcp, grpc_call_list *call_list,
+static void tcp_unref(grpc_tcp *tcp, grpc_closure_list *closure_list,
const char *reason, const char *file, int line) {
gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "TCP unref %p : %s %d -> %d", tcp,
reason, tcp->refcount.count, tcp->refcount.count - 1);
if (gpr_unref(&tcp->refcount)) {
- tcp_free(tcp, call_list);
+ tcp_free(tcp, closure_list);
}
}
@@ -133,22 +133,22 @@ static void tcp_ref(grpc_tcp *tcp, const char *reason, const char *file,
#else
#define TCP_UNREF(tcp, reason, cl) tcp_unref((tcp), (cl))
#define TCP_REF(tcp, reason) tcp_ref((tcp))
-static void tcp_unref(grpc_tcp *tcp, grpc_call_list *call_list) {
+static void tcp_unref(grpc_tcp *tcp, grpc_closure_list *closure_list) {
if (gpr_unref(&tcp->refcount)) {
- tcp_free(tcp, call_list);
+ tcp_free(tcp, closure_list);
}
}
static void tcp_ref(grpc_tcp *tcp) { gpr_ref(&tcp->refcount); }
#endif
-static void tcp_destroy(grpc_endpoint *ep, grpc_call_list *call_list) {
+static void tcp_destroy(grpc_endpoint *ep, grpc_closure_list *closure_list) {
grpc_tcp *tcp = (grpc_tcp *)ep;
- TCP_UNREF(tcp, "destroy", call_list);
+ TCP_UNREF(tcp, "destroy", closure_list);
}
static void call_read_cb(grpc_tcp *tcp, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_closure *cb = tcp->read_cb;
if (grpc_tcp_trace) {
@@ -164,11 +164,11 @@ static void call_read_cb(grpc_tcp *tcp, int success,
tcp->read_cb = NULL;
tcp->incoming_buffer = NULL;
- cb->cb(cb->cb_arg, success, call_list);
+ cb->cb(cb->cb_arg, success, closure_list);
}
#define MAX_READ_IOVEC 4
-static void tcp_continue_read(grpc_tcp *tcp, grpc_call_list *call_list) {
+static void tcp_continue_read(grpc_tcp *tcp, grpc_closure_list *closure_list) {
struct msghdr msg;
struct iovec iov[MAX_READ_IOVEC];
ssize_t read_bytes;
@@ -210,18 +210,18 @@ static void tcp_continue_read(grpc_tcp *tcp, grpc_call_list *call_list) {
tcp->iov_size /= 2;
}
/* We've consumed the edge, request a new one */
- grpc_fd_notify_on_read(tcp->em_fd, &tcp->read_closure, call_list);
+ grpc_fd_notify_on_read(tcp->em_fd, &tcp->read_closure, closure_list);
} else {
/* TODO(klempner): Log interesting errors */
gpr_slice_buffer_reset_and_unref(tcp->incoming_buffer);
- call_read_cb(tcp, 0, call_list);
- TCP_UNREF(tcp, "read", call_list);
+ call_read_cb(tcp, 0, closure_list);
+ TCP_UNREF(tcp, "read", closure_list);
}
} else if (read_bytes == 0) {
/* 0 read size ==> end of stream */
gpr_slice_buffer_reset_and_unref(tcp->incoming_buffer);
- call_read_cb(tcp, 0, call_list);
- TCP_UNREF(tcp, "read", call_list);
+ call_read_cb(tcp, 0, closure_list);
+ TCP_UNREF(tcp, "read", closure_list);
} else {
GPR_ASSERT((size_t)read_bytes <= tcp->incoming_buffer->length);
if ((size_t)read_bytes < tcp->incoming_buffer->length) {
@@ -232,29 +232,29 @@ static void tcp_continue_read(grpc_tcp *tcp, grpc_call_list *call_list) {
++tcp->iov_size;
}
GPR_ASSERT((size_t)read_bytes == tcp->incoming_buffer->length);
- call_read_cb(tcp, 1, call_list);
- TCP_UNREF(tcp, "read", call_list);
+ call_read_cb(tcp, 1, closure_list);
+ TCP_UNREF(tcp, "read", closure_list);
}
GRPC_TIMER_END(GRPC_PTAG_HANDLE_READ, 0);
}
static void tcp_handle_read(void *arg /* grpc_tcp */, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_tcp *tcp = (grpc_tcp *)arg;
GPR_ASSERT(!tcp->finished_edge);
if (!success) {
gpr_slice_buffer_reset_and_unref(tcp->incoming_buffer);
- call_read_cb(tcp, 0, call_list);
- TCP_UNREF(tcp, "read", call_list);
+ call_read_cb(tcp, 0, closure_list);
+ TCP_UNREF(tcp, "read", closure_list);
} else {
- tcp_continue_read(tcp, call_list);
+ tcp_continue_read(tcp, closure_list);
}
}
static void tcp_read(grpc_endpoint *ep, gpr_slice_buffer *incoming_buffer,
- grpc_closure *cb, grpc_call_list *call_list) {
+ grpc_closure *cb, grpc_closure_list *closure_list) {
grpc_tcp *tcp = (grpc_tcp *)ep;
GPR_ASSERT(tcp->read_cb == NULL);
tcp->read_cb = cb;
@@ -263,9 +263,9 @@ static void tcp_read(grpc_endpoint *ep, gpr_slice_buffer *incoming_buffer,
TCP_REF(tcp, "read");
if (tcp->finished_edge) {
tcp->finished_edge = 0;
- grpc_fd_notify_on_read(tcp->em_fd, &tcp->read_closure, call_list);
+ grpc_fd_notify_on_read(tcp->em_fd, &tcp->read_closure, closure_list);
} else {
- grpc_call_list_add(call_list, &tcp->read_closure, 1);
+ grpc_closure_list_add(closure_list, &tcp->read_closure, 1);
}
}
@@ -352,7 +352,7 @@ static flush_result tcp_flush(grpc_tcp *tcp) {
}
static void tcp_handle_write(void *arg /* grpc_tcp */, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_tcp *tcp = (grpc_tcp *)arg;
flush_result status;
grpc_closure *cb;
@@ -360,26 +360,26 @@ static void tcp_handle_write(void *arg /* grpc_tcp */, int success,
if (!success) {
cb = tcp->write_cb;
tcp->write_cb = NULL;
- cb->cb(cb->cb_arg, 0, call_list);
- TCP_UNREF(tcp, "write", call_list);
+ cb->cb(cb->cb_arg, 0, closure_list);
+ TCP_UNREF(tcp, "write", closure_list);
return;
}
GRPC_TIMER_BEGIN(GRPC_PTAG_TCP_CB_WRITE, 0);
status = tcp_flush(tcp);
if (status == FLUSH_PENDING) {
- grpc_fd_notify_on_write(tcp->em_fd, &tcp->write_closure, call_list);
+ grpc_fd_notify_on_write(tcp->em_fd, &tcp->write_closure, closure_list);
} else {
cb = tcp->write_cb;
tcp->write_cb = NULL;
- cb->cb(cb->cb_arg, status == FLUSH_DONE, call_list);
- TCP_UNREF(tcp, "write", call_list);
+ cb->cb(cb->cb_arg, status == FLUSH_DONE, closure_list);
+ TCP_UNREF(tcp, "write", closure_list);
}
GRPC_TIMER_END(GRPC_PTAG_TCP_CB_WRITE, 0);
}
static void tcp_write(grpc_endpoint *ep, gpr_slice_buffer *buf,
- grpc_closure *cb, grpc_call_list *call_list) {
+ grpc_closure *cb, grpc_closure_list *closure_list) {
grpc_tcp *tcp = (grpc_tcp *)ep;
flush_result status;
@@ -399,7 +399,7 @@ static void tcp_write(grpc_endpoint *ep, gpr_slice_buffer *buf,
if (buf->length == 0) {
GRPC_TIMER_END(GRPC_PTAG_TCP_WRITE, 0);
- grpc_call_list_add(call_list, cb, 1);
+ grpc_closure_list_add(closure_list, cb, 1);
return;
}
tcp->outgoing_buffer = buf;
@@ -410,25 +410,25 @@ static void tcp_write(grpc_endpoint *ep, gpr_slice_buffer *buf,
if (status == FLUSH_PENDING) {
TCP_REF(tcp, "write");
tcp->write_cb = cb;
- grpc_fd_notify_on_write(tcp->em_fd, &tcp->write_closure, call_list);
+ grpc_fd_notify_on_write(tcp->em_fd, &tcp->write_closure, closure_list);
} else {
- grpc_call_list_add(call_list, cb, status == FLUSH_DONE);
+ grpc_closure_list_add(closure_list, cb, status == FLUSH_DONE);
}
GRPC_TIMER_END(GRPC_PTAG_TCP_WRITE, 0);
}
static void tcp_add_to_pollset(grpc_endpoint *ep, grpc_pollset *pollset,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_tcp *tcp = (grpc_tcp *)ep;
- grpc_pollset_add_fd(pollset, tcp->em_fd, call_list);
+ grpc_pollset_add_fd(pollset, tcp->em_fd, closure_list);
}
static void tcp_add_to_pollset_set(grpc_endpoint *ep,
grpc_pollset_set *pollset_set,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_tcp *tcp = (grpc_tcp *)ep;
- grpc_pollset_set_add_fd(pollset_set, tcp->em_fd, call_list);
+ grpc_pollset_set_add_fd(pollset_set, tcp->em_fd, closure_list);
}
static char *tcp_get_peer(grpc_endpoint *ep) {
diff --git a/src/core/iomgr/tcp_server.h b/src/core/iomgr/tcp_server.h
index b2aab234d33f2e6db6e95f9eff9aeafd1dc571a1..034f10eff70c400e72e75b6b2147bdca07089906 100644
--- a/src/core/iomgr/tcp_server.h
+++ b/src/core/iomgr/tcp_server.h
@@ -41,7 +41,7 @@ typedef struct grpc_tcp_server grpc_tcp_server;
/* Called for newly connected TCP connections. */
typedef void (*grpc_tcp_server_cb)(void *arg, grpc_endpoint *ep,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Create a server, initially not bound to any ports */
grpc_tcp_server *grpc_tcp_server_create(void);
@@ -50,7 +50,7 @@ grpc_tcp_server *grpc_tcp_server_create(void);
void grpc_tcp_server_start(grpc_tcp_server *server, grpc_pollset **pollsets,
size_t pollset_count,
grpc_tcp_server_cb on_accept_cb, void *cb_arg,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Add a port to the server, returning port number on success, or negative
on failure.
@@ -74,6 +74,6 @@ int grpc_tcp_server_add_port(grpc_tcp_server *s, const void *addr,
int grpc_tcp_server_get_fd(grpc_tcp_server *s, unsigned index);
void grpc_tcp_server_destroy(grpc_tcp_server *server, grpc_closure *closure,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_IOMGR_TCP_SERVER_H */
diff --git a/src/core/iomgr/tcp_server_posix.c b/src/core/iomgr/tcp_server_posix.c
index 635fdeb198ff814ae2254e4da1e717c9bfde7172..e6c6a36602a61ea6665ad4d414c6f121b2231141 100644
--- a/src/core/iomgr/tcp_server_posix.c
+++ b/src/core/iomgr/tcp_server_posix.c
@@ -140,8 +140,9 @@ grpc_tcp_server *grpc_tcp_server_create(void) {
return s;
}
-static void finish_shutdown(grpc_tcp_server *s, grpc_call_list *call_list) {
- grpc_call_list_add(call_list, s->shutdown_complete, 1);
+static void finish_shutdown(grpc_tcp_server *s,
+ grpc_closure_list *closure_list) {
+ grpc_closure_list_add(closure_list, s->shutdown_complete, 1);
gpr_mu_destroy(&s->mu);
@@ -150,13 +151,13 @@ static void finish_shutdown(grpc_tcp_server *s, grpc_call_list *call_list) {
}
static void destroyed_port(void *server, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_tcp_server *s = server;
gpr_mu_lock(&s->mu);
s->destroyed_ports++;
if (s->destroyed_ports == s->nports) {
gpr_mu_unlock(&s->mu);
- finish_shutdown(s, call_list);
+ finish_shutdown(s, closure_list);
} else {
GPR_ASSERT(s->destroyed_ports < s->nports);
gpr_mu_unlock(&s->mu);
@@ -167,7 +168,7 @@ static void destroyed_port(void *server, int success,
events will be received on them - at this point it's safe to destroy
things */
static void deactivated_all_ports(grpc_tcp_server *s,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t i;
/* delete ALL the things */
@@ -187,17 +188,17 @@ static void deactivated_all_ports(grpc_tcp_server *s,
sp->destroyed_closure.cb = destroyed_port;
sp->destroyed_closure.cb_arg = s;
grpc_fd_orphan(sp->emfd, &sp->destroyed_closure, "tcp_listener_shutdown",
- call_list);
+ closure_list);
}
gpr_mu_unlock(&s->mu);
} else {
gpr_mu_unlock(&s->mu);
- finish_shutdown(s, call_list);
+ finish_shutdown(s, closure_list);
}
}
void grpc_tcp_server_destroy(grpc_tcp_server *s, grpc_closure *closure,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t i;
gpr_mu_lock(&s->mu);
@@ -209,12 +210,12 @@ void grpc_tcp_server_destroy(grpc_tcp_server *s, grpc_closure *closure,
/* shutdown all fd's */
if (s->active_ports) {
for (i = 0; i < s->nports; i++) {
- grpc_fd_shutdown(s->ports[i].emfd, call_list);
+ grpc_fd_shutdown(s->ports[i].emfd, closure_list);
}
gpr_mu_unlock(&s->mu);
} else {
gpr_mu_unlock(&s->mu);
- deactivated_all_ports(s, call_list);
+ deactivated_all_ports(s, closure_list);
}
}
@@ -299,7 +300,7 @@ error:
}
/* event manager callback when reads are ready */
-static void on_read(void *arg, int success, grpc_call_list *call_list) {
+static void on_read(void *arg, int success, grpc_closure_list *closure_list) {
server_port *sp = arg;
grpc_fd *fdobj;
size_t i;
@@ -322,7 +323,7 @@ static void on_read(void *arg, int success, grpc_call_list *call_list) {
case EINTR:
continue;
case EAGAIN:
- grpc_fd_notify_on_read(sp->emfd, &sp->read_closure, call_list);
+ grpc_fd_notify_on_read(sp->emfd, &sp->read_closure, closure_list);
return;
default:
gpr_log(GPR_ERROR, "Failed accept4: %s", strerror(errno));
@@ -344,12 +345,12 @@ static void on_read(void *arg, int success, grpc_call_list *call_list) {
of channels -- we certainly should not be automatically adding every
incoming channel to every pollset owned by the server */
for (i = 0; i < sp->server->pollset_count; i++) {
- grpc_pollset_add_fd(sp->server->pollsets[i], fdobj, call_list);
+ grpc_pollset_add_fd(sp->server->pollsets[i], fdobj, closure_list);
}
sp->server->on_accept_cb(
sp->server->on_accept_cb_arg,
grpc_tcp_create(fdobj, GRPC_TCP_DEFAULT_READ_SLICE_SIZE, addr_str),
- call_list);
+ closure_list);
gpr_free(name);
gpr_free(addr_str);
@@ -361,7 +362,7 @@ error:
gpr_mu_lock(&sp->server->mu);
if (0 == --sp->server->active_ports) {
gpr_mu_unlock(&sp->server->mu);
- deactivated_all_ports(sp->server, call_list);
+ deactivated_all_ports(sp->server, closure_list);
} else {
gpr_mu_unlock(&sp->server->mu);
}
@@ -488,7 +489,8 @@ int grpc_tcp_server_get_fd(grpc_tcp_server *s, unsigned index) {
void grpc_tcp_server_start(grpc_tcp_server *s, grpc_pollset **pollsets,
size_t pollset_count,
grpc_tcp_server_cb on_accept_cb,
- void *on_accept_cb_arg, grpc_call_list *call_list) {
+ void *on_accept_cb_arg,
+ grpc_closure_list *closure_list) {
size_t i, j;
GPR_ASSERT(on_accept_cb);
gpr_mu_lock(&s->mu);
@@ -500,12 +502,12 @@ void grpc_tcp_server_start(grpc_tcp_server *s, grpc_pollset **pollsets,
s->pollset_count = pollset_count;
for (i = 0; i < s->nports; i++) {
for (j = 0; j < pollset_count; j++) {
- grpc_pollset_add_fd(pollsets[j], s->ports[i].emfd, call_list);
+ grpc_pollset_add_fd(pollsets[j], s->ports[i].emfd, closure_list);
}
s->ports[i].read_closure.cb = on_read;
s->ports[i].read_closure.cb_arg = &s->ports[i];
grpc_fd_notify_on_read(s->ports[i].emfd, &s->ports[i].read_closure,
- call_list);
+ closure_list);
s->active_ports++;
}
gpr_mu_unlock(&s->mu);
diff --git a/src/core/iomgr/udp_server.c b/src/core/iomgr/udp_server.c
index e1c2ae95fd1c2c4301bf530796e171efaf7984e3..0f0bea82ab1457ea8933cba08e913e524f0931c0 100644
--- a/src/core/iomgr/udp_server.c
+++ b/src/core/iomgr/udp_server.c
@@ -133,8 +133,9 @@ grpc_udp_server *grpc_udp_server_create(void) {
return s;
}
-static void finish_shutdown(grpc_udp_server *s, grpc_call_list *call_list) {
- grpc_call_list_add(call_list, s->shutdown_complete, 1);
+static void finish_shutdown(grpc_udp_server *s,
+ grpc_closure_list *closure_list) {
+ grpc_closure_list_add(closure_list, s->shutdown_complete, 1);
gpr_mu_destroy(&s->mu);
gpr_cv_destroy(&s->cv);
@@ -144,13 +145,13 @@ static void finish_shutdown(grpc_udp_server *s, grpc_call_list *call_list) {
}
static void destroyed_port(void *server, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_udp_server *s = server;
gpr_mu_lock(&s->mu);
s->destroyed_ports++;
if (s->destroyed_ports == s->nports) {
gpr_mu_unlock(&s->mu);
- finish_shutdown(s, call_list);
+ finish_shutdown(s, closure_list);
} else {
gpr_mu_unlock(&s->mu);
}
@@ -160,7 +161,7 @@ static void destroyed_port(void *server, int success,
events will be received on them - at this point it's safe to destroy
things */
static void deactivated_all_ports(grpc_udp_server *s,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t i;
/* delete ALL the things */
@@ -180,17 +181,17 @@ static void deactivated_all_ports(grpc_udp_server *s,
sp->destroyed_closure.cb = destroyed_port;
sp->destroyed_closure.cb_arg = s;
grpc_fd_orphan(sp->emfd, &sp->destroyed_closure, "udp_listener_shutdown",
- call_list);
+ closure_list);
}
gpr_mu_unlock(&s->mu);
} else {
gpr_mu_unlock(&s->mu);
- finish_shutdown(s, call_list);
+ finish_shutdown(s, closure_list);
}
}
void grpc_udp_server_destroy(grpc_udp_server *s, grpc_closure *on_done,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t i;
gpr_mu_lock(&s->mu);
@@ -202,12 +203,12 @@ void grpc_udp_server_destroy(grpc_udp_server *s, grpc_closure *on_done,
/* shutdown all fd's */
if (s->active_ports) {
for (i = 0; i < s->nports; i++) {
- grpc_fd_shutdown(s->ports[i].emfd, call_list);
+ grpc_fd_shutdown(s->ports[i].emfd, closure_list);
}
gpr_mu_unlock(&s->mu);
} else {
gpr_mu_unlock(&s->mu);
- deactivated_all_ports(s, call_list);
+ deactivated_all_ports(s, closure_list);
}
}
@@ -262,14 +263,14 @@ error:
}
/* event manager callback when reads are ready */
-static void on_read(void *arg, int success, grpc_call_list *call_list) {
+static void on_read(void *arg, int success, grpc_closure_list *closure_list) {
server_port *sp = arg;
if (success == 0) {
gpr_mu_lock(&sp->server->mu);
if (0 == --sp->server->active_ports) {
gpr_mu_unlock(&sp->server->mu);
- deactivated_all_ports(sp->server, call_list);
+ deactivated_all_ports(sp->server, closure_list);
} else {
gpr_mu_unlock(&sp->server->mu);
}
@@ -281,7 +282,7 @@ static void on_read(void *arg, int success, grpc_call_list *call_list) {
sp->read_cb(sp->fd);
/* Re-arm the notification event so we get another chance to read. */
- grpc_fd_notify_on_read(sp->emfd, &sp->read_closure, call_list);
+ grpc_fd_notify_on_read(sp->emfd, &sp->read_closure, closure_list);
}
static int add_socket_to_server(grpc_udp_server *s, int fd,
@@ -402,19 +403,20 @@ int grpc_udp_server_get_fd(grpc_udp_server *s, unsigned index) {
}
void grpc_udp_server_start(grpc_udp_server *s, grpc_pollset **pollsets,
- size_t pollset_count, grpc_call_list *call_list) {
+ size_t pollset_count,
+ grpc_closure_list *closure_list) {
size_t i, j;
gpr_mu_lock(&s->mu);
GPR_ASSERT(s->active_ports == 0);
s->pollsets = pollsets;
for (i = 0; i < s->nports; i++) {
for (j = 0; j < pollset_count; j++) {
- grpc_pollset_add_fd(pollsets[j], s->ports[i].emfd, call_list);
+ grpc_pollset_add_fd(pollsets[j], s->ports[i].emfd, closure_list);
}
s->ports[i].read_closure.cb = on_read;
s->ports[i].read_closure.cb_arg = &s->ports[i];
grpc_fd_notify_on_read(s->ports[i].emfd, &s->ports[i].read_closure,
- call_list);
+ closure_list);
s->active_ports++;
}
gpr_mu_unlock(&s->mu);
diff --git a/src/core/iomgr/udp_server.h b/src/core/iomgr/udp_server.h
index fa4d2147b4f650e3d4dd043e06a8b5b11ead0222..b66a2d79a231b82ec81490a221dae6942e4d6d74 100644
--- a/src/core/iomgr/udp_server.h
+++ b/src/core/iomgr/udp_server.h
@@ -47,7 +47,8 @@ grpc_udp_server *grpc_udp_server_create(void);
/* Start listening to bound ports */
void grpc_udp_server_start(grpc_udp_server *udp_server, grpc_pollset **pollsets,
- size_t pollset_count, grpc_call_list *call_list);
+ size_t pollset_count,
+ grpc_closure_list *closure_list);
int grpc_udp_server_get_fd(grpc_udp_server *s, unsigned index);
@@ -65,7 +66,7 @@ int grpc_udp_server_add_port(grpc_udp_server *s, const void *addr,
size_t addr_len, grpc_udp_server_read_cb read_cb);
void grpc_udp_server_destroy(grpc_udp_server *server, grpc_closure *on_done,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Write the contents of buffer to the underlying UDP socket. */
/*
diff --git a/src/core/iomgr/workqueue.h b/src/core/iomgr/workqueue.h
index ea7031a9f376031f36a3719bb9d0437dd7335c85..0bec714d4f17b7e6399d34e96e8847d4ea30302a 100644
--- a/src/core/iomgr/workqueue.h
+++ b/src/core/iomgr/workqueue.h
@@ -50,9 +50,10 @@ struct grpc_workqueue;
typedef struct grpc_workqueue grpc_workqueue;
/** Create a work queue */
-grpc_workqueue *grpc_workqueue_create(grpc_call_list *call_list);
+grpc_workqueue *grpc_workqueue_create(grpc_closure_list *closure_list);
-void grpc_workqueue_flush(grpc_workqueue *workqueue, grpc_call_list *call_list);
+void grpc_workqueue_flush(grpc_workqueue *workqueue,
+ grpc_closure_list *closure_list);
#define GRPC_WORKQUEUE_REFCOUNT_DEBUG
#ifdef GRPC_WORKQUEUE_REFCOUNT_DEBUG
@@ -62,19 +63,21 @@ void grpc_workqueue_flush(grpc_workqueue *workqueue, grpc_call_list *call_list);
grpc_workqueue_unref((p), (cl), __FILE__, __LINE__, (r))
void grpc_workqueue_ref(grpc_workqueue *workqueue, const char *file, int line,
const char *reason);
-void grpc_workqueue_unref(grpc_workqueue *workqueue, grpc_call_list *call_list,
- const char *file, int line, const char *reason);
+void grpc_workqueue_unref(grpc_workqueue *workqueue,
+ grpc_closure_list *closure_list, const char *file,
+ int line, const char *reason);
#else
#define GRPC_WORKQUEUE_REF(p, r) grpc_workqueue_ref((p))
#define GRPC_WORKQUEUE_UNREF(p, r, cl) grpc_workqueue_unref((p), (cl))
void grpc_workqueue_ref(grpc_workqueue *workqueue);
-void grpc_workqueue_unref(grpc_workqueue *workqueue, grpc_call_list *call_list);
+void grpc_workqueue_unref(grpc_workqueue *workqueue,
+ grpc_closure_list *closure_list);
#endif
/** Bind this workqueue to a pollset */
void grpc_workqueue_add_to_pollset(grpc_workqueue *workqueue,
grpc_pollset *pollset,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** Add a work item to a workqueue */
void grpc_workqueue_push(grpc_workqueue *workqueue, grpc_closure *closure,
diff --git a/src/core/iomgr/workqueue_posix.c b/src/core/iomgr/workqueue_posix.c
index 83249c583ce58e2b4dc65bd3ab68ca57ad429cad..9ecd59d390b205dbbed8edb9c8c0d326a6df9bef 100644
--- a/src/core/iomgr/workqueue_posix.c
+++ b/src/core/iomgr/workqueue_posix.c
@@ -45,28 +45,29 @@
#include "src/core/iomgr/fd_posix.h"
-static void on_readable(void *arg, int success, grpc_call_list *call_list);
+static void on_readable(void *arg, int success,
+ grpc_closure_list *closure_list);
-grpc_workqueue *grpc_workqueue_create(grpc_call_list *call_list) {
+grpc_workqueue *grpc_workqueue_create(grpc_closure_list *closure_list) {
char name[32];
grpc_workqueue *workqueue = gpr_malloc(sizeof(grpc_workqueue));
gpr_ref_init(&workqueue->refs, 1);
gpr_mu_init(&workqueue->mu);
- workqueue->call_list.head = workqueue->call_list.tail = NULL;
+ workqueue->closure_list.head = workqueue->closure_list.tail = NULL;
grpc_wakeup_fd_init(&workqueue->wakeup_fd);
sprintf(name, "workqueue:%p", (void *)workqueue);
workqueue->wakeup_read_fd =
grpc_fd_create(GRPC_WAKEUP_FD_GET_READ_FD(&workqueue->wakeup_fd), name);
grpc_closure_init(&workqueue->read_closure, on_readable, workqueue);
grpc_fd_notify_on_read(workqueue->wakeup_read_fd, &workqueue->read_closure,
- call_list);
+ closure_list);
return workqueue;
}
static void workqueue_destroy(grpc_workqueue *workqueue,
- grpc_call_list *call_list) {
- GPR_ASSERT(grpc_call_list_empty(workqueue->call_list));
- grpc_fd_shutdown(workqueue->wakeup_read_fd, call_list);
+ grpc_closure_list *closure_list) {
+ GPR_ASSERT(grpc_closure_list_empty(workqueue->closure_list));
+ grpc_fd_shutdown(workqueue->wakeup_read_fd, closure_list);
}
#ifdef GRPC_WORKQUEUE_REFCOUNT_DEBUG
@@ -82,34 +83,36 @@ void grpc_workqueue_ref(grpc_workqueue *workqueue) {
}
#ifdef GRPC_WORKQUEUE_REFCOUNT_DEBUG
-void grpc_workqueue_unref(grpc_workqueue *workqueue, grpc_call_list *call_list,
- const char *file, int line, const char *reason) {
+void grpc_workqueue_unref(grpc_workqueue *workqueue,
+ grpc_closure_list *closure_list, const char *file,
+ int line, const char *reason) {
gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "WORKQUEUE:%p unref %d -> %d %s",
workqueue, (int)workqueue->refs.count, (int)workqueue->refs.count - 1,
reason);
#else
void grpc_workqueue_unref(grpc_workqueue *workqueue,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
#endif
if (gpr_unref(&workqueue->refs)) {
- workqueue_destroy(workqueue, call_list);
+ workqueue_destroy(workqueue, closure_list);
}
}
void grpc_workqueue_add_to_pollset(grpc_workqueue *workqueue,
grpc_pollset *pollset,
- grpc_call_list *call_list) {
- grpc_pollset_add_fd(pollset, workqueue->wakeup_read_fd, call_list);
+ grpc_closure_list *closure_list) {
+ grpc_pollset_add_fd(pollset, workqueue->wakeup_read_fd, closure_list);
}
void grpc_workqueue_flush(grpc_workqueue *workqueue,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
gpr_mu_lock(&workqueue->mu);
- grpc_call_list_move(&workqueue->call_list, call_list);
+ grpc_closure_list_move(&workqueue->closure_list, closure_list);
gpr_mu_unlock(&workqueue->mu);
}
-static void on_readable(void *arg, int success, grpc_call_list *call_list) {
+static void on_readable(void *arg, int success,
+ grpc_closure_list *closure_list) {
grpc_workqueue *workqueue = arg;
if (!success) {
@@ -117,15 +120,15 @@ static void on_readable(void *arg, int success, grpc_call_list *call_list) {
/* HACK: let wakeup_fd code know that we stole the fd */
workqueue->wakeup_fd.read_fd = 0;
grpc_wakeup_fd_destroy(&workqueue->wakeup_fd);
- grpc_fd_orphan(workqueue->wakeup_read_fd, NULL, "destroy", call_list);
+ grpc_fd_orphan(workqueue->wakeup_read_fd, NULL, "destroy", closure_list);
gpr_free(workqueue);
} else {
gpr_mu_lock(&workqueue->mu);
- grpc_call_list_move(&workqueue->call_list, call_list);
+ grpc_closure_list_move(&workqueue->closure_list, closure_list);
grpc_wakeup_fd_consume_wakeup(&workqueue->wakeup_fd);
gpr_mu_unlock(&workqueue->mu);
grpc_fd_notify_on_read(workqueue->wakeup_read_fd, &workqueue->read_closure,
- call_list);
+ closure_list);
}
}
@@ -134,10 +137,10 @@ void grpc_workqueue_push(grpc_workqueue *workqueue, grpc_closure *closure,
closure->success = success;
closure->next = NULL;
gpr_mu_lock(&workqueue->mu);
- if (grpc_call_list_empty(workqueue->call_list)) {
+ if (grpc_closure_list_empty(workqueue->closure_list)) {
grpc_wakeup_fd_wakeup(&workqueue->wakeup_fd);
}
- grpc_call_list_add(&workqueue->call_list, closure, success);
+ grpc_closure_list_add(&workqueue->closure_list, closure, success);
gpr_mu_unlock(&workqueue->mu);
}
diff --git a/src/core/iomgr/workqueue_posix.h b/src/core/iomgr/workqueue_posix.h
index 22c48c4926c17708adfd2bddb10e9c3a02a7220d..589034fe1bb502a6a9c352480707b11de8ec41a5 100644
--- a/src/core/iomgr/workqueue_posix.h
+++ b/src/core/iomgr/workqueue_posix.h
@@ -40,7 +40,7 @@ struct grpc_workqueue {
gpr_refcount refs;
gpr_mu mu;
- grpc_call_list call_list;
+ grpc_closure_list closure_list;
grpc_wakeup_fd wakeup_fd;
struct grpc_fd *wakeup_read_fd;
diff --git a/src/core/security/client_auth_filter.c b/src/core/security/client_auth_filter.c
index 43a37c2077c146b45211f87f7d0b28a8049b8b4f..5955b84962af1225ef5bf6c6772750d0b48686dc 100644
--- a/src/core/security/client_auth_filter.c
+++ b/src/core/security/client_auth_filter.c
@@ -84,18 +84,19 @@ static void reset_service_url(call_data *calld) {
}
static void bubble_up_error(grpc_call_element *elem, grpc_status_code status,
- const char *error_msg, grpc_call_list *call_list) {
+ const char *error_msg,
+ grpc_closure_list *closure_list) {
call_data *calld = elem->call_data;
gpr_log(GPR_ERROR, "Client side authentication failure: %s", error_msg);
grpc_transport_stream_op_add_cancellation(&calld->op, status);
- grpc_call_next_op(elem, &calld->op, call_list);
+ grpc_call_next_op(elem, &calld->op, closure_list);
}
static void on_credentials_metadata(void *user_data,
grpc_credentials_md *md_elems,
size_t num_md,
grpc_credentials_status status,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_call_element *elem = (grpc_call_element *)user_data;
call_data *calld = elem->call_data;
channel_data *chand = elem->channel_data;
@@ -105,7 +106,7 @@ static void on_credentials_metadata(void *user_data,
reset_service_url(calld);
if (status != GRPC_CREDENTIALS_OK) {
bubble_up_error(elem, GRPC_STATUS_UNAUTHENTICATED,
- "Credentials failed to get metadata.", call_list);
+ "Credentials failed to get metadata.", closure_list);
return;
}
GPR_ASSERT(num_md <= MAX_CREDENTIALS_METADATA_COUNT);
@@ -118,7 +119,7 @@ static void on_credentials_metadata(void *user_data,
grpc_mdelem_from_slices(chand->md_ctx, gpr_slice_ref(md_elems[i].key),
gpr_slice_ref(md_elems[i].value)));
}
- grpc_call_next_op(elem, op, call_list);
+ grpc_call_next_op(elem, op, closure_list);
}
void build_service_url(const char *url_scheme, call_data *calld) {
@@ -142,7 +143,7 @@ void build_service_url(const char *url_scheme, call_data *calld) {
static void send_security_metadata(grpc_call_element *elem,
grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
call_data *calld = elem->call_data;
channel_data *chand = elem->channel_data;
grpc_client_security_context *ctx =
@@ -157,7 +158,7 @@ static void send_security_metadata(grpc_call_element *elem,
if (!channel_creds_has_md && !call_creds_has_md) {
/* Skip sending metadata altogether. */
- grpc_call_next_op(elem, op, call_list);
+ grpc_call_next_op(elem, op, closure_list);
return;
}
@@ -167,7 +168,7 @@ static void send_security_metadata(grpc_call_element *elem,
if (calld->creds == NULL) {
bubble_up_error(elem, GRPC_STATUS_INVALID_ARGUMENT,
"Incompatible credentials set on channel and call.",
- call_list);
+ closure_list);
return;
}
} else {
@@ -180,21 +181,22 @@ static void send_security_metadata(grpc_call_element *elem,
GPR_ASSERT(calld->pollset);
grpc_credentials_get_request_metadata(
calld->creds, calld->pollset, calld->service_url, on_credentials_metadata,
- elem, call_list);
+ elem, closure_list);
}
static void on_host_checked(void *user_data, grpc_security_status status,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_call_element *elem = (grpc_call_element *)user_data;
call_data *calld = elem->call_data;
if (status == GRPC_SECURITY_OK) {
- send_security_metadata(elem, &calld->op, call_list);
+ send_security_metadata(elem, &calld->op, closure_list);
} else {
char *error_msg;
gpr_asprintf(&error_msg, "Invalid host %s set in :authority metadata.",
grpc_mdstr_as_c_string(calld->host));
- bubble_up_error(elem, GRPC_STATUS_INVALID_ARGUMENT, error_msg, call_list);
+ bubble_up_error(elem, GRPC_STATUS_INVALID_ARGUMENT, error_msg,
+ closure_list);
gpr_free(error_msg);
}
}
@@ -206,7 +208,7 @@ static void on_host_checked(void *user_data, grpc_security_status status,
that is being sent or received. */
static void auth_start_transport_op(grpc_call_element *elem,
grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
/* grab pointers to our data from the call element */
call_data *calld = elem->call_data;
channel_data *chand = elem->channel_data;
@@ -259,7 +261,7 @@ static void auth_start_transport_op(grpc_call_element *elem,
calld->op = *op; /* Copy op (originates from the caller's stack). */
status = grpc_channel_security_connector_check_call_host(
chand->security_connector, call_host, on_host_checked, elem,
- call_list);
+ closure_list);
if (status != GRPC_SECURITY_OK) {
if (status == GRPC_SECURITY_ERROR) {
char *error_msg;
@@ -267,26 +269,26 @@ static void auth_start_transport_op(grpc_call_element *elem,
"Invalid host %s set in :authority metadata.",
call_host);
bubble_up_error(elem, GRPC_STATUS_INVALID_ARGUMENT, error_msg,
- call_list);
+ closure_list);
gpr_free(error_msg);
}
return; /* early exit */
}
}
- send_security_metadata(elem, op, call_list);
+ send_security_metadata(elem, op, closure_list);
return; /* early exit */
}
}
/* pass control down the stack */
- grpc_call_next_op(elem, op, call_list);
+ grpc_call_next_op(elem, op, closure_list);
}
/* Constructor for call_data */
static 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) {
call_data *calld = elem->call_data;
memset(calld, 0, sizeof(*calld));
GPR_ASSERT(!initial_op || !initial_op->send_ops);
@@ -294,7 +296,7 @@ static void init_call_elem(grpc_call_element *elem,
/* Destructor for call_data */
static void destroy_call_elem(grpc_call_element *elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
call_data *calld = elem->call_data;
grpc_credentials_unref(calld->creds);
if (calld->host != NULL) {
@@ -310,7 +312,7 @@ static void destroy_call_elem(grpc_call_element *elem,
static 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) {
grpc_security_connector *sc = grpc_find_security_connector_in_args(args);
/* grab pointers to our data from the channel element */
channel_data *chand = elem->channel_data;
@@ -337,7 +339,7 @@ static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
/* Destructor for channel data */
static void destroy_channel_elem(grpc_channel_element *elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
/* grab pointers to our data from the channel element */
channel_data *chand = elem->channel_data;
grpc_channel_security_connector *ctx = chand->security_connector;
diff --git a/src/core/security/credentials.c b/src/core/security/credentials.c
index 80e0a79447bf59af2aa38686310e37168fef1708..0a49834d40b38472620b8a3c659571cf59dd2e0c 100644
--- a/src/core/security/credentials.c
+++ b/src/core/security/credentials.c
@@ -109,16 +109,16 @@ void grpc_credentials_get_request_metadata(grpc_credentials *creds,
const char *service_url,
grpc_credentials_metadata_cb cb,
void *user_data,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
if (creds == NULL || !grpc_credentials_has_request_metadata(creds) ||
creds->vtable->get_request_metadata == NULL) {
if (cb != NULL) {
- cb(user_data, NULL, 0, GRPC_CREDENTIALS_OK, call_list);
+ cb(user_data, NULL, 0, GRPC_CREDENTIALS_OK, closure_list);
}
return;
}
creds->vtable->get_request_metadata(creds, pollset, service_url, cb,
- user_data, call_list);
+ user_data, closure_list);
}
grpc_security_status grpc_credentials_create_security_connector(
@@ -377,7 +377,7 @@ static void jwt_get_request_metadata(grpc_credentials *creds,
const char *service_url,
grpc_credentials_metadata_cb cb,
void *user_data,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_service_account_jwt_access_credentials *c =
(grpc_service_account_jwt_access_credentials *)creds;
gpr_timespec refresh_threshold = gpr_time_from_seconds(
@@ -422,10 +422,10 @@ static void jwt_get_request_metadata(grpc_credentials *creds,
if (jwt_md != NULL) {
cb(user_data, jwt_md->entries, jwt_md->num_entries, GRPC_CREDENTIALS_OK,
- call_list);
+ closure_list);
grpc_credentials_md_store_unref(jwt_md);
} else {
- cb(user_data, NULL, 0, GRPC_CREDENTIALS_ERROR, call_list);
+ cb(user_data, NULL, 0, GRPC_CREDENTIALS_ERROR, closure_list);
}
}
@@ -572,7 +572,7 @@ end:
static void on_oauth2_token_fetcher_http_response(
void *user_data, const grpc_httpcli_response *response,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_credentials_metadata_request *r =
(grpc_credentials_metadata_request *)user_data;
grpc_oauth2_token_fetcher_credentials *c =
@@ -587,10 +587,10 @@ static void on_oauth2_token_fetcher_http_response(
c->token_expiration =
gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), token_lifetime);
r->cb(r->user_data, c->access_token_md->entries,
- c->access_token_md->num_entries, status, call_list);
+ c->access_token_md->num_entries, status, closure_list);
} else {
c->token_expiration = gpr_inf_past(GPR_CLOCK_REALTIME);
- r->cb(r->user_data, NULL, 0, status, call_list);
+ r->cb(r->user_data, NULL, 0, status, closure_list);
}
gpr_mu_unlock(&c->mu);
grpc_credentials_metadata_request_destroy(r);
@@ -599,7 +599,7 @@ static void on_oauth2_token_fetcher_http_response(
static void oauth2_token_fetcher_get_request_metadata(
grpc_credentials *creds, grpc_pollset *pollset, const char *service_url,
grpc_credentials_metadata_cb cb, void *user_data,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_oauth2_token_fetcher_credentials *c =
(grpc_oauth2_token_fetcher_credentials *)creds;
gpr_timespec refresh_threshold = gpr_time_from_seconds(
@@ -618,14 +618,14 @@ static void oauth2_token_fetcher_get_request_metadata(
}
if (cached_access_token_md != NULL) {
cb(user_data, cached_access_token_md->entries,
- cached_access_token_md->num_entries, GRPC_CREDENTIALS_OK, call_list);
+ cached_access_token_md->num_entries, GRPC_CREDENTIALS_OK, closure_list);
grpc_credentials_md_store_unref(cached_access_token_md);
} else {
c->fetch_func(
grpc_credentials_metadata_request_create(creds, cb, user_data),
&c->httpcli_context, pollset, on_oauth2_token_fetcher_http_response,
gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), refresh_threshold),
- call_list);
+ closure_list);
}
}
@@ -651,7 +651,7 @@ static void compute_engine_fetch_oauth2(
grpc_credentials_metadata_request *metadata_req,
grpc_httpcli_context *httpcli_context, grpc_pollset *pollset,
grpc_httpcli_response_cb response_cb, gpr_timespec deadline,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_httpcli_header header = {"Metadata-Flavor", "Google"};
grpc_httpcli_request request;
memset(&request, 0, sizeof(grpc_httpcli_request));
@@ -660,7 +660,7 @@ static void compute_engine_fetch_oauth2(
request.hdr_count = 1;
request.hdrs = &header;
grpc_httpcli_get(httpcli_context, pollset, &request, deadline, response_cb,
- metadata_req, call_list);
+ metadata_req, closure_list);
}
grpc_credentials *grpc_google_compute_engine_credentials_create(
@@ -691,7 +691,7 @@ static void refresh_token_fetch_oauth2(
grpc_credentials_metadata_request *metadata_req,
grpc_httpcli_context *httpcli_context, grpc_pollset *pollset,
grpc_httpcli_response_cb response_cb, gpr_timespec deadline,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_google_refresh_token_credentials *c =
(grpc_google_refresh_token_credentials *)metadata_req->creds;
grpc_httpcli_header header = {"Content-Type",
@@ -708,7 +708,7 @@ static void refresh_token_fetch_oauth2(
request.hdrs = &header;
request.handshaker = &grpc_httpcli_ssl;
grpc_httpcli_post(httpcli_context, pollset, &request, body, strlen(body),
- deadline, response_cb, metadata_req, call_list);
+ deadline, response_cb, metadata_req, closure_list);
gpr_free(body);
}
@@ -755,11 +755,11 @@ static void on_simulated_token_fetch_done(void *user_data) {
grpc_credentials_metadata_request *r =
(grpc_credentials_metadata_request *)user_data;
grpc_md_only_test_credentials *c = (grpc_md_only_test_credentials *)r->creds;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
r->cb(r->user_data, c->md_store->entries, c->md_store->num_entries,
- GRPC_CREDENTIALS_OK, &call_list);
+ GRPC_CREDENTIALS_OK, &closure_list);
grpc_credentials_metadata_request_destroy(r);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
static void md_only_test_get_request_metadata(grpc_credentials *creds,
@@ -767,7 +767,7 @@ static void md_only_test_get_request_metadata(grpc_credentials *creds,
const char *service_url,
grpc_credentials_metadata_cb cb,
void *user_data,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_md_only_test_credentials *c = (grpc_md_only_test_credentials *)creds;
if (c->is_async) {
@@ -776,7 +776,7 @@ static void md_only_test_get_request_metadata(grpc_credentials *creds,
grpc_credentials_metadata_request_create(creds, cb, user_data);
gpr_thd_new(&thd_id, on_simulated_token_fetch_done, cb_arg, NULL);
} else {
- cb(user_data, c->md_store->entries, 1, GRPC_CREDENTIALS_OK, call_list);
+ cb(user_data, c->md_store->entries, 1, GRPC_CREDENTIALS_OK, closure_list);
}
}
@@ -821,9 +821,10 @@ static void access_token_get_request_metadata(grpc_credentials *creds,
const char *service_url,
grpc_credentials_metadata_cb cb,
void *user_data,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_access_token_credentials *c = (grpc_access_token_credentials *)creds;
- cb(user_data, c->access_token_md->entries, 1, GRPC_CREDENTIALS_OK, call_list);
+ cb(user_data, c->access_token_md->entries, 1, GRPC_CREDENTIALS_OK,
+ closure_list);
}
static grpc_credentials_vtable access_token_vtable = {
@@ -971,11 +972,11 @@ static void composite_md_context_destroy(
static void composite_metadata_cb(void *user_data,
grpc_credentials_md *md_elems, size_t num_md,
grpc_credentials_status status,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_composite_credentials_metadata_context *ctx =
(grpc_composite_credentials_metadata_context *)user_data;
if (status != GRPC_CREDENTIALS_OK) {
- ctx->cb(ctx->user_data, NULL, 0, status, call_list);
+ ctx->cb(ctx->user_data, NULL, 0, status, closure_list);
return;
}
@@ -995,16 +996,16 @@ static void composite_metadata_cb(void *user_data,
if (grpc_credentials_has_request_metadata(inner_creds)) {
grpc_credentials_get_request_metadata(
inner_creds, ctx->pollset, ctx->service_url, composite_metadata_cb,
- ctx, call_list);
+ ctx, closure_list);
return;
}
}
/* We're done!. */
ctx->cb(ctx->user_data, ctx->md_elems->entries, ctx->md_elems->num_entries,
- GRPC_CREDENTIALS_OK, call_list);
+ GRPC_CREDENTIALS_OK, closure_list);
composite_md_context_destroy(ctx);
- grpc_call_list_run(call_list);
+ grpc_closure_list_run(closure_list);
}
static void composite_get_request_metadata(grpc_credentials *creds,
@@ -1012,11 +1013,11 @@ static void composite_get_request_metadata(grpc_credentials *creds,
const char *service_url,
grpc_credentials_metadata_cb cb,
void *user_data,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_composite_credentials *c = (grpc_composite_credentials *)creds;
grpc_composite_credentials_metadata_context *ctx;
if (!grpc_credentials_has_request_metadata(creds)) {
- cb(user_data, NULL, 0, GRPC_CREDENTIALS_OK, call_list);
+ cb(user_data, NULL, 0, GRPC_CREDENTIALS_OK, closure_list);
return;
}
ctx = gpr_malloc(sizeof(grpc_composite_credentials_metadata_context));
@@ -1032,7 +1033,7 @@ static void composite_get_request_metadata(grpc_credentials *creds,
if (grpc_credentials_has_request_metadata(inner_creds)) {
grpc_credentials_get_request_metadata(inner_creds, pollset, service_url,
composite_metadata_cb, ctx,
- call_list);
+ closure_list);
return;
}
}
@@ -1169,10 +1170,10 @@ static void iam_get_request_metadata(grpc_credentials *creds,
const char *service_url,
grpc_credentials_metadata_cb cb,
void *user_data,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_google_iam_credentials *c = (grpc_google_iam_credentials *)creds;
cb(user_data, c->iam_md->entries, c->iam_md->num_entries, GRPC_CREDENTIALS_OK,
- call_list);
+ closure_list);
}
static grpc_credentials_vtable iam_vtable = {
@@ -1226,14 +1227,14 @@ static void plugin_md_request_metadata_ready(void *request,
grpc_status_code status,
const char *error_details) {
/* called from application code */
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_metadata_plugin_request *r = (grpc_metadata_plugin_request *)request;
if (status != GRPC_STATUS_OK) {
if (error_details != NULL) {
gpr_log(GPR_ERROR, "Getting metadata from plugin failed with error: %s",
error_details);
}
- r->cb(r->user_data, NULL, 0, GRPC_CREDENTIALS_ERROR, &call_list);
+ r->cb(r->user_data, NULL, 0, GRPC_CREDENTIALS_ERROR, &closure_list);
} else {
size_t i;
grpc_credentials_md *md_array = NULL;
@@ -1245,7 +1246,7 @@ static void plugin_md_request_metadata_ready(void *request,
gpr_slice_from_copied_buffer(md[i].value, md[i].value_length);
}
}
- r->cb(r->user_data, md_array, num_md, GRPC_CREDENTIALS_OK, &call_list);
+ r->cb(r->user_data, md_array, num_md, GRPC_CREDENTIALS_OK, &closure_list);
if (md_array != NULL) {
for (i = 0; i < num_md; i++) {
gpr_slice_unref(md_array[i].key);
@@ -1262,7 +1263,7 @@ static void plugin_get_request_metadata(grpc_credentials *creds,
const char *service_url,
grpc_credentials_metadata_cb cb,
void *user_data,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_plugin_credentials *c = (grpc_plugin_credentials *)creds;
if (c->plugin.get_metadata != NULL) {
grpc_metadata_plugin_request *request = gpr_malloc(sizeof(*request));
@@ -1272,7 +1273,7 @@ static void plugin_get_request_metadata(grpc_credentials *creds,
c->plugin.get_metadata(c->plugin.state, service_url,
plugin_md_request_metadata_ready, request);
} else {
- cb(user_data, NULL, 0, GRPC_CREDENTIALS_OK, call_list);
+ cb(user_data, NULL, 0, GRPC_CREDENTIALS_OK, closure_list);
}
}
diff --git a/src/core/security/credentials.h b/src/core/security/credentials.h
index 090767d237d9d479f3983459e504db8b8d5d08f8..edc0a61f03b475d94c92618066afc97af04fa756 100644
--- a/src/core/security/credentials.h
+++ b/src/core/security/credentials.h
@@ -128,7 +128,7 @@ typedef void (*grpc_credentials_metadata_cb)(void *user_data,
grpc_credentials_md *md_elems,
size_t num_md,
grpc_credentials_status status,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
typedef struct {
void (*destruct)(grpc_credentials *c);
@@ -137,7 +137,7 @@ typedef struct {
void (*get_request_metadata)(grpc_credentials *c, grpc_pollset *pollset,
const char *service_url,
grpc_credentials_metadata_cb cb, void *user_data,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
grpc_security_status (*create_security_connector)(
grpc_credentials *c, const char *target, const grpc_channel_args *args,
grpc_credentials *request_metadata_creds,
@@ -159,7 +159,7 @@ void grpc_credentials_get_request_metadata(grpc_credentials *creds,
const char *service_url,
grpc_credentials_metadata_cb cb,
void *user_data,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Creates a security connector for the channel. May also create new channel
args for the channel to be used in place of the passed in const args if
@@ -278,7 +278,7 @@ typedef void (*grpc_fetch_oauth2_func)(grpc_credentials_metadata_request *req,
grpc_pollset *pollset,
grpc_httpcli_response_cb response_cb,
gpr_timespec deadline,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
typedef struct {
grpc_credentials base;
diff --git a/src/core/security/google_default_credentials.c b/src/core/security/google_default_credentials.c
index 8c3d85cc58eaab8780173b2e4d40156328faf5db..4a7ab53c1e332cc79740b7f8f513de640e8e999f 100644
--- a/src/core/security/google_default_credentials.c
+++ b/src/core/security/google_default_credentials.c
@@ -64,7 +64,7 @@ typedef struct {
static void on_compute_engine_detection_http_response(
void *user_data, const grpc_httpcli_response *response,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
compute_engine_detector *detector = (compute_engine_detector *)user_data;
if (response != NULL && response->status == 200 && response->hdr_count > 0) {
/* Internet providers can return a generic response to all requests, so
@@ -85,7 +85,7 @@ static void on_compute_engine_detection_http_response(
gpr_mu_unlock(GRPC_POLLSET_MU(&detector->pollset));
}
-static void destroy_pollset(void *p, int s, grpc_call_list *call_list) {
+static void destroy_pollset(void *p, int s, grpc_closure_list *closure_list) {
grpc_pollset_destroy(p);
}
@@ -93,7 +93,7 @@ static int is_stack_running_on_compute_engine(void) {
compute_engine_detector detector;
grpc_httpcli_request request;
grpc_httpcli_context context;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_closure destroy_closure;
/* The http call is local. If it takes more than one sec, it is for sure not
@@ -113,9 +113,9 @@ static int is_stack_running_on_compute_engine(void) {
grpc_httpcli_get(
&context, &detector.pollset, &request,
gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), max_detection_delay),
- on_compute_engine_detection_http_response, &detector, &call_list);
+ on_compute_engine_detection_http_response, &detector, &closure_list);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
/* Block until we get the response. This is not ideal but this should only be
called once for the lifetime of the process by the default credentials. */
@@ -123,14 +123,14 @@ static int is_stack_running_on_compute_engine(void) {
while (!detector.is_done) {
grpc_pollset_worker worker;
grpc_pollset_work(&detector.pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- gpr_inf_future(GPR_CLOCK_MONOTONIC), &call_list);
+ gpr_inf_future(GPR_CLOCK_MONOTONIC), &closure_list);
}
gpr_mu_unlock(GRPC_POLLSET_MU(&detector.pollset));
grpc_httpcli_context_destroy(&context);
grpc_closure_init(&destroy_closure, destroy_pollset, &detector.pollset);
- grpc_pollset_shutdown(&detector.pollset, &destroy_closure, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_pollset_shutdown(&detector.pollset, &destroy_closure, &closure_list);
+ grpc_closure_list_run(&closure_list);
return detector.success;
}
diff --git a/src/core/security/handshake.c b/src/core/security/handshake.c
index e3206c2e1224059dcac85460ff2c91311ebe4fd7..caad12a65335bd24dc5c723ecca983e3a58e096d 100644
--- a/src/core/security/handshake.c
+++ b/src/core/security/handshake.c
@@ -58,26 +58,26 @@ typedef struct {
grpc_closure on_handshake_data_received_from_peer;
} grpc_security_handshake;
-static void on_handshake_data_received_from_peer(void *setup, int success,
- grpc_call_list *call_list);
+static void on_handshake_data_received_from_peer(
+ void *setup, int success, grpc_closure_list *closure_list);
static void on_handshake_data_sent_to_peer(void *setup, int success,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
static void security_handshake_done(grpc_security_handshake *h, int is_success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
if (is_success) {
h->cb(h->user_data, GRPC_SECURITY_OK, h->wrapped_endpoint,
- h->secure_endpoint, call_list);
+ h->secure_endpoint, closure_list);
} else {
if (h->secure_endpoint != NULL) {
- grpc_endpoint_shutdown(h->secure_endpoint, call_list);
- grpc_endpoint_destroy(h->secure_endpoint, call_list);
+ grpc_endpoint_shutdown(h->secure_endpoint, closure_list);
+ grpc_endpoint_destroy(h->secure_endpoint, closure_list);
} else {
- grpc_endpoint_destroy(h->wrapped_endpoint, call_list);
+ grpc_endpoint_destroy(h->wrapped_endpoint, closure_list);
}
h->cb(h->user_data, GRPC_SECURITY_ERROR, h->wrapped_endpoint, NULL,
- call_list);
+ closure_list);
}
if (h->handshaker != NULL) tsi_handshaker_destroy(h->handshaker);
if (h->handshake_buffer != NULL) gpr_free(h->handshake_buffer);
@@ -89,13 +89,13 @@ static void security_handshake_done(grpc_security_handshake *h, int is_success,
}
static void on_peer_checked(void *user_data, grpc_security_status status,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_security_handshake *h = user_data;
tsi_frame_protector *protector;
tsi_result result;
if (status != GRPC_SECURITY_OK) {
gpr_log(GPR_ERROR, "Error checking peer.");
- security_handshake_done(h, 0, call_list);
+ security_handshake_done(h, 0, closure_list);
return;
}
result =
@@ -103,7 +103,7 @@ static void on_peer_checked(void *user_data, grpc_security_status status,
if (result != TSI_OK) {
gpr_log(GPR_ERROR, "Frame protector creation failed with error %s.",
tsi_result_to_string(result));
- security_handshake_done(h, 0, call_list);
+ security_handshake_done(h, 0, closure_list);
return;
}
h->secure_endpoint =
@@ -111,11 +111,12 @@ static void on_peer_checked(void *user_data, grpc_security_status status,
h->left_overs.slices, h->left_overs.count);
h->left_overs.count = 0;
h->left_overs.length = 0;
- security_handshake_done(h, 1, call_list);
+ security_handshake_done(h, 1, closure_list);
return;
}
-static void check_peer(grpc_security_handshake *h, grpc_call_list *call_list) {
+static void check_peer(grpc_security_handshake *h,
+ grpc_closure_list *closure_list) {
grpc_security_status peer_status;
tsi_peer peer;
tsi_result result = tsi_handshaker_extract_peer(h->handshaker, &peer);
@@ -123,22 +124,22 @@ static void check_peer(grpc_security_handshake *h, grpc_call_list *call_list) {
if (result != TSI_OK) {
gpr_log(GPR_ERROR, "Peer extraction failed with error %s",
tsi_result_to_string(result));
- security_handshake_done(h, 0, call_list);
+ security_handshake_done(h, 0, closure_list);
return;
}
peer_status = grpc_security_connector_check_peer(h->connector, peer,
on_peer_checked, h);
if (peer_status == GRPC_SECURITY_ERROR) {
gpr_log(GPR_ERROR, "Peer check failed.");
- security_handshake_done(h, 0, call_list);
+ security_handshake_done(h, 0, closure_list);
return;
} else if (peer_status == GRPC_SECURITY_OK) {
- on_peer_checked(h, peer_status, call_list);
+ on_peer_checked(h, peer_status, closure_list);
}
}
static void send_handshake_bytes_to_peer(grpc_security_handshake *h,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t offset = 0;
tsi_result result = TSI_OK;
gpr_slice to_send;
@@ -158,7 +159,7 @@ static void send_handshake_bytes_to_peer(grpc_security_handshake *h,
if (result != TSI_OK) {
gpr_log(GPR_ERROR, "Handshake failed with error %s",
tsi_result_to_string(result));
- security_handshake_done(h, 0, call_list);
+ security_handshake_done(h, 0, closure_list);
return;
}
@@ -169,11 +170,11 @@ static void send_handshake_bytes_to_peer(grpc_security_handshake *h,
/* TODO(klempner,jboeuf): This should probably use the client setup
deadline */
grpc_endpoint_write(h->wrapped_endpoint, &h->outgoing,
- &h->on_handshake_data_sent_to_peer, call_list);
+ &h->on_handshake_data_sent_to_peer, closure_list);
}
-static void on_handshake_data_received_from_peer(void *handshake, int success,
- grpc_call_list *call_list) {
+static void on_handshake_data_received_from_peer(
+ void *handshake, int success, grpc_closure_list *closure_list) {
grpc_security_handshake *h = handshake;
size_t consumed_slice_size = 0;
tsi_result result = TSI_OK;
@@ -183,7 +184,7 @@ static void on_handshake_data_received_from_peer(void *handshake, int success,
if (!success) {
gpr_log(GPR_ERROR, "Read failed.");
- security_handshake_done(h, 0, call_list);
+ security_handshake_done(h, 0, closure_list);
return;
}
@@ -199,10 +200,11 @@ static void on_handshake_data_received_from_peer(void *handshake, int success,
/* We may need more data. */
if (result == TSI_INCOMPLETE_DATA) {
grpc_endpoint_read(h->wrapped_endpoint, &h->incoming,
- &h->on_handshake_data_received_from_peer, call_list);
+ &h->on_handshake_data_received_from_peer,
+ closure_list);
return;
} else {
- send_handshake_bytes_to_peer(h, call_list);
+ send_handshake_bytes_to_peer(h, closure_list);
return;
}
}
@@ -210,7 +212,7 @@ static void on_handshake_data_received_from_peer(void *handshake, int success,
if (result != TSI_OK) {
gpr_log(GPR_ERROR, "Handshake failed with error %s",
tsi_result_to_string(result));
- security_handshake_done(h, 0, call_list);
+ security_handshake_done(h, 0, closure_list);
return;
}
@@ -220,7 +222,7 @@ static void on_handshake_data_received_from_peer(void *handshake, int success,
num_left_overs =
(has_left_overs_in_current_slice ? 1 : 0) + h->incoming.count - i - 1;
if (num_left_overs == 0) {
- check_peer(h, call_list);
+ check_peer(h, closure_list);
return;
}
@@ -235,18 +237,18 @@ static void on_handshake_data_received_from_peer(void *handshake, int success,
gpr_slice_buffer_addn(
&h->left_overs, &h->incoming.slices[i + 1],
num_left_overs - (size_t)has_left_overs_in_current_slice);
- check_peer(h, call_list);
+ check_peer(h, closure_list);
}
/* If handshake is NULL, the handshake is done. */
static void on_handshake_data_sent_to_peer(void *handshake, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_security_handshake *h = handshake;
/* Make sure that write is OK. */
if (!success) {
gpr_log(GPR_ERROR, "Write failed.");
- if (handshake != NULL) security_handshake_done(h, 0, call_list);
+ if (handshake != NULL) security_handshake_done(h, 0, closure_list);
return;
}
@@ -255,9 +257,9 @@ static void on_handshake_data_sent_to_peer(void *handshake, int success,
/* TODO(klempner,jboeuf): This should probably use the client setup
deadline */
grpc_endpoint_read(h->wrapped_endpoint, &h->incoming,
- &h->on_handshake_data_received_from_peer, call_list);
+ &h->on_handshake_data_received_from_peer, closure_list);
} else {
- check_peer(h, call_list);
+ check_peer(h, closure_list);
}
}
@@ -265,7 +267,8 @@ void grpc_do_security_handshake(tsi_handshaker *handshaker,
grpc_security_connector *connector,
grpc_endpoint *nonsecure_endpoint,
grpc_security_handshake_done_cb cb,
- void *user_data, grpc_call_list *call_list) {
+ void *user_data,
+ grpc_closure_list *closure_list) {
grpc_security_handshake *h = gpr_malloc(sizeof(grpc_security_handshake));
memset(h, 0, sizeof(grpc_security_handshake));
h->handshaker = handshaker;
@@ -282,5 +285,5 @@ void grpc_do_security_handshake(tsi_handshaker *handshaker,
gpr_slice_buffer_init(&h->left_overs);
gpr_slice_buffer_init(&h->outgoing);
gpr_slice_buffer_init(&h->incoming);
- send_handshake_bytes_to_peer(h, call_list);
+ send_handshake_bytes_to_peer(h, closure_list);
}
diff --git a/src/core/security/handshake.h b/src/core/security/handshake.h
index d492de5059bd51eabcb01304574fcd54fa9f9204..368e8bf5e1b947bca7a60ba79252dceffddafee6 100644
--- a/src/core/security/handshake.h
+++ b/src/core/security/handshake.h
@@ -42,6 +42,7 @@ void grpc_do_security_handshake(tsi_handshaker *handshaker,
grpc_security_connector *connector,
grpc_endpoint *nonsecure_endpoint,
grpc_security_handshake_done_cb cb,
- void *user_data, grpc_call_list *call_list);
+ void *user_data,
+ grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_SECURITY_HANDSHAKE_H */
diff --git a/src/core/security/jwt_verifier.c b/src/core/security/jwt_verifier.c
index a6736c922cb2b93962cfab25d0457fa7c867260c..be861693468cbf593d89eb3d0fe06722d921002b 100644
--- a/src/core/security/jwt_verifier.c
+++ b/src/core/security/jwt_verifier.c
@@ -571,7 +571,7 @@ end:
static void on_keys_retrieved(void *user_data,
const grpc_httpcli_response *response,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_json *json = json_from_http(response);
verifier_cb_ctx *ctx = (verifier_cb_ctx *)user_data;
EVP_PKEY *verification_key = NULL;
@@ -613,7 +613,7 @@ end:
static void on_openid_config_retrieved(void *user_data,
const grpc_httpcli_response *response,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
const grpc_json *cur;
grpc_json *json = json_from_http(response);
verifier_cb_ctx *ctx = (verifier_cb_ctx *)user_data;
@@ -645,7 +645,7 @@ static void on_openid_config_retrieved(void *user_data,
grpc_httpcli_get(
&ctx->verifier->http_ctx, ctx->pollset, &req,
gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), grpc_jwt_verifier_max_delay),
- on_keys_retrieved, ctx, call_list);
+ on_keys_retrieved, ctx, closure_list);
grpc_json_destroy(json);
gpr_free(req.host);
return;
@@ -685,7 +685,7 @@ static void verifier_put_mapping(grpc_jwt_verifier *v, const char *email_domain,
/* Takes ownership of ctx. */
static void retrieve_key_and_verify(verifier_cb_ctx *ctx,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
const char *at_sign;
grpc_httpcli_response_cb http_cb;
char *path_prefix = NULL;
@@ -748,7 +748,7 @@ static void retrieve_key_and_verify(verifier_cb_ctx *ctx,
grpc_httpcli_get(
&ctx->verifier->http_ctx, ctx->pollset, &req,
gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), grpc_jwt_verifier_max_delay),
- http_cb, ctx, call_list);
+ http_cb, ctx, closure_list);
gpr_free(req.host);
gpr_free(req.path);
return;
@@ -762,7 +762,7 @@ void grpc_jwt_verifier_verify(grpc_jwt_verifier *verifier,
grpc_pollset *pollset, const char *jwt,
const char *audience,
grpc_jwt_verification_done_cb cb, void *user_data,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
const char *dot = NULL;
grpc_json *json;
jose_header *header = NULL;
@@ -796,7 +796,7 @@ void grpc_jwt_verifier_verify(grpc_jwt_verifier *verifier,
retrieve_key_and_verify(
verifier_cb_ctx_create(verifier, pollset, header, claims, audience,
signature, jwt, signed_jwt_len, user_data, cb),
- call_list);
+ closure_list);
return;
error:
diff --git a/src/core/security/jwt_verifier.h b/src/core/security/jwt_verifier.h
index 394935302baa9b5529e93b14894905dbbedf2985..b270280cc102ccdc0bae26ff284cf8256aa5f4db 100644
--- a/src/core/security/jwt_verifier.h
+++ b/src/core/security/jwt_verifier.h
@@ -124,7 +124,7 @@ void grpc_jwt_verifier_verify(grpc_jwt_verifier *verifier,
grpc_pollset *pollset, const char *jwt,
const char *audience,
grpc_jwt_verification_done_cb cb, void *user_data,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* --- TESTING ONLY exposed functions. --- */
diff --git a/src/core/security/secure_endpoint.c b/src/core/security/secure_endpoint.c
index a647345796f4579e328c7b03436c81497069dbad..a6fc7e94a08e0774739b7d4e484368803b90d23f 100644
--- a/src/core/security/secure_endpoint.c
+++ b/src/core/security/secure_endpoint.c
@@ -67,9 +67,10 @@ typedef struct {
int grpc_trace_secure_endpoint = 0;
-static void destroy(secure_endpoint *secure_ep, grpc_call_list *call_list) {
+static void destroy(secure_endpoint *secure_ep,
+ grpc_closure_list *closure_list) {
secure_endpoint *ep = secure_ep;
- grpc_endpoint_destroy(ep->wrapped_ep, call_list);
+ grpc_endpoint_destroy(ep->wrapped_ep, closure_list);
tsi_frame_protector_destroy(ep->protector);
gpr_slice_buffer_destroy(&ep->leftover_bytes);
gpr_slice_unref(ep->read_staging_buffer);
@@ -87,12 +88,13 @@ static void destroy(secure_endpoint *secure_ep, grpc_call_list *call_list) {
#define SECURE_ENDPOINT_REF(ep, reason) \
secure_endpoint_ref((ep), (reason), __FILE__, __LINE__)
static void secure_endpoint_unref(secure_endpoint *ep,
- grpc_call_list *call_list, const char *reason,
- const char *file, int line) {
+ grpc_closure_list *closure_list,
+ const char *reason, const char *file,
+ int line) {
gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "SECENDP unref %p : %s %d -> %d",
ep, reason, ep->ref.count, ep->ref.count - 1);
if (gpr_unref(&ep->ref)) {
- destroy(ep, call_list);
+ destroy(ep, closure_list);
}
}
@@ -106,9 +108,9 @@ static void secure_endpoint_ref(secure_endpoint *ep, const char *reason,
#define SECURE_ENDPOINT_UNREF(ep, reason, cl) secure_endpoint_unref((ep), (cl))
#define SECURE_ENDPOINT_REF(ep, reason) secure_endpoint_ref((ep))
static void secure_endpoint_unref(secure_endpoint *ep,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
if (gpr_unref(&ep->ref)) {
- destroy(ep, call_list);
+ destroy(ep, closure_list);
}
}
@@ -124,7 +126,7 @@ static void flush_read_staging_buffer(secure_endpoint *ep, gpr_uint8 **cur,
}
static void call_read_cb(secure_endpoint *ep, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
if (grpc_trace_secure_endpoint) {
size_t i;
for (i = 0; i < ep->read_buffer->count; i++) {
@@ -135,11 +137,12 @@ static void call_read_cb(secure_endpoint *ep, int success,
}
}
ep->read_buffer = NULL;
- grpc_call_list_add(call_list, ep->read_cb, success);
- SECURE_ENDPOINT_UNREF(ep, "read", call_list);
+ grpc_closure_list_add(closure_list, ep->read_cb, success);
+ SECURE_ENDPOINT_UNREF(ep, "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) {
unsigned i;
gpr_uint8 keep_looping = 0;
tsi_result result = TSI_OK;
@@ -149,7 +152,7 @@ static void on_read(void *user_data, int success, grpc_call_list *call_list) {
if (!success) {
gpr_slice_buffer_reset_and_unref(ep->read_buffer);
- call_read_cb(ep, 0, call_list);
+ call_read_cb(ep, 0, closure_list);
return;
}
@@ -206,15 +209,15 @@ static void on_read(void *user_data, int success, grpc_call_list *call_list) {
if (result != TSI_OK) {
gpr_slice_buffer_reset_and_unref(ep->read_buffer);
- call_read_cb(ep, 0, call_list);
+ call_read_cb(ep, 0, closure_list);
return;
}
- call_read_cb(ep, 1, call_list);
+ call_read_cb(ep, 1, closure_list);
}
static void endpoint_read(grpc_endpoint *secure_ep, gpr_slice_buffer *slices,
- grpc_closure *cb, grpc_call_list *call_list) {
+ grpc_closure *cb, grpc_closure_list *closure_list) {
secure_endpoint *ep = (secure_endpoint *)secure_ep;
ep->read_cb = cb;
ep->read_buffer = slices;
@@ -224,12 +227,12 @@ static void endpoint_read(grpc_endpoint *secure_ep, gpr_slice_buffer *slices,
if (ep->leftover_bytes.count) {
gpr_slice_buffer_swap(&ep->leftover_bytes, &ep->source_buffer);
GPR_ASSERT(ep->leftover_bytes.count == 0);
- on_read(ep, 1, call_list);
+ on_read(ep, 1, closure_list);
return;
}
grpc_endpoint_read(ep->wrapped_ep, &ep->source_buffer, &ep->on_read,
- call_list);
+ closure_list);
}
static void flush_write_staging_buffer(secure_endpoint *ep, gpr_uint8 **cur,
@@ -241,7 +244,7 @@ static void flush_write_staging_buffer(secure_endpoint *ep, gpr_uint8 **cur,
}
static void endpoint_write(grpc_endpoint *secure_ep, gpr_slice_buffer *slices,
- grpc_closure *cb, grpc_call_list *call_list) {
+ grpc_closure *cb, grpc_closure_list *closure_list) {
unsigned i;
tsi_result result = TSI_OK;
secure_endpoint *ep = (secure_endpoint *)secure_ep;
@@ -313,37 +316,37 @@ static void endpoint_write(grpc_endpoint *secure_ep, gpr_slice_buffer *slices,
if (result != TSI_OK) {
/* TODO(yangg) do different things according to the error type? */
gpr_slice_buffer_reset_and_unref(&ep->output_buffer);
- grpc_call_list_add(call_list, cb, 0);
+ grpc_closure_list_add(closure_list, cb, 0);
return;
}
- grpc_endpoint_write(ep->wrapped_ep, &ep->output_buffer, cb, call_list);
+ grpc_endpoint_write(ep->wrapped_ep, &ep->output_buffer, cb, closure_list);
}
static void endpoint_shutdown(grpc_endpoint *secure_ep,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
secure_endpoint *ep = (secure_endpoint *)secure_ep;
- grpc_endpoint_shutdown(ep->wrapped_ep, call_list);
+ grpc_endpoint_shutdown(ep->wrapped_ep, closure_list);
}
static void endpoint_destroy(grpc_endpoint *secure_ep,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
secure_endpoint *ep = (secure_endpoint *)secure_ep;
- SECURE_ENDPOINT_UNREF(ep, "destroy", call_list);
+ SECURE_ENDPOINT_UNREF(ep, "destroy", closure_list);
}
static void endpoint_add_to_pollset(grpc_endpoint *secure_ep,
grpc_pollset *pollset,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
secure_endpoint *ep = (secure_endpoint *)secure_ep;
- grpc_endpoint_add_to_pollset(ep->wrapped_ep, pollset, call_list);
+ grpc_endpoint_add_to_pollset(ep->wrapped_ep, pollset, closure_list);
}
static void endpoint_add_to_pollset_set(grpc_endpoint *secure_ep,
grpc_pollset_set *pollset_set,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
secure_endpoint *ep = (secure_endpoint *)secure_ep;
- grpc_endpoint_add_to_pollset_set(ep->wrapped_ep, pollset_set, call_list);
+ grpc_endpoint_add_to_pollset_set(ep->wrapped_ep, pollset_set, closure_list);
}
static char *endpoint_get_peer(grpc_endpoint *secure_ep) {
diff --git a/src/core/security/security_connector.c b/src/core/security/security_connector.c
index 07e2490981c7f5d23d873ec310ae8e33f6c9e2dc..280036bc0ebe33a5e91ae534a246b773f4ec83f3 100644
--- a/src/core/security/security_connector.c
+++ b/src/core/security/security_connector.c
@@ -106,11 +106,12 @@ void grpc_security_connector_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) {
if (sc == NULL || nonsecure_endpoint == NULL) {
- cb(user_data, GRPC_SECURITY_ERROR, nonsecure_endpoint, NULL, call_list);
+ cb(user_data, GRPC_SECURITY_ERROR, nonsecure_endpoint, NULL, closure_list);
} else {
- sc->vtable->do_handshake(sc, nonsecure_endpoint, cb, user_data, call_list);
+ sc->vtable->do_handshake(sc, nonsecure_endpoint, cb, user_data,
+ closure_list);
}
}
@@ -126,9 +127,10 @@ grpc_security_status grpc_security_connector_check_peer(
grpc_security_status grpc_channel_security_connector_check_call_host(
grpc_channel_security_connector *sc, const char *host,
- grpc_security_check_cb cb, void *user_data, grpc_call_list *call_list) {
+ grpc_security_check_cb cb, void *user_data,
+ grpc_closure_list *closure_list) {
if (sc == NULL || sc->check_call_host == NULL) return GRPC_SECURITY_ERROR;
- return sc->check_call_host(sc, host, cb, user_data, call_list);
+ return sc->check_call_host(sc, host, cb, user_data, closure_list);
}
#ifdef GRPC_SECURITY_CONNECTOR_REFCOUNT_DEBUG
@@ -270,11 +272,12 @@ end:
static grpc_security_status fake_channel_check_call_host(
grpc_channel_security_connector *sc, const char *host,
- grpc_security_check_cb cb, void *user_data, grpc_call_list *call_list) {
+ grpc_security_check_cb cb, void *user_data,
+ grpc_closure_list *closure_list) {
grpc_fake_channel_security_connector *c =
(grpc_fake_channel_security_connector *)sc;
if (c->call_host_check_is_async) {
- cb(user_data, GRPC_SECURITY_OK, call_list);
+ cb(user_data, GRPC_SECURITY_OK, closure_list);
return GRPC_SECURITY_PENDING;
} else {
return GRPC_SECURITY_OK;
@@ -285,18 +288,18 @@ static void fake_channel_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_do_security_handshake(tsi_create_fake_handshaker(1), sc,
- nonsecure_endpoint, cb, user_data, call_list);
+ nonsecure_endpoint, cb, user_data, closure_list);
}
static void fake_server_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_do_security_handshake(tsi_create_fake_handshaker(0), sc,
- nonsecure_endpoint, cb, user_data, call_list);
+ nonsecure_endpoint, cb, user_data, closure_list);
}
static grpc_security_connector_vtable fake_channel_vtable = {
@@ -389,7 +392,7 @@ static void ssl_channel_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_ssl_channel_security_connector *c =
(grpc_ssl_channel_security_connector *)sc;
tsi_handshaker *handshaker;
@@ -399,10 +402,10 @@ static void ssl_channel_do_handshake(grpc_security_connector *sc,
: c->target_name,
&handshaker);
if (status != GRPC_SECURITY_OK) {
- cb(user_data, status, nonsecure_endpoint, NULL, call_list);
+ cb(user_data, status, nonsecure_endpoint, NULL, closure_list);
} else {
grpc_do_security_handshake(handshaker, sc, nonsecure_endpoint, cb,
- user_data, call_list);
+ user_data, closure_list);
}
}
@@ -410,17 +413,17 @@ static void ssl_server_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_ssl_server_security_connector *c =
(grpc_ssl_server_security_connector *)sc;
tsi_handshaker *handshaker;
grpc_security_status status =
ssl_create_handshaker(c->handshaker_factory, 0, NULL, &handshaker);
if (status != GRPC_SECURITY_OK) {
- cb(user_data, status, nonsecure_endpoint, NULL, call_list);
+ cb(user_data, status, nonsecure_endpoint, NULL, closure_list);
} else {
grpc_do_security_handshake(handshaker, sc, nonsecure_endpoint, cb,
- user_data, call_list);
+ user_data, closure_list);
}
}
@@ -529,7 +532,8 @@ static grpc_security_status ssl_server_check_peer(grpc_security_connector *sc,
static grpc_security_status ssl_channel_check_call_host(
grpc_channel_security_connector *sc, const char *host,
- grpc_security_check_cb cb, void *user_data, grpc_call_list *call_list) {
+ grpc_security_check_cb cb, void *user_data,
+ grpc_closure_list *closure_list) {
grpc_ssl_channel_security_connector *c =
(grpc_ssl_channel_security_connector *)sc;
diff --git a/src/core/security/security_connector.h b/src/core/security/security_connector.h
index 276fa479400d7372c9f394e06640a65934533892..0f161d0e374ba444bdef1839544222758f72605d 100644
--- a/src/core/security/security_connector.h
+++ b/src/core/security/security_connector.h
@@ -62,21 +62,20 @@ typedef struct grpc_security_connector grpc_security_connector;
typedef void (*grpc_security_check_cb)(void *user_data,
grpc_security_status status,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Ownership of the secure_endpoint is transfered. */
-typedef void (*grpc_security_handshake_done_cb)(void *user_data,
- grpc_security_status status,
- grpc_endpoint *wrapped_endpoint,
- grpc_endpoint *secure_endpoint,
- grpc_call_list *call_list);
+typedef void (*grpc_security_handshake_done_cb)(
+ void *user_data, grpc_security_status status,
+ grpc_endpoint *wrapped_endpoint, grpc_endpoint *secure_endpoint,
+ grpc_closure_list *closure_list);
typedef struct {
void (*destroy)(grpc_security_connector *sc);
void (*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_security_status (*check_peer)(grpc_security_connector *sc, tsi_peer peer,
grpc_security_check_cb cb,
void *user_data);
@@ -115,7 +114,7 @@ void grpc_security_connector_do_handshake(grpc_security_connector *connector,
grpc_endpoint *nonsecure_endpoint,
grpc_security_handshake_done_cb cb,
void *user_data,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Check the peer.
Implementations can choose to check the peer either synchronously or
@@ -152,7 +151,7 @@ struct grpc_channel_security_connector {
const char *host,
grpc_security_check_cb cb,
void *user_data,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
};
/* Checks that the host that will be set for a call is acceptable.
@@ -162,7 +161,8 @@ struct grpc_channel_security_connector {
GRPC_SECURITY_PENDING unless an error is detected early on. */
grpc_security_status grpc_channel_security_connector_check_call_host(
grpc_channel_security_connector *sc, const char *host,
- grpc_security_check_cb cb, void *user_data, grpc_call_list *call_list);
+ grpc_security_check_cb cb, void *user_data,
+ grpc_closure_list *closure_list);
/* --- Creation security connectors. --- */
diff --git a/src/core/security/server_auth_filter.c b/src/core/security/server_auth_filter.c
index 201288bbdd4fd627c28c6a7efa29096b2a521e0e..e65578e479ea049641b86e9c50745b2802379b41 100644
--- a/src/core/security/server_auth_filter.c
+++ b/src/core/security/server_auth_filter.c
@@ -116,7 +116,7 @@ static void on_md_processing_done(
grpc_status_code status, const char *error_details) {
grpc_call_element *elem = user_data;
call_data *calld = elem->call_data;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
/* TODO(jboeuf): Implement support for response_md. */
if (response_md != NULL && num_response_md > 0) {
@@ -131,7 +131,7 @@ static void on_md_processing_done(
grpc_metadata_batch_filter(&calld->md_op->data.metadata, remove_consumed_md,
elem);
grpc_metadata_array_destroy(&calld->md);
- calld->on_done_recv->cb(calld->on_done_recv->cb_arg, 1, &call_list);
+ calld->on_done_recv->cb(calld->on_done_recv->cb_arg, 1, &closure_list);
} else {
gpr_slice message;
grpc_metadata_array_destroy(&calld->md);
@@ -141,14 +141,14 @@ static void on_md_processing_done(
message = gpr_slice_from_copied_string(error_details);
grpc_sopb_reset(calld->recv_ops);
grpc_transport_stream_op_add_close(&calld->transport_op, status, &message);
- grpc_call_next_op(elem, &calld->transport_op, &call_list);
+ grpc_call_next_op(elem, &calld->transport_op, &closure_list);
}
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
static void auth_on_recv(void *user_data, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_call_element *elem = user_data;
call_data *calld = elem->call_data;
channel_data *chand = elem->channel_data;
@@ -169,7 +169,7 @@ static void auth_on_recv(void *user_data, int success,
return;
}
}
- calld->on_done_recv->cb(calld->on_done_recv->cb_arg, success, call_list);
+ calld->on_done_recv->cb(calld->on_done_recv->cb_arg, success, closure_list);
}
static void set_recv_ops_md_callbacks(grpc_call_element *elem,
@@ -192,16 +192,16 @@ static void set_recv_ops_md_callbacks(grpc_call_element *elem,
that is being sent or received. */
static void auth_start_transport_op(grpc_call_element *elem,
grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
set_recv_ops_md_callbacks(elem, op);
- grpc_call_next_op(elem, op, call_list);
+ grpc_call_next_op(elem, op, closure_list);
}
/* Constructor for call_data */
static 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) {
/* grab pointers to our data from the call element */
call_data *calld = elem->call_data;
channel_data *chand = elem->channel_data;
@@ -235,13 +235,13 @@ static void init_call_elem(grpc_call_element *elem,
/* Destructor for call_data */
static void destroy_call_elem(grpc_call_element *elem,
- grpc_call_list *call_list) {}
+ grpc_closure_list *closure_list) {}
/* Constructor for channel_data */
static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
const grpc_channel_args *args, grpc_mdctx *mdctx,
int is_first, int is_last,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_security_connector *sc = grpc_find_security_connector_in_args(args);
grpc_auth_metadata_processor *processor =
grpc_find_auth_metadata_processor_in_args(args);
@@ -266,7 +266,7 @@ static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
/* Destructor for channel data */
static void destroy_channel_elem(grpc_channel_element *elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
/* grab pointers to our data from the channel element */
channel_data *chand = elem->channel_data;
GRPC_SECURITY_CONNECTOR_UNREF(chand->security_connector,
diff --git a/src/core/security/server_secure_chttp2.c b/src/core/security/server_secure_chttp2.c
index 2ecb61514024f762b4c89326d6b1540574c7eb6e..268ae58280489462cc5f14e36810fc2886060197 100644
--- a/src/core/security/server_secure_chttp2.c
+++ b/src/core/security/server_secure_chttp2.c
@@ -86,7 +86,8 @@ static void state_unref(grpc_server_secure_state *state) {
}
static void setup_transport(void *statep, grpc_transport *transport,
- grpc_mdctx *mdctx, grpc_call_list *call_list) {
+ grpc_mdctx *mdctx,
+ grpc_closure_list *closure_list) {
static grpc_channel_filter const *extra_filters[] = {
&grpc_server_auth_filter, &grpc_http_server_filter};
grpc_server_secure_state *state = statep;
@@ -100,7 +101,7 @@ static void setup_transport(void *statep, grpc_transport *transport,
GPR_ARRAY_SIZE(args_to_add));
grpc_server_setup_transport(state->server, transport, extra_filters,
GPR_ARRAY_SIZE(extra_filters), mdctx, args_copy,
- call_list);
+ closure_list);
grpc_channel_args_destroy(args_copy);
}
@@ -128,7 +129,7 @@ static int remove_tcp_from_list_locked(grpc_server_secure_state *state,
static void on_secure_handshake_done(void *statep, grpc_security_status status,
grpc_endpoint *wrapped_endpoint,
grpc_endpoint *secure_endpoint,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_server_secure_state *state = statep;
grpc_transport *transport;
grpc_mdctx *mdctx;
@@ -139,13 +140,13 @@ static void on_secure_handshake_done(void *statep, grpc_security_status status,
mdctx = grpc_mdctx_create();
transport = grpc_create_chttp2_transport(
grpc_server_get_channel_args(state->server), secure_endpoint, mdctx,
- 0, call_list);
- setup_transport(state, transport, mdctx, call_list);
- grpc_chttp2_transport_start_reading(transport, NULL, 0, call_list);
+ 0, closure_list);
+ setup_transport(state, transport, mdctx, closure_list);
+ grpc_chttp2_transport_start_reading(transport, NULL, 0, closure_list);
} else {
/* We need to consume this here, because the server may already have gone
* away. */
- grpc_endpoint_destroy(secure_endpoint, call_list);
+ grpc_endpoint_destroy(secure_endpoint, closure_list);
}
gpr_mu_unlock(&state->mu);
} else {
@@ -158,7 +159,7 @@ static void on_secure_handshake_done(void *statep, grpc_security_status status,
}
static void on_accept(void *statep, grpc_endpoint *tcp,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_server_secure_state *state = statep;
tcp_endpoint_list *node;
state_ref(state);
@@ -169,25 +170,26 @@ static void on_accept(void *statep, grpc_endpoint *tcp,
state->handshaking_tcp_endpoints = node;
gpr_mu_unlock(&state->mu);
grpc_security_connector_do_handshake(state->sc, tcp, on_secure_handshake_done,
- state, call_list);
+ state, closure_list);
}
/* Server callback: start listening on our ports */
static void start(grpc_server *server, void *statep, grpc_pollset **pollsets,
- size_t pollset_count, grpc_call_list *call_list) {
+ size_t pollset_count, grpc_closure_list *closure_list) {
grpc_server_secure_state *state = statep;
grpc_tcp_server_start(state->tcp, pollsets, pollset_count, on_accept, state,
- call_list);
+ closure_list);
}
-static void destroy_done(void *statep, int success, grpc_call_list *call_list) {
+static void destroy_done(void *statep, int success,
+ grpc_closure_list *closure_list) {
grpc_server_secure_state *state = statep;
state->destroy_callback->cb(state->destroy_callback->cb_arg, success,
- call_list);
+ closure_list);
gpr_mu_lock(&state->mu);
while (state->handshaking_tcp_endpoints != NULL) {
grpc_endpoint_shutdown(state->handshaking_tcp_endpoints->tcp_endpoint,
- call_list);
+ closure_list);
remove_tcp_from_list_locked(state,
state->handshaking_tcp_endpoints->tcp_endpoint);
}
@@ -198,7 +200,7 @@ static void destroy_done(void *statep, int success, grpc_call_list *call_list) {
/* Server callback: destroy the tcp listener (so we don't generate further
callbacks) */
static void destroy(grpc_server *server, void *statep, grpc_closure *callback,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_server_secure_state *state = statep;
grpc_tcp_server *tcp;
gpr_mu_lock(&state->mu);
@@ -207,7 +209,7 @@ static void destroy(grpc_server *server, void *statep, grpc_closure *callback,
tcp = state->tcp;
gpr_mu_unlock(&state->mu);
grpc_closure_init(&state->destroy_closure, destroy_done, state);
- grpc_tcp_server_destroy(tcp, &state->destroy_closure, call_list);
+ grpc_tcp_server_destroy(tcp, &state->destroy_closure, closure_list);
}
int grpc_server_add_secure_http2_port(grpc_server *server, const char *addr,
@@ -221,7 +223,7 @@ int grpc_server_add_secure_http2_port(grpc_server *server, const char *addr,
int port_temp;
grpc_security_status status = GRPC_SECURITY_ERROR;
grpc_security_connector *sc = NULL;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
/* create security context */
if (creds == NULL) goto error;
@@ -282,9 +284,9 @@ int grpc_server_add_secure_http2_port(grpc_server *server, const char *addr,
gpr_ref_init(&state->refcount, 1);
/* Register with the server only upon success */
- grpc_server_add_listener(server, state, start, destroy, &call_list);
+ grpc_server_add_listener(server, state, start, destroy, &closure_list);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
return port_num;
/* Error path: cleanup and return */
@@ -296,11 +298,11 @@ error:
grpc_resolved_addresses_destroy(resolved);
}
if (tcp) {
- grpc_tcp_server_destroy(tcp, NULL, &call_list);
+ grpc_tcp_server_destroy(tcp, NULL, &closure_list);
}
if (state) {
gpr_free(state);
}
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
return 0;
}
diff --git a/src/core/surface/call.c b/src/core/surface/call.c
index 9920e0daafeaea29f9a97de832ffc4a223417dc3..1e371a4cbc040bbc529d9304c90af91f94c0523a 100644
--- a/src/core/surface/call.c
+++ b/src/core/surface/call.c
@@ -277,24 +277,24 @@ struct grpc_call {
CALL_FROM_CALL_STACK(grpc_call_stack_from_top_element(top_elem))
static void set_deadline_alarm(grpc_call *call, gpr_timespec deadline,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
static void call_on_done_recv(void *call, int success,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
static void call_on_done_send(void *call, int success,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
static int fill_send_ops(grpc_call *call, grpc_transport_stream_op *op);
static void execute_op(grpc_call *call, grpc_transport_stream_op *op,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
static void recv_metadata(grpc_call *call, grpc_metadata_batch *metadata,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
static void finish_read_ops(grpc_call *call);
static grpc_call_error cancel_with_status(grpc_call *c, grpc_status_code status,
const char *description);
static void finished_loose_op(void *call, int success,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
static void lock(grpc_call *call);
-static void unlock(grpc_call *call, grpc_call_list *call_list);
+static void unlock(grpc_call *call, grpc_closure_list *closure_list);
grpc_call *grpc_call_create(grpc_channel *channel, grpc_call *parent_call,
gpr_uint32 propagation_mask,
@@ -307,7 +307,7 @@ grpc_call *grpc_call_create(grpc_channel *channel, grpc_call *parent_call,
grpc_transport_stream_op initial_op;
grpc_transport_stream_op *initial_op_ptr = NULL;
grpc_channel_stack *channel_stack = grpc_channel_get_channel_stack(channel);
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_call *call =
gpr_malloc(sizeof(grpc_call) + channel_stack->call_stack_size);
memset(call, 0, sizeof(grpc_call));
@@ -356,7 +356,7 @@ grpc_call *grpc_call_create(grpc_channel *channel, grpc_call *parent_call,
initial_op_ptr = &initial_op;
}
grpc_call_stack_init(channel_stack, server_transport_data, initial_op_ptr,
- CALL_STACK_FROM_CALL(call), &call_list);
+ CALL_STACK_FROM_CALL(call), &closure_list);
if (parent_call != NULL) {
GRPC_CALL_INTERNAL_REF(parent_call, "child");
GPR_ASSERT(call->is_client);
@@ -400,20 +400,20 @@ grpc_call *grpc_call_create(grpc_channel *channel, grpc_call *parent_call,
}
if (gpr_time_cmp(send_deadline, gpr_inf_future(send_deadline.clock_type)) !=
0) {
- set_deadline_alarm(call, send_deadline, &call_list);
+ set_deadline_alarm(call, send_deadline, &closure_list);
}
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
return call;
}
void grpc_call_set_completion_queue(grpc_call *call, grpc_completion_queue *cq,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
lock(call);
call->cq = cq;
if (cq) {
GRPC_CQ_INTERNAL_REF(cq, "bind");
}
- unlock(call, call_list);
+ unlock(call, closure_list);
}
grpc_completion_queue *grpc_call_get_completion_queue(grpc_call *call) {
@@ -436,13 +436,13 @@ static grpc_cq_completion *allocate_completion(grpc_call *call) {
}
static void done_completion(void *call, grpc_cq_completion *completion,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_call *c = call;
gpr_mu_lock(&c->completion_mu);
c->allocated_completions &=
(gpr_uint8) ~(1u << (completion - c->completions));
gpr_mu_unlock(&c->completion_mu);
- GRPC_CALL_INTERNAL_UNREF(c, "completion", call_list);
+ GRPC_CALL_INTERNAL_UNREF(c, "completion", closure_list);
}
#ifdef GRPC_CALL_REF_COUNT_DEBUG
@@ -455,11 +455,11 @@ void grpc_call_internal_ref(grpc_call *c) {
gpr_ref(&c->internal_refcount);
}
-static void destroy_call(grpc_call *call, grpc_call_list *call_list) {
+static void destroy_call(grpc_call *call, grpc_closure_list *closure_list) {
size_t i;
grpc_call *c = call;
- grpc_call_stack_destroy(CALL_STACK_FROM_CALL(c), call_list);
- GRPC_CHANNEL_INTERNAL_UNREF(c->channel, "call", call_list);
+ grpc_call_stack_destroy(CALL_STACK_FROM_CALL(c), closure_list);
+ GRPC_CHANNEL_INTERNAL_UNREF(c->channel, "call", closure_list);
gpr_mu_destroy(&c->mu);
gpr_mu_destroy(&c->completion_mu);
for (i = 0; i < STATUS_SOURCE_COUNT; i++) {
@@ -494,14 +494,14 @@ static void destroy_call(grpc_call *call, grpc_call_list *call_list) {
#ifdef GRPC_CALL_REF_COUNT_DEBUG
void grpc_call_internal_unref(grpc_call *c, const char *reason,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
gpr_log(GPR_DEBUG, "CALL: unref %p %d -> %d [%s]", c,
c->internal_refcount.count, c->internal_refcount.count - 1, reason);
#else
-void grpc_call_internal_unref(grpc_call *c, grpc_call_list *call_list) {
+void grpc_call_internal_unref(grpc_call *c, grpc_closure_list *closure_list) {
#endif
if (gpr_unref(&c->internal_refcount)) {
- destroy_call(c, call_list);
+ destroy_call(c, closure_list);
}
}
@@ -600,7 +600,7 @@ static int need_more_data(grpc_call *call) {
(call->cancel_with_status != GRPC_STATUS_OK) || call->destroy_called;
}
-static void unlock(grpc_call *call, grpc_call_list *call_list) {
+static void unlock(grpc_call *call, grpc_closure_list *closure_list) {
grpc_transport_stream_op op;
completed_request completed_requests[GRPC_IOREQ_OP_COUNT];
int completing_requests = 0;
@@ -665,19 +665,19 @@ static void unlock(grpc_call *call, grpc_call_list *call_list) {
gpr_mu_unlock(&call->mu);
if (start_op) {
- execute_op(call, &op, call_list);
+ execute_op(call, &op, closure_list);
}
if (completing_requests > 0) {
for (i = 0; i < completing_requests; i++) {
completed_requests[i].on_complete(call, completed_requests[i].success,
completed_requests[i].user_data,
- call_list);
+ closure_list);
}
lock(call);
call->completing = 0;
- unlock(call, call_list);
- GRPC_CALL_INTERNAL_UNREF(call, "completing", call_list);
+ unlock(call, closure_list);
+ GRPC_CALL_INTERNAL_UNREF(call, "completing", closure_list);
}
}
@@ -823,7 +823,7 @@ static void early_out_write_ops(grpc_call *call) {
}
static void call_on_done_send(void *pc, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_call *call = pc;
lock(call);
if (call->last_send_contains & (1 << GRPC_IOREQ_SEND_INITIAL_METADATA)) {
@@ -846,8 +846,8 @@ static void call_on_done_send(void *pc, int success,
call->send_ops.nops = 0;
call->last_send_contains = 0;
call->sending = 0;
- unlock(call, call_list);
- GRPC_CALL_INTERNAL_UNREF(call, "sending", call_list);
+ unlock(call, closure_list);
+ GRPC_CALL_INTERNAL_UNREF(call, "sending", closure_list);
}
static void finish_message(grpc_call *call) {
@@ -954,7 +954,7 @@ static int add_slice_to_message(grpc_call *call, gpr_slice slice) {
}
static void call_on_done_recv(void *pc, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_call *call = pc;
grpc_call *child_call;
grpc_call *next_child_call;
@@ -969,7 +969,7 @@ static void call_on_done_recv(void *pc, int success,
case GRPC_NO_OP:
break;
case GRPC_OP_METADATA:
- recv_metadata(call, &op->data.metadata, call_list);
+ recv_metadata(call, &op->data.metadata, closure_list);
break;
case GRPC_OP_BEGIN_MESSAGE:
success = begin_message(call, op->data.begin_message);
@@ -991,7 +991,7 @@ static void call_on_done_recv(void *pc, int success,
GPR_ASSERT(call->read_state <= READ_STATE_STREAM_CLOSED);
call->read_state = READ_STATE_STREAM_CLOSED;
if (call->have_alarm) {
- grpc_alarm_cancel(&call->alarm, call_list);
+ grpc_alarm_cancel(&call->alarm, closure_list);
}
/* propagate cancellation to any interested children */
child_call = call->first_child;
@@ -1001,12 +1001,13 @@ static void call_on_done_recv(void *pc, int success,
if (child_call->cancellation_is_inherited) {
GRPC_CALL_INTERNAL_REF(child_call, "propagate_cancel");
grpc_call_cancel(child_call, NULL);
- GRPC_CALL_INTERNAL_UNREF(child_call, "propagate_cancel", call_list);
+ GRPC_CALL_INTERNAL_UNREF(child_call, "propagate_cancel",
+ closure_list);
}
child_call = next_child_call;
} while (child_call != call->first_child);
}
- GRPC_CALL_INTERNAL_UNREF(call, "closed", call_list);
+ GRPC_CALL_INTERNAL_UNREF(call, "closed", closure_list);
}
finish_read_ops(call);
} else {
@@ -1018,9 +1019,9 @@ static void call_on_done_recv(void *pc, int success,
finish_ioreq_op(call, GRPC_IOREQ_RECV_STATUS_DETAILS, 0);
}
call->recv_ops.nops = 0;
- unlock(call, call_list);
+ unlock(call, closure_list);
- GRPC_CALL_INTERNAL_UNREF(call, "receiving", call_list);
+ GRPC_CALL_INTERNAL_UNREF(call, "receiving", closure_list);
GRPC_TIMER_END(GRPC_PTAG_CALL_ON_DONE_RECV, 0);
}
@@ -1273,18 +1274,18 @@ static grpc_call_error start_ioreq(grpc_call *call, const grpc_ioreq *reqs,
grpc_call_error grpc_call_start_ioreq_and_call_back(
grpc_call *call, const grpc_ioreq *reqs, size_t nreqs,
grpc_ioreq_completion_func on_complete, void *user_data,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_call_error err;
lock(call);
err = start_ioreq(call, reqs, nreqs, on_complete, user_data);
- unlock(call, call_list);
+ unlock(call, closure_list);
return err;
}
void grpc_call_destroy(grpc_call *c) {
int cancel;
grpc_call *parent = c->parent;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
if (parent) {
gpr_mu_lock(&parent->mu);
@@ -1297,20 +1298,20 @@ void grpc_call_destroy(grpc_call *c) {
c->sibling_next->sibling_prev = c->sibling_prev;
}
gpr_mu_unlock(&parent->mu);
- GRPC_CALL_INTERNAL_UNREF(parent, "child", &call_list);
+ GRPC_CALL_INTERNAL_UNREF(parent, "child", &closure_list);
}
lock(c);
GPR_ASSERT(!c->destroy_called);
c->destroy_called = 1;
if (c->have_alarm) {
- grpc_alarm_cancel(&c->alarm, &call_list);
+ grpc_alarm_cancel(&c->alarm, &closure_list);
}
cancel = c->read_state != READ_STATE_STREAM_CLOSED;
- unlock(c, &call_list);
+ unlock(c, &closure_list);
if (cancel) grpc_call_cancel(c, NULL);
- GRPC_CALL_INTERNAL_UNREF(c, "destroy", &call_list);
- grpc_call_list_run(&call_list);
+ GRPC_CALL_INTERNAL_UNREF(c, "destroy", &closure_list);
+ grpc_closure_list_run(&closure_list);
}
grpc_call_error grpc_call_cancel(grpc_call *call, void *reserved) {
@@ -1324,12 +1325,12 @@ grpc_call_error grpc_call_cancel_with_status(grpc_call *c,
const char *description,
void *reserved) {
grpc_call_error r;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
GPR_ASSERT(reserved == NULL);
lock(c);
r = cancel_with_status(c, status, description);
- unlock(c, &call_list);
- grpc_call_list_run(&call_list);
+ unlock(c, &closure_list);
+ grpc_closure_list_run(&closure_list);
return r;
}
@@ -1350,8 +1351,8 @@ static grpc_call_error cancel_with_status(grpc_call *c, grpc_status_code status,
}
static void finished_loose_op(void *call, int success_ignored,
- grpc_call_list *call_list) {
- GRPC_CALL_INTERNAL_UNREF(call, "loose-op", call_list);
+ grpc_closure_list *closure_list) {
+ GRPC_CALL_INTERNAL_UNREF(call, "loose-op", closure_list);
}
typedef struct {
@@ -1360,14 +1361,14 @@ typedef struct {
} finished_loose_op_allocated_args;
static void finished_loose_op_allocated(void *alloc, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
finished_loose_op_allocated_args *args = alloc;
- finished_loose_op(args->call, success, call_list);
+ finished_loose_op(args->call, success, closure_list);
gpr_free(args);
}
static void execute_op(grpc_call *call, grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_call_element *elem;
GPR_ASSERT(op->on_consumed == NULL);
@@ -1385,14 +1386,14 @@ static void execute_op(grpc_call *call, grpc_transport_stream_op *op,
elem = CALL_ELEM_FROM_CALL(call, 0);
op->context = call->context;
- elem->filter->start_transport_stream_op(elem, op, call_list);
+ elem->filter->start_transport_stream_op(elem, op, closure_list);
}
char *grpc_call_get_peer(grpc_call *call) {
grpc_call_element *elem = CALL_ELEM_FROM_CALL(call, 0);
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
- char *result = elem->filter->get_peer(elem, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
+ char *result = elem->filter->get_peer(elem, &closure_list);
+ grpc_closure_list_run(&closure_list);
return result;
}
@@ -1400,7 +1401,8 @@ grpc_call *grpc_call_from_top_element(grpc_call_element *elem) {
return CALL_FROM_TOP_ELEM(elem);
}
-static void call_alarm(void *arg, int success, grpc_call_list *call_list) {
+static void call_alarm(void *arg, int success,
+ grpc_closure_list *closure_list) {
grpc_call *call = arg;
lock(call);
call->have_alarm = 0;
@@ -1409,12 +1411,12 @@ static void call_alarm(void *arg, int success, grpc_call_list *call_list) {
"Deadline Exceeded");
}
finish_read_ops(call);
- unlock(call, call_list);
- GRPC_CALL_INTERNAL_UNREF(call, "alarm", call_list);
+ unlock(call, closure_list);
+ GRPC_CALL_INTERNAL_UNREF(call, "alarm", closure_list);
}
static void set_deadline_alarm(grpc_call *call, gpr_timespec deadline,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
if (call->have_alarm) {
gpr_log(GPR_ERROR, "Attempt to set deadline alarm twice");
assert(0);
@@ -1424,7 +1426,7 @@ static void set_deadline_alarm(grpc_call *call, gpr_timespec deadline,
call->have_alarm = 1;
call->send_deadline = gpr_convert_clock_type(deadline, GPR_CLOCK_MONOTONIC);
grpc_alarm_init(&call->alarm, call->send_deadline, call_alarm, call,
- gpr_now(GPR_CLOCK_MONOTONIC), call_list);
+ gpr_now(GPR_CLOCK_MONOTONIC), closure_list);
}
/* we offset status by a small amount when storing it into transport metadata
@@ -1476,7 +1478,7 @@ static gpr_uint32 decode_compression(grpc_mdelem *md) {
}
static void recv_metadata(grpc_call *call, grpc_metadata_batch *md,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_linked_mdelem *l;
grpc_metadata_array *dest;
grpc_metadata *mdusr;
@@ -1523,7 +1525,7 @@ static void recv_metadata(grpc_call *call, grpc_metadata_batch *md,
if (gpr_time_cmp(md->deadline, gpr_inf_future(md->deadline.clock_type)) !=
0 &&
!call->is_client) {
- set_deadline_alarm(call, md->deadline, call_list);
+ set_deadline_alarm(call, md->deadline, closure_list);
}
if (!is_trailing) {
call->read_state = READ_STATE_GOT_INITIAL_METADATA;
@@ -1556,15 +1558,15 @@ static void set_cancelled_value(grpc_status_code status, void *dest) {
}
static void finish_batch(grpc_call *call, int success, void *tag,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_cq_end_op(call->cq, tag, success, done_completion, call,
- allocate_completion(call), call_list);
+ allocate_completion(call), closure_list);
}
static void finish_batch_with_close(grpc_call *call, int success, void *tag,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_cq_end_op(call->cq, tag, 1, done_completion, call,
- allocate_completion(call), call_list);
+ allocate_completion(call), closure_list);
}
static int are_write_flags_valid(gpr_uint32 flags) {
@@ -1582,10 +1584,10 @@ grpc_call_error grpc_call_start_batch(grpc_call *call, const grpc_op *ops,
size_t out;
const grpc_op *op;
grpc_ioreq *req;
- void (*finish_func)(grpc_call *, int, void *, grpc_call_list *) =
+ void (*finish_func)(grpc_call *, int, void *, grpc_closure_list *) =
finish_batch;
grpc_call_error error;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
if (reserved != NULL) {
error = GRPC_CALL_ERROR;
@@ -1598,7 +1600,7 @@ grpc_call_error grpc_call_start_batch(grpc_call *call, const grpc_op *ops,
grpc_cq_begin_op(call->cq);
GRPC_CALL_INTERNAL_REF(call, "completion");
grpc_cq_end_op(call->cq, tag, 1, done_completion, call,
- allocate_completion(call), &call_list);
+ allocate_completion(call), &closure_list);
error = GRPC_CALL_OK;
goto done;
}
@@ -1817,9 +1819,9 @@ grpc_call_error grpc_call_start_batch(grpc_call *call, const grpc_op *ops,
grpc_cq_begin_op(call->cq);
error = grpc_call_start_ioreq_and_call_back(call, reqs, out, finish_func, tag,
- &call_list);
+ &closure_list);
done:
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
return error;
}
diff --git a/src/core/surface/call.h b/src/core/surface/call.h
index 144aa7cef2ca69fdafd7865fb228519a50368683..4476ab915bebee724e7f93fa515379bf287de0b2 100644
--- a/src/core/surface/call.h
+++ b/src/core/surface/call.h
@@ -88,7 +88,7 @@ typedef struct {
typedef void (*grpc_ioreq_completion_func)(grpc_call *call, int success,
void *user_data,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
grpc_call *grpc_call_create(grpc_channel *channel, grpc_call *parent_call,
gpr_uint32 propagation_mask,
@@ -99,29 +99,29 @@ grpc_call *grpc_call_create(grpc_channel *channel, grpc_call *parent_call,
gpr_timespec send_deadline);
void grpc_call_set_completion_queue(grpc_call *call, grpc_completion_queue *cq,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
grpc_completion_queue *grpc_call_get_completion_queue(grpc_call *call);
#ifdef GRPC_CALL_REF_COUNT_DEBUG
void grpc_call_internal_ref(grpc_call *call, const char *reason);
void grpc_call_internal_unref(grpc_call *call, const char *reason,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
#define GRPC_CALL_INTERNAL_REF(call, reason) \
grpc_call_internal_ref(call, reason)
-#define GRPC_CALL_INTERNAL_UNREF(call, reason, call_list) \
- grpc_call_internal_unref(call, reason, call_list)
+#define GRPC_CALL_INTERNAL_UNREF(call, reason, closure_list) \
+ grpc_call_internal_unref(call, reason, closure_list)
#else
void grpc_call_internal_ref(grpc_call *call);
-void grpc_call_internal_unref(grpc_call *call, grpc_call_list *call_list);
+void grpc_call_internal_unref(grpc_call *call, grpc_closure_list *closure_list);
#define GRPC_CALL_INTERNAL_REF(call, reason) grpc_call_internal_ref(call)
-#define GRPC_CALL_INTERNAL_UNREF(call, reason, call_list) \
- grpc_call_internal_unref(call, call_list)
+#define GRPC_CALL_INTERNAL_UNREF(call, reason, closure_list) \
+ grpc_call_internal_unref(call, closure_list)
#endif
grpc_call_error grpc_call_start_ioreq_and_call_back(
grpc_call *call, const grpc_ioreq *reqs, size_t nreqs,
grpc_ioreq_completion_func on_complete, void *user_data,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
grpc_call_stack *grpc_call_get_call_stack(grpc_call *call);
diff --git a/src/core/surface/channel.c b/src/core/surface/channel.c
index b00096f6fa243bb57ade6345dda4f88ce74c734a..1214425e0904657e4794d9bf0b1359f47b4f11c6 100644
--- a/src/core/surface/channel.c
+++ b/src/core/surface/channel.c
@@ -92,7 +92,7 @@ struct grpc_channel {
grpc_channel *grpc_channel_create_from_filters(
const char *target, const grpc_channel_filter **filters, size_t num_filters,
const grpc_channel_args *args, grpc_mdctx *mdctx, int is_client,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t i;
size_t size =
sizeof(grpc_channel) + grpc_channel_stack_size(filters, num_filters);
@@ -179,7 +179,7 @@ grpc_channel *grpc_channel_create_from_filters(
grpc_channel_stack_init(filters, num_filters, channel, args,
channel->metadata_context,
- CHANNEL_STACK_FROM_CHANNEL(channel), call_list);
+ CHANNEL_STACK_FROM_CHANNEL(channel), closure_list);
return channel;
}
@@ -270,9 +270,10 @@ void grpc_channel_internal_ref(grpc_channel *c) {
gpr_ref(&c->refs);
}
-static void destroy_channel(grpc_channel *channel, grpc_call_list *call_list) {
+static void destroy_channel(grpc_channel *channel,
+ grpc_closure_list *closure_list) {
size_t i;
- grpc_channel_stack_destroy(CHANNEL_STACK_FROM_CHANNEL(channel), call_list);
+ grpc_channel_stack_destroy(CHANNEL_STACK_FROM_CHANNEL(channel), closure_list);
for (i = 0; i < NUM_CACHED_STATUS_ELEMS; i++) {
GRPC_MDELEM_UNREF(channel->grpc_status_elem[i]);
}
@@ -302,30 +303,30 @@ static void destroy_channel(grpc_channel *channel, grpc_call_list *call_list) {
#ifdef GRPC_CHANNEL_REF_COUNT_DEBUG
void grpc_channel_internal_unref(grpc_channel *channel, const char *reason,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
gpr_log(GPR_DEBUG, "CHANNEL: unref %p %d -> %d [%s]", channel,
channel->refs.count, channel->refs.count - 1, reason);
#else
void grpc_channel_internal_unref(grpc_channel *channel,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
#endif
if (gpr_unref(&channel->refs)) {
- destroy_channel(channel, call_list);
+ destroy_channel(channel, closure_list);
}
}
void grpc_channel_destroy(grpc_channel *channel) {
grpc_transport_op op;
grpc_channel_element *elem;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
memset(&op, 0, sizeof(op));
op.disconnect = 1;
elem = grpc_channel_stack_element(CHANNEL_STACK_FROM_CHANNEL(channel), 0);
- elem->filter->start_transport_op(elem, &op, &call_list);
+ elem->filter->start_transport_op(elem, &op, &closure_list);
- GRPC_CHANNEL_INTERNAL_UNREF(channel, "channel", &call_list);
+ GRPC_CHANNEL_INTERNAL_UNREF(channel, "channel", &closure_list);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
grpc_channel_stack *grpc_channel_get_channel_stack(grpc_channel *channel) {
diff --git a/src/core/surface/channel.h b/src/core/surface/channel.h
index 2a249c9c51ac633fbaac08902acf103caa705446..e9c29481474e80404573e72c9f95885f89862091 100644
--- a/src/core/surface/channel.h
+++ b/src/core/surface/channel.h
@@ -40,7 +40,7 @@
grpc_channel *grpc_channel_create_from_filters(
const char *target, const grpc_channel_filter **filters, size_t count,
const grpc_channel_args *args, grpc_mdctx *mdctx, int is_client,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** Get a (borrowed) pointer to this channels underlying channel stack */
grpc_channel_stack *grpc_channel_get_channel_stack(grpc_channel *channel);
@@ -65,19 +65,19 @@ gpr_uint32 grpc_channel_get_max_message_length(grpc_channel *channel);
#ifdef GRPC_CHANNEL_REF_COUNT_DEBUG
void grpc_channel_internal_ref(grpc_channel *channel, const char *reason);
void grpc_channel_internal_unref(grpc_channel *channel, const char *reason,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
#define GRPC_CHANNEL_INTERNAL_REF(channel, reason) \
grpc_channel_internal_ref(channel, reason)
-#define GRPC_CHANNEL_INTERNAL_UNREF(channel, reason, call_list) \
- grpc_channel_internal_unref(channel, reason, call_list)
+#define GRPC_CHANNEL_INTERNAL_UNREF(channel, reason, closure_list) \
+ grpc_channel_internal_unref(channel, reason, closure_list)
#else
void grpc_channel_internal_ref(grpc_channel *channel);
void grpc_channel_internal_unref(grpc_channel *channel,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
#define GRPC_CHANNEL_INTERNAL_REF(channel, reason) \
grpc_channel_internal_ref(channel)
-#define GRPC_CHANNEL_INTERNAL_UNREF(channel, reason, call_list) \
- grpc_channel_internal_unref(channel, call_list)
+#define GRPC_CHANNEL_INTERNAL_UNREF(channel, reason, closure_list) \
+ grpc_channel_internal_unref(channel, closure_list)
#endif
#endif /* GRPC_INTERNAL_CORE_SURFACE_CHANNEL_H */
diff --git a/src/core/surface/channel_connectivity.c b/src/core/surface/channel_connectivity.c
index 3e34e84f60123ddb4dc02a35b42f5d64eeea11b0..d09e9bef799088777d740ad8f6efc99ecd4eb22a 100644
--- a/src/core/surface/channel_connectivity.c
+++ b/src/core/surface/channel_connectivity.c
@@ -45,7 +45,7 @@ grpc_connectivity_state grpc_channel_check_connectivity_state(
/* forward through to the underlying client channel */
grpc_channel_element *client_channel_elem =
grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel));
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_connectivity_state state;
if (client_channel_elem->filter != &grpc_client_channel_filter) {
gpr_log(GPR_ERROR,
@@ -55,8 +55,8 @@ grpc_connectivity_state grpc_channel_check_connectivity_state(
return GRPC_CHANNEL_FATAL_FAILURE;
}
state = grpc_client_channel_check_connectivity_state(
- client_channel_elem, try_to_connect, &call_list);
- grpc_call_list_run(&call_list);
+ client_channel_elem, try_to_connect, &closure_list);
+ grpc_closure_list_run(&closure_list);
return state;
}
@@ -81,14 +81,15 @@ typedef struct {
void *tag;
} state_watcher;
-static void delete_state_watcher(state_watcher *w, grpc_call_list *call_list) {
- GRPC_CHANNEL_INTERNAL_UNREF(w->channel, "watch_connectivity", call_list);
+static void delete_state_watcher(state_watcher *w,
+ grpc_closure_list *closure_list) {
+ GRPC_CHANNEL_INTERNAL_UNREF(w->channel, "watch_connectivity", closure_list);
gpr_mu_destroy(&w->mu);
gpr_free(w);
}
static void finished_completion(void *pw, grpc_cq_completion *ignored,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
int delete = 0;
state_watcher *w = pw;
gpr_mu_lock(&w->mu);
@@ -108,12 +109,12 @@ static void finished_completion(void *pw, grpc_cq_completion *ignored,
gpr_mu_unlock(&w->mu);
if (delete) {
- delete_state_watcher(w, call_list);
+ delete_state_watcher(w, closure_list);
}
}
static void partly_done(state_watcher *w, int due_to_completion,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
int delete = 0;
grpc_channel_element *client_channel_elem = NULL;
@@ -122,15 +123,15 @@ static void partly_done(state_watcher *w, int due_to_completion,
w->removed = 1;
client_channel_elem = grpc_channel_stack_last_element(
grpc_channel_get_channel_stack(w->channel));
- grpc_client_channel_del_interested_party(client_channel_elem,
- grpc_cq_pollset(w->cq), call_list);
+ grpc_client_channel_del_interested_party(
+ client_channel_elem, grpc_cq_pollset(w->cq), closure_list);
}
gpr_mu_unlock(&w->mu);
if (due_to_completion) {
gpr_mu_lock(&w->mu);
w->success = 1;
gpr_mu_unlock(&w->mu);
- grpc_alarm_cancel(&w->alarm, call_list);
+ grpc_alarm_cancel(&w->alarm, closure_list);
}
gpr_mu_lock(&w->mu);
@@ -138,7 +139,7 @@ static void partly_done(state_watcher *w, int due_to_completion,
case WAITING:
w->phase = CALLING_BACK;
grpc_cq_end_op(w->cq, w->tag, w->success, finished_completion, w,
- &w->completion_storage, call_list);
+ &w->completion_storage, closure_list);
break;
case CALLING_BACK:
w->phase = CALLING_BACK_AND_FINISHED;
@@ -154,16 +155,18 @@ static void partly_done(state_watcher *w, int due_to_completion,
gpr_mu_unlock(&w->mu);
if (delete) {
- delete_state_watcher(w, call_list);
+ delete_state_watcher(w, closure_list);
}
}
-static void watch_complete(void *pw, int success, grpc_call_list *call_list) {
- partly_done(pw, 1, call_list);
+static void watch_complete(void *pw, int success,
+ grpc_closure_list *closure_list) {
+ partly_done(pw, 1, closure_list);
}
-static void timeout_complete(void *pw, int success, grpc_call_list *call_list) {
- partly_done(pw, 0, call_list);
+static void timeout_complete(void *pw, int success,
+ grpc_closure_list *closure_list) {
+ partly_done(pw, 0, closure_list);
}
void grpc_channel_watch_connectivity_state(
@@ -171,7 +174,7 @@ void grpc_channel_watch_connectivity_state(
gpr_timespec deadline, grpc_completion_queue *cq, void *tag) {
grpc_channel_element *client_channel_elem =
grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel));
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
state_watcher *w = gpr_malloc(sizeof(*w));
grpc_cq_begin_op(cq);
@@ -188,21 +191,21 @@ void grpc_channel_watch_connectivity_state(
grpc_alarm_init(
&w->alarm, gpr_convert_clock_type(deadline, GPR_CLOCK_MONOTONIC),
- timeout_complete, w, gpr_now(GPR_CLOCK_MONOTONIC), &call_list);
+ timeout_complete, w, gpr_now(GPR_CLOCK_MONOTONIC), &closure_list);
if (client_channel_elem->filter != &grpc_client_channel_filter) {
gpr_log(GPR_ERROR,
"grpc_channel_watch_connectivity_state called on something that is "
"not a client channel, but '%s'",
client_channel_elem->filter->name);
- grpc_call_list_add(&call_list, &w->on_complete, 1);
+ grpc_closure_list_add(&closure_list, &w->on_complete, 1);
} else {
GRPC_CHANNEL_INTERNAL_REF(channel, "watch_connectivity");
- grpc_client_channel_add_interested_party(client_channel_elem,
- grpc_cq_pollset(cq), &call_list);
- grpc_client_channel_watch_connectivity_state(client_channel_elem, &w->state,
- &w->on_complete, &call_list);
+ grpc_client_channel_add_interested_party(
+ client_channel_elem, grpc_cq_pollset(cq), &closure_list);
+ grpc_client_channel_watch_connectivity_state(
+ client_channel_elem, &w->state, &w->on_complete, &closure_list);
}
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
diff --git a/src/core/surface/channel_create.c b/src/core/surface/channel_create.c
index f48fa4ed83d2b6a89cd0bcc73fc7bce208654d83..fc9ed5849163af4f50f266dd9904be19239a0280 100644
--- a/src/core/surface/channel_create.c
+++ b/src/core/surface/channel_create.c
@@ -68,7 +68,8 @@ static void connector_ref(grpc_connector *con) {
gpr_ref(&c->refs);
}
-static void connector_unref(grpc_connector *con, grpc_call_list *call_list) {
+static void connector_unref(grpc_connector *con,
+ grpc_closure_list *closure_list) {
connector *c = (connector *)con;
if (gpr_unref(&c->refs)) {
grpc_mdctx_unref(c->mdctx);
@@ -76,15 +77,15 @@ static void connector_unref(grpc_connector *con, grpc_call_list *call_list) {
}
}
-static void connected(void *arg, int success, grpc_call_list *call_list) {
+static void connected(void *arg, int success, grpc_closure_list *closure_list) {
connector *c = arg;
grpc_closure *notify;
grpc_endpoint *tcp = c->tcp;
if (tcp != NULL) {
c->result->transport = grpc_create_chttp2_transport(
- c->args.channel_args, tcp, c->mdctx, 1, call_list);
+ c->args.channel_args, tcp, c->mdctx, 1, closure_list);
grpc_chttp2_transport_start_reading(c->result->transport, NULL, 0,
- call_list);
+ closure_list);
GPR_ASSERT(c->result->transport);
c->result->filters = gpr_malloc(sizeof(grpc_channel_filter *));
c->result->filters[0] = &grpc_http_client_filter;
@@ -94,16 +95,17 @@ static void connected(void *arg, int success, grpc_call_list *call_list) {
}
notify = c->notify;
c->notify = NULL;
- notify->cb(notify->cb_arg, 1, call_list);
+ notify->cb(notify->cb_arg, 1, closure_list);
}
-static void connector_shutdown(grpc_connector *con, grpc_call_list *call_list) {
-}
+static void connector_shutdown(grpc_connector *con,
+ grpc_closure_list *closure_list) {}
static void connector_connect(grpc_connector *con,
const grpc_connect_in_args *args,
grpc_connect_out_args *result,
- grpc_closure *notify, grpc_call_list *call_list) {
+ grpc_closure *notify,
+ grpc_closure_list *closure_list) {
connector *c = (connector *)con;
GPR_ASSERT(c->notify == NULL);
GPR_ASSERT(notify->cb);
@@ -114,7 +116,7 @@ static void connector_connect(grpc_connector *con,
grpc_closure_init(&c->connected, connected, c);
grpc_tcp_client_connect(&c->connected, &c->tcp, args->interested_parties,
args->addr, args->addr_len, args->deadline,
- call_list);
+ closure_list);
}
static const grpc_connector_vtable connector_vtable = {
@@ -134,10 +136,10 @@ static void subchannel_factory_ref(grpc_subchannel_factory *scf) {
}
static void subchannel_factory_unref(grpc_subchannel_factory *scf,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
subchannel_factory *f = (subchannel_factory *)scf;
if (gpr_unref(&f->refs)) {
- GRPC_CHANNEL_INTERNAL_UNREF(f->master, "subchannel_factory", call_list);
+ GRPC_CHANNEL_INTERNAL_UNREF(f->master, "subchannel_factory", closure_list);
grpc_channel_args_destroy(f->merge_args);
grpc_mdctx_unref(f->mdctx);
gpr_free(f);
@@ -146,7 +148,7 @@ static void subchannel_factory_unref(grpc_subchannel_factory *scf,
static grpc_subchannel *subchannel_factory_create_subchannel(
grpc_subchannel_factory *scf, grpc_subchannel_args *args,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
subchannel_factory *f = (subchannel_factory *)scf;
connector *c = gpr_malloc(sizeof(*c));
grpc_channel_args *final_args =
@@ -161,7 +163,7 @@ static grpc_subchannel *subchannel_factory_create_subchannel(
args->args = final_args;
args->master = f->master;
s = grpc_subchannel_create(&c->base, args);
- grpc_connector_unref(&c->base, call_list);
+ grpc_connector_unref(&c->base, closure_list);
grpc_channel_args_destroy(final_args);
return s;
}
@@ -183,7 +185,7 @@ grpc_channel *grpc_insecure_channel_create(const char *target,
grpc_resolver *resolver;
subchannel_factory *f;
grpc_mdctx *mdctx = grpc_mdctx_create();
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
size_t n = 0;
GPR_ASSERT(!reserved);
if (grpc_channel_args_is_census_enabled(args)) {
@@ -194,7 +196,7 @@ grpc_channel *grpc_insecure_channel_create(const char *target,
GPR_ASSERT(n <= MAX_FILTERS);
channel = grpc_channel_create_from_filters(target, filters, n, args, mdctx, 1,
- &call_list);
+ &closure_list);
f = gpr_malloc(sizeof(*f));
f->base.vtable = &subchannel_factory_vtable;
@@ -210,11 +212,11 @@ grpc_channel *grpc_insecure_channel_create(const char *target,
}
grpc_client_channel_set_resolver(grpc_channel_get_channel_stack(channel),
- resolver, &call_list);
- GRPC_RESOLVER_UNREF(resolver, "create", &call_list);
- grpc_subchannel_factory_unref(&f->base, &call_list);
+ resolver, &closure_list);
+ GRPC_RESOLVER_UNREF(resolver, "create", &closure_list);
+ grpc_subchannel_factory_unref(&f->base, &closure_list);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
return channel;
}
diff --git a/src/core/surface/completion_queue.c b/src/core/surface/completion_queue.c
index 49dfc3c0e1c7ca49502629f48f9594b1529fcab4..cb839b069d57c4fdbe8339577b2c352a2d45c07f 100644
--- a/src/core/surface/completion_queue.c
+++ b/src/core/surface/completion_queue.c
@@ -71,7 +71,7 @@ struct grpc_completion_queue {
};
static void on_pollset_destroy_done(void *cc, int success,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
grpc_completion_queue *grpc_completion_queue_create(void *reserved) {
grpc_completion_queue *cc = gpr_malloc(sizeof(grpc_completion_queue));
@@ -100,7 +100,7 @@ void grpc_cq_internal_ref(grpc_completion_queue *cc) {
}
static void on_pollset_destroy_done(void *arg, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_completion_queue *cc = arg;
GRPC_CQ_INTERNAL_UNREF(cc, "pollset_destroy");
}
@@ -134,9 +134,9 @@ void grpc_cq_begin_op(grpc_completion_queue *cc) {
/* Queue a GRPC_OP_COMPLETED operation */
void grpc_cq_end_op(grpc_completion_queue *cc, void *tag, int success,
void (*done)(void *done_arg, grpc_cq_completion *storage,
- grpc_call_list *call_list),
+ grpc_closure_list *closure_list),
void *done_arg, grpc_cq_completion *storage,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
int shutdown;
int i;
grpc_pollset_worker *pluck_worker;
@@ -170,7 +170,8 @@ void grpc_cq_end_op(grpc_completion_queue *cc, void *tag, int success,
GPR_ASSERT(cc->shutdown_called);
cc->shutdown = 1;
gpr_mu_unlock(GRPC_POLLSET_MU(&cc->pollset));
- grpc_pollset_shutdown(&cc->pollset, &cc->pollset_destroy_done, call_list);
+ grpc_pollset_shutdown(&cc->pollset, &cc->pollset_destroy_done,
+ closure_list);
}
}
@@ -180,7 +181,7 @@ grpc_event grpc_completion_queue_next(grpc_completion_queue *cc,
grpc_pollset_worker worker;
int first_loop = 1;
gpr_timespec now;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
GPR_ASSERT(!reserved);
@@ -199,7 +200,7 @@ grpc_event grpc_completion_queue_next(grpc_completion_queue *cc,
ret.type = GRPC_OP_COMPLETE;
ret.success = c->next & 1u;
ret.tag = c->tag;
- c->done(c->done_arg, c, &call_list);
+ c->done(c->done_arg, c, &closure_list);
break;
}
if (cc->shutdown) {
@@ -216,11 +217,11 @@ grpc_event grpc_completion_queue_next(grpc_completion_queue *cc,
break;
}
first_loop = 0;
- grpc_pollset_work(&cc->pollset, &worker, now, deadline, &call_list);
+ grpc_pollset_work(&cc->pollset, &worker, now, deadline, &closure_list);
}
GRPC_SURFACE_TRACE_RETURNED_EVENT(cc, &ret);
GRPC_CQ_INTERNAL_UNREF(cc, "next");
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
return ret;
}
@@ -257,7 +258,7 @@ grpc_event grpc_completion_queue_pluck(grpc_completion_queue *cc, void *tag,
grpc_pollset_worker worker;
gpr_timespec now;
int first_loop = 1;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
GPR_ASSERT(!reserved);
@@ -279,7 +280,7 @@ grpc_event grpc_completion_queue_pluck(grpc_completion_queue *cc, void *tag,
ret.type = GRPC_OP_COMPLETE;
ret.success = c->next & 1u;
ret.tag = c->tag;
- c->done(c->done_arg, c, &call_list);
+ c->done(c->done_arg, c, &closure_list);
goto done;
}
prev = c;
@@ -310,20 +311,20 @@ grpc_event grpc_completion_queue_pluck(grpc_completion_queue *cc, void *tag,
break;
}
first_loop = 0;
- grpc_pollset_work(&cc->pollset, &worker, now, deadline, &call_list);
+ grpc_pollset_work(&cc->pollset, &worker, now, deadline, &closure_list);
del_plucker(cc, tag, &worker);
}
done:
GRPC_SURFACE_TRACE_RETURNED_EVENT(cc, &ret);
GRPC_CQ_INTERNAL_UNREF(cc, "pluck");
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
return ret;
}
/* Shutdown simply drops a ref that we reserved at creation time; if we drop
to zero here, then enter shutdown mode and wake up any waiters */
void grpc_completion_queue_shutdown(grpc_completion_queue *cc) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
gpr_mu_lock(GRPC_POLLSET_MU(&cc->pollset));
if (cc->shutdown_called) {
gpr_mu_unlock(GRPC_POLLSET_MU(&cc->pollset));
@@ -337,9 +338,10 @@ void grpc_completion_queue_shutdown(grpc_completion_queue *cc) {
GPR_ASSERT(!cc->shutdown);
cc->shutdown = 1;
gpr_mu_unlock(GRPC_POLLSET_MU(&cc->pollset));
- grpc_pollset_shutdown(&cc->pollset, &cc->pollset_destroy_done, &call_list);
+ grpc_pollset_shutdown(&cc->pollset, &cc->pollset_destroy_done,
+ &closure_list);
}
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
void grpc_completion_queue_destroy(grpc_completion_queue *cc) {
diff --git a/src/core/surface/completion_queue.h b/src/core/surface/completion_queue.h
index 6d8d1ce959380404f262939358fcad4aa4c4bea8..7e88b471da0fa725877d671e9179f226bcb86293 100644
--- a/src/core/surface/completion_queue.h
+++ b/src/core/surface/completion_queue.h
@@ -45,7 +45,7 @@ typedef struct grpc_cq_completion {
/** done callback - called when this queue element is no longer
needed by the completion queue */
void (*done)(void *done_arg, struct grpc_cq_completion *c,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void *done_arg;
/** next pointer; low bit is used to indicate success or not */
gpr_uintptr next;
@@ -74,9 +74,9 @@ void grpc_cq_begin_op(grpc_completion_queue *cc);
/* Queue a GRPC_OP_COMPLETED operation */
void grpc_cq_end_op(grpc_completion_queue *cc, void *tag, int success,
void (*done)(void *done_arg, grpc_cq_completion *storage,
- grpc_call_list *call_list),
+ grpc_closure_list *closure_list),
void *done_arg, grpc_cq_completion *storage,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
grpc_pollset *grpc_cq_pollset(grpc_completion_queue *cc);
diff --git a/src/core/surface/lame_client.c b/src/core/surface/lame_client.c
index 2af028960d71ce4c54f8f46f284f44b2ec650e18..53334e7c5bf34deba2695a530e076575972b9d41 100644
--- a/src/core/surface/lame_client.c
+++ b/src/core/surface/lame_client.c
@@ -56,13 +56,13 @@ typedef struct {
static void lame_start_transport_stream_op(grpc_call_element *elem,
grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
call_data *calld = elem->call_data;
channel_data *chand = elem->channel_data;
GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
if (op->send_ops != NULL) {
grpc_stream_ops_unref_owned_objects(op->send_ops->ops, op->send_ops->nops);
- op->on_done_send->cb(op->on_done_send->cb_arg, 0, call_list);
+ op->on_done_send->cb(op->on_done_send->cb_arg, 0, closure_list);
}
if (op->recv_ops != NULL) {
char tmp[GPR_LTOA_MIN_BUFSIZE];
@@ -81,48 +81,49 @@ static void lame_start_transport_stream_op(grpc_call_element *elem,
mdb.deadline = gpr_inf_future(GPR_CLOCK_REALTIME);
grpc_sopb_add_metadata(op->recv_ops, mdb);
*op->recv_state = GRPC_STREAM_CLOSED;
- op->on_done_recv->cb(op->on_done_recv->cb_arg, 1, call_list);
+ op->on_done_recv->cb(op->on_done_recv->cb_arg, 1, closure_list);
}
if (op->on_consumed != NULL) {
- op->on_consumed->cb(op->on_consumed->cb_arg, 0, call_list);
+ op->on_consumed->cb(op->on_consumed->cb_arg, 0, closure_list);
}
}
-static char *lame_get_peer(grpc_call_element *elem, grpc_call_list *call_list) {
+static char *lame_get_peer(grpc_call_element *elem,
+ grpc_closure_list *closure_list) {
channel_data *chand = elem->channel_data;
return grpc_channel_get_target(chand->master);
}
static void lame_start_transport_op(grpc_channel_element *elem,
grpc_transport_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
if (op->on_connectivity_state_change) {
GPR_ASSERT(*op->connectivity_state != GRPC_CHANNEL_FATAL_FAILURE);
*op->connectivity_state = GRPC_CHANNEL_FATAL_FAILURE;
op->on_connectivity_state_change->cb(
- op->on_connectivity_state_change->cb_arg, 1, call_list);
+ op->on_connectivity_state_change->cb_arg, 1, closure_list);
}
if (op->on_consumed != NULL) {
- op->on_consumed->cb(op->on_consumed->cb_arg, 1, call_list);
+ op->on_consumed->cb(op->on_consumed->cb_arg, 1, closure_list);
}
}
static void init_call_elem(grpc_call_element *elem,
const void *transport_server_data,
grpc_transport_stream_op *initial_op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
if (initial_op) {
- grpc_transport_stream_op_finish_with_failure(initial_op, call_list);
+ grpc_transport_stream_op_finish_with_failure(initial_op, closure_list);
}
}
static void destroy_call_elem(grpc_call_element *elem,
- grpc_call_list *call_list) {}
+ grpc_closure_list *closure_list) {}
static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
const grpc_channel_args *args, grpc_mdctx *mdctx,
int is_first, int is_last,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
channel_data *chand = elem->channel_data;
GPR_ASSERT(is_first);
GPR_ASSERT(is_last);
@@ -131,7 +132,7 @@ static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
}
static void destroy_channel_elem(grpc_channel_element *elem,
- grpc_call_list *call_list) {}
+ grpc_closure_list *closure_list) {}
static const grpc_channel_filter lame_filter = {
lame_start_transport_stream_op,
@@ -154,15 +155,15 @@ grpc_channel *grpc_lame_client_channel_create(const char *target,
grpc_channel *channel;
grpc_channel_element *elem;
channel_data *chand;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
static const grpc_channel_filter *filters[] = {&lame_filter};
channel = grpc_channel_create_from_filters(
- target, filters, 1, NULL, grpc_mdctx_create(), 1, &call_list);
+ target, filters, 1, NULL, grpc_mdctx_create(), 1, &closure_list);
elem = grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0);
GPR_ASSERT(elem->filter == &lame_filter);
chand = (channel_data *)elem->channel_data;
chand->error_code = error_code;
chand->error_message = error_message;
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
return channel;
}
diff --git a/src/core/surface/secure_channel_create.c b/src/core/surface/secure_channel_create.c
index c2d571d955c526f111a36e4a533659f324ca5f70..45567428e908bd49b4a68e26bef51f589d56001f 100644
--- a/src/core/surface/secure_channel_create.c
+++ b/src/core/surface/secure_channel_create.c
@@ -75,7 +75,8 @@ static void connector_ref(grpc_connector *con) {
gpr_ref(&c->refs);
}
-static void connector_unref(grpc_connector *con, grpc_call_list *call_list) {
+static void connector_unref(grpc_connector *con,
+ grpc_closure_list *closure_list) {
connector *c = (connector *)con;
if (gpr_unref(&c->refs)) {
grpc_mdctx_unref(c->mdctx);
@@ -86,7 +87,7 @@ static void connector_unref(grpc_connector *con, grpc_call_list *call_list) {
static void on_secure_handshake_done(void *arg, grpc_security_status status,
grpc_endpoint *wrapped_endpoint,
grpc_endpoint *secure_endpoint,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
connector *c = arg;
grpc_closure *notify;
gpr_mu_lock(&c->mu);
@@ -104,9 +105,9 @@ static void on_secure_handshake_done(void *arg, grpc_security_status status,
c->connecting_endpoint = NULL;
gpr_mu_unlock(&c->mu);
c->result->transport = grpc_create_chttp2_transport(
- c->args.channel_args, secure_endpoint, c->mdctx, 1, call_list);
+ c->args.channel_args, secure_endpoint, c->mdctx, 1, closure_list);
grpc_chttp2_transport_start_reading(c->result->transport, NULL, 0,
- call_list);
+ closure_list);
c->result->filters = gpr_malloc(sizeof(grpc_channel_filter *) * 2);
c->result->filters[0] = &grpc_http_client_filter;
c->result->filters[1] = &grpc_client_auth_filter;
@@ -114,10 +115,10 @@ static void on_secure_handshake_done(void *arg, grpc_security_status status,
}
notify = c->notify;
c->notify = NULL;
- notify->cb(notify->cb_arg, 1, call_list);
+ notify->cb(notify->cb_arg, 1, closure_list);
}
-static void connected(void *arg, int success, grpc_call_list *call_list) {
+static void connected(void *arg, int success, grpc_closure_list *closure_list) {
connector *c = arg;
grpc_closure *notify;
grpc_endpoint *tcp = c->newly_connecting_endpoint;
@@ -128,16 +129,17 @@ static void connected(void *arg, int success, grpc_call_list *call_list) {
gpr_mu_unlock(&c->mu);
grpc_security_connector_do_handshake(&c->security_connector->base, tcp,
on_secure_handshake_done, c,
- call_list);
+ closure_list);
} else {
memset(c->result, 0, sizeof(*c->result));
notify = c->notify;
c->notify = NULL;
- notify->cb(notify->cb_arg, 1, call_list);
+ notify->cb(notify->cb_arg, 1, closure_list);
}
}
-static void connector_shutdown(grpc_connector *con, grpc_call_list *call_list) {
+static void connector_shutdown(grpc_connector *con,
+ grpc_closure_list *closure_list) {
connector *c = (connector *)con;
grpc_endpoint *ep;
gpr_mu_lock(&c->mu);
@@ -145,14 +147,15 @@ static void connector_shutdown(grpc_connector *con, grpc_call_list *call_list) {
c->connecting_endpoint = NULL;
gpr_mu_unlock(&c->mu);
if (ep) {
- grpc_endpoint_shutdown(ep, call_list);
+ grpc_endpoint_shutdown(ep, closure_list);
}
}
static void connector_connect(grpc_connector *con,
const grpc_connect_in_args *args,
grpc_connect_out_args *result,
- grpc_closure *notify, grpc_call_list *call_list) {
+ grpc_closure *notify,
+ grpc_closure_list *closure_list) {
connector *c = (connector *)con;
GPR_ASSERT(c->notify == NULL);
GPR_ASSERT(notify->cb);
@@ -165,7 +168,7 @@ static void connector_connect(grpc_connector *con,
grpc_closure_init(&c->connected_closure, connected, c);
grpc_tcp_client_connect(&c->connected_closure, &c->newly_connecting_endpoint,
args->interested_parties, args->addr, args->addr_len,
- args->deadline, call_list);
+ args->deadline, closure_list);
}
static const grpc_connector_vtable connector_vtable = {
@@ -186,12 +189,12 @@ static void subchannel_factory_ref(grpc_subchannel_factory *scf) {
}
static void subchannel_factory_unref(grpc_subchannel_factory *scf,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
subchannel_factory *f = (subchannel_factory *)scf;
if (gpr_unref(&f->refs)) {
GRPC_SECURITY_CONNECTOR_UNREF(&f->security_connector->base,
"subchannel_factory");
- GRPC_CHANNEL_INTERNAL_UNREF(f->master, "subchannel_factory", call_list);
+ GRPC_CHANNEL_INTERNAL_UNREF(f->master, "subchannel_factory", closure_list);
grpc_channel_args_destroy(f->merge_args);
grpc_mdctx_unref(f->mdctx);
gpr_free(f);
@@ -200,7 +203,7 @@ static void subchannel_factory_unref(grpc_subchannel_factory *scf,
static grpc_subchannel *subchannel_factory_create_subchannel(
grpc_subchannel_factory *scf, grpc_subchannel_args *args,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
subchannel_factory *f = (subchannel_factory *)scf;
connector *c = gpr_malloc(sizeof(*c));
grpc_channel_args *final_args =
@@ -216,7 +219,7 @@ static grpc_subchannel *subchannel_factory_create_subchannel(
args->master = f->master;
args->mdctx = f->mdctx;
s = grpc_subchannel_create(&c->base, args);
- grpc_connector_unref(&c->base, call_list);
+ grpc_connector_unref(&c->base, closure_list);
grpc_channel_args_destroy(final_args);
return s;
}
@@ -243,7 +246,7 @@ grpc_channel *grpc_secure_channel_create(grpc_credentials *creds,
subchannel_factory *f;
#define MAX_FILTERS 3
const grpc_channel_filter *filters[MAX_FILTERS];
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
size_t n = 0;
GPR_ASSERT(reserved == NULL);
@@ -275,7 +278,7 @@ grpc_channel *grpc_secure_channel_create(grpc_credentials *creds,
GPR_ASSERT(n <= MAX_FILTERS);
channel = grpc_channel_create_from_filters(target, filters, n, args_copy,
- mdctx, 1, &call_list);
+ mdctx, 1, &closure_list);
f = gpr_malloc(sizeof(*f));
f->base.vtable = &subchannel_factory_vtable;
@@ -293,9 +296,9 @@ grpc_channel *grpc_secure_channel_create(grpc_credentials *creds,
}
grpc_client_channel_set_resolver(grpc_channel_get_channel_stack(channel),
- resolver, &call_list);
- GRPC_RESOLVER_UNREF(resolver, "create", &call_list);
- grpc_subchannel_factory_unref(&f->base, &call_list);
+ resolver, &closure_list);
+ GRPC_RESOLVER_UNREF(resolver, "create", &closure_list);
+ grpc_subchannel_factory_unref(&f->base, &closure_list);
GRPC_SECURITY_CONNECTOR_UNREF(&connector->base, "channel_create");
grpc_channel_args_destroy(args_copy);
@@ -303,7 +306,7 @@ grpc_channel *grpc_secure_channel_create(grpc_credentials *creds,
grpc_channel_args_destroy(new_args_from_connector);
}
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
return channel;
}
diff --git a/src/core/surface/server.c b/src/core/surface/server.c
index 4249e6f9bd0445e241d3a57f6df361aef4dcd975..520065a484127d55c7b1ce2d81d4dad6e06cac72 100644
--- a/src/core/surface/server.c
+++ b/src/core/surface/server.c
@@ -57,9 +57,9 @@
typedef struct listener {
void *arg;
void (*start)(grpc_server *server, void *arg, grpc_pollset **pollsets,
- size_t pollset_count, grpc_call_list *call_list);
+ size_t pollset_count, grpc_closure_list *closure_list);
void (*destroy)(grpc_server *server, void *arg, grpc_closure *closure,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
struct listener *next;
grpc_closure destroy_done;
} listener;
@@ -227,13 +227,13 @@ struct grpc_server {
(((channel_data *)(elem)->channel_data)->server)
static void begin_call(grpc_server *server, call_data *calld,
- requested_call *rc, grpc_call_list *call_list);
+ requested_call *rc, grpc_closure_list *closure_list);
static void fail_call(grpc_server *server, requested_call *rc,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Before calling maybe_finish_shutdown, we must hold mu_global and not
hold mu_call */
static void maybe_finish_shutdown(grpc_server *server,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/*
* channel broadcaster
@@ -261,14 +261,15 @@ struct shutdown_cleanup_args {
};
static void shutdown_cleanup(void *arg, int iomgr_status_ignored,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
struct shutdown_cleanup_args *a = arg;
gpr_slice_unref(a->slice);
gpr_free(a);
}
static void send_shutdown(grpc_channel *channel, int send_goaway,
- int send_disconnect, grpc_call_list *call_list) {
+ int send_disconnect,
+ grpc_closure_list *closure_list) {
grpc_transport_op op;
struct shutdown_cleanup_args *sc;
grpc_channel_element *elem;
@@ -284,17 +285,17 @@ static void send_shutdown(grpc_channel *channel, int send_goaway,
op.on_consumed = &sc->closure;
elem = grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0);
- elem->filter->start_transport_op(elem, &op, call_list);
+ elem->filter->start_transport_op(elem, &op, closure_list);
}
static void channel_broadcaster_shutdown(channel_broadcaster *cb,
int send_goaway, int force_disconnect,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t i;
for (i = 0; i < cb->num_channels; i++) {
- send_shutdown(cb->channels[i], send_goaway, force_disconnect, call_list);
- GRPC_CHANNEL_INTERNAL_UNREF(cb->channels[i], "broadcast", call_list);
+ send_shutdown(cb->channels[i], send_goaway, force_disconnect, closure_list);
+ GRPC_CHANNEL_INTERNAL_UNREF(cb->channels[i], "broadcast", closure_list);
}
gpr_free(cb->channels);
}
@@ -314,12 +315,13 @@ static void request_matcher_destroy(request_matcher *request_matcher) {
gpr_stack_lockfree_destroy(request_matcher->requests);
}
-static void kill_zombie(void *elem, int success, grpc_call_list *call_list) {
+static void kill_zombie(void *elem, int success,
+ grpc_closure_list *closure_list) {
grpc_call_destroy(grpc_call_from_top_element(elem));
}
static void request_matcher_zombify_all_pending_calls(
- request_matcher *request_matcher, grpc_call_list *call_list) {
+ request_matcher *request_matcher, grpc_closure_list *closure_list) {
while (request_matcher->pending_head) {
call_data *calld = request_matcher->pending_head;
request_matcher->pending_head = calld->pending_next;
@@ -329,16 +331,16 @@ static void request_matcher_zombify_all_pending_calls(
grpc_closure_init(
&calld->kill_zombie_closure, kill_zombie,
grpc_call_stack_element(grpc_call_get_call_stack(calld->call), 0));
- grpc_call_list_add(call_list, &calld->kill_zombie_closure, 1);
+ grpc_closure_list_add(closure_list, &calld->kill_zombie_closure, 1);
}
}
static void request_matcher_kill_requests(grpc_server *server,
request_matcher *rm,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
int request_id;
while ((request_id = gpr_stack_lockfree_pop(rm->requests)) != -1) {
- fail_call(server, &server->requested_calls[request_id], call_list);
+ fail_call(server, &server->requested_calls[request_id], closure_list);
}
}
@@ -350,7 +352,8 @@ static void server_ref(grpc_server *server) {
gpr_ref(&server->internal_refcount);
}
-static void server_delete(grpc_server *server, grpc_call_list *call_list) {
+static void server_delete(grpc_server *server,
+ grpc_closure_list *closure_list) {
registered_method *rm;
size_t i;
grpc_channel_args_destroy(server->channel_args);
@@ -376,9 +379,9 @@ static void server_delete(grpc_server *server, grpc_call_list *call_list) {
gpr_free(server);
}
-static void server_unref(grpc_server *server, grpc_call_list *call_list) {
+static void server_unref(grpc_server *server, grpc_closure_list *closure_list) {
if (gpr_unref(&server->internal_refcount)) {
- server_delete(server, call_list);
+ server_delete(server, closure_list);
}
}
@@ -393,28 +396,30 @@ static void orphan_channel(channel_data *chand) {
}
static void finish_destroy_channel(void *cd, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
channel_data *chand = cd;
grpc_server *server = chand->server;
gpr_log(GPR_DEBUG, "finish_destroy_channel: %p", chand->channel);
- GRPC_CHANNEL_INTERNAL_UNREF(chand->channel, "server", call_list);
- server_unref(server, call_list);
+ GRPC_CHANNEL_INTERNAL_UNREF(chand->channel, "server", closure_list);
+ server_unref(server, closure_list);
}
-static void destroy_channel(channel_data *chand, grpc_call_list *call_list) {
+static void destroy_channel(channel_data *chand,
+ grpc_closure_list *closure_list) {
if (is_channel_orphaned(chand)) return;
GPR_ASSERT(chand->server != NULL);
orphan_channel(chand);
server_ref(chand->server);
- maybe_finish_shutdown(chand->server, call_list);
+ maybe_finish_shutdown(chand->server, closure_list);
chand->finish_destroy_channel_closure.cb = finish_destroy_channel;
chand->finish_destroy_channel_closure.cb_arg = chand;
- grpc_call_list_add(call_list, &chand->finish_destroy_channel_closure, 1);
+ grpc_closure_list_add(closure_list, &chand->finish_destroy_channel_closure,
+ 1);
}
static void finish_start_new_rpc(grpc_server *server, grpc_call_element *elem,
request_matcher *request_matcher,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
call_data *calld = elem->call_data;
int request_id;
@@ -423,7 +428,7 @@ static void finish_start_new_rpc(grpc_server *server, grpc_call_element *elem,
calld->state = ZOMBIED;
gpr_mu_unlock(&calld->mu_state);
grpc_closure_init(&calld->kill_zombie_closure, kill_zombie, elem);
- grpc_call_list_add(call_list, &calld->kill_zombie_closure, 1);
+ grpc_closure_list_add(closure_list, &calld->kill_zombie_closure, 1);
return;
}
@@ -445,11 +450,13 @@ static void finish_start_new_rpc(grpc_server *server, grpc_call_element *elem,
gpr_mu_lock(&calld->mu_state);
calld->state = ACTIVATED;
gpr_mu_unlock(&calld->mu_state);
- begin_call(server, calld, &server->requested_calls[request_id], call_list);
+ begin_call(server, calld, &server->requested_calls[request_id],
+ closure_list);
}
}
-static void start_new_rpc(grpc_call_element *elem, grpc_call_list *call_list) {
+static void start_new_rpc(grpc_call_element *elem,
+ grpc_closure_list *closure_list) {
channel_data *chand = elem->channel_data;
call_data *calld = elem->call_data;
grpc_server *server = chand->server;
@@ -469,7 +476,7 @@ static void start_new_rpc(grpc_call_element *elem, grpc_call_list *call_list) {
if (rm->method != calld->path) continue;
finish_start_new_rpc(server, elem,
&rm->server_registered_method->request_matcher,
- call_list);
+ closure_list);
return;
}
/* check for a wildcard method definition (no host set) */
@@ -482,12 +489,12 @@ static void start_new_rpc(grpc_call_element *elem, grpc_call_list *call_list) {
if (rm->method != calld->path) continue;
finish_start_new_rpc(server, elem,
&rm->server_registered_method->request_matcher,
- call_list);
+ closure_list);
return;
}
}
finish_start_new_rpc(server, elem, &server->unregistered_request_matcher,
- call_list);
+ closure_list);
}
static int num_listeners(grpc_server *server) {
@@ -500,8 +507,8 @@ static int num_listeners(grpc_server *server) {
}
static void done_shutdown_event(void *server, grpc_cq_completion *completion,
- grpc_call_list *call_list) {
- server_unref(server, call_list);
+ grpc_closure_list *closure_list) {
+ server_unref(server, closure_list);
}
static int num_channels(grpc_server *server) {
@@ -515,26 +522,27 @@ static int num_channels(grpc_server *server) {
}
static void kill_pending_work_locked(grpc_server *server,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
registered_method *rm;
request_matcher_kill_requests(server, &server->unregistered_request_matcher,
- call_list);
+ closure_list);
request_matcher_zombify_all_pending_calls(
- &server->unregistered_request_matcher, call_list);
+ &server->unregistered_request_matcher, closure_list);
for (rm = server->registered_methods; rm; rm = rm->next) {
- request_matcher_kill_requests(server, &rm->request_matcher, call_list);
- request_matcher_zombify_all_pending_calls(&rm->request_matcher, call_list);
+ request_matcher_kill_requests(server, &rm->request_matcher, closure_list);
+ request_matcher_zombify_all_pending_calls(&rm->request_matcher,
+ closure_list);
}
}
static void maybe_finish_shutdown(grpc_server *server,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t i;
if (!gpr_atm_acq_load(&server->shutdown_flag) || server->shutdown_published) {
return;
}
- kill_pending_work_locked(server, call_list);
+ kill_pending_work_locked(server, closure_list);
if (server->root_channel_data.next != &server->root_channel_data ||
server->listeners_destroyed < num_listeners(server)) {
@@ -556,7 +564,7 @@ static void maybe_finish_shutdown(grpc_server *server,
server_ref(server);
grpc_cq_end_op(server->shutdown_tags[i].cq, server->shutdown_tags[i].tag, 1,
done_shutdown_event, server,
- &server->shutdown_tags[i].completion, call_list);
+ &server->shutdown_tags[i].completion, closure_list);
}
}
@@ -574,7 +582,8 @@ static grpc_mdelem *server_filter(void *user_data, grpc_mdelem *md) {
return md;
}
-static void server_on_recv(void *ptr, int success, grpc_call_list *call_list) {
+static void server_on_recv(void *ptr, int success,
+ grpc_closure_list *closure_list) {
grpc_call_element *elem = ptr;
call_data *calld = elem->call_data;
gpr_timespec op_deadline;
@@ -594,7 +603,7 @@ static void server_on_recv(void *ptr, int success, grpc_call_list *call_list) {
}
if (calld->host && calld->path) {
calld->got_initial_metadata = 1;
- start_new_rpc(elem, call_list);
+ start_new_rpc(elem, closure_list);
}
break;
}
@@ -611,7 +620,7 @@ static void server_on_recv(void *ptr, int success, grpc_call_list *call_list) {
calld->state = ZOMBIED;
gpr_mu_unlock(&calld->mu_state);
grpc_closure_init(&calld->kill_zombie_closure, kill_zombie, elem);
- grpc_call_list_add(call_list, &calld->kill_zombie_closure, 1);
+ grpc_closure_list_add(closure_list, &calld->kill_zombie_closure, 1);
} else {
gpr_mu_unlock(&calld->mu_state);
}
@@ -622,7 +631,7 @@ static void server_on_recv(void *ptr, int success, grpc_call_list *call_list) {
calld->state = ZOMBIED;
gpr_mu_unlock(&calld->mu_state);
grpc_closure_init(&calld->kill_zombie_closure, kill_zombie, elem);
- grpc_call_list_add(call_list, &calld->kill_zombie_closure, 1);
+ grpc_closure_list_add(closure_list, &calld->kill_zombie_closure, 1);
} else if (calld->state == PENDING) {
calld->state = ZOMBIED;
gpr_mu_unlock(&calld->mu_state);
@@ -634,7 +643,7 @@ static void server_on_recv(void *ptr, int success, grpc_call_list *call_list) {
break;
}
- calld->on_done_recv->cb(calld->on_done_recv->cb_arg, success, call_list);
+ calld->on_done_recv->cb(calld->on_done_recv->cb_arg, success, closure_list);
}
static void server_mutate_op(grpc_call_element *elem,
@@ -652,10 +661,10 @@ static void server_mutate_op(grpc_call_element *elem,
static void server_start_transport_stream_op(grpc_call_element *elem,
grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
server_mutate_op(elem, op);
- grpc_call_next_op(elem, op, call_list);
+ grpc_call_next_op(elem, op, closure_list);
}
static void accept_stream(void *cd, grpc_transport *transport,
@@ -667,7 +676,7 @@ static void accept_stream(void *cd, grpc_transport *transport,
}
static void channel_connectivity_changed(void *cd, int iomgr_status_ignored,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
channel_data *chand = cd;
grpc_server *server = chand->server;
if (chand->connectivity_state != GRPC_CHANNEL_FATAL_FAILURE) {
@@ -677,19 +686,19 @@ static void channel_connectivity_changed(void *cd, int iomgr_status_ignored,
op.connectivity_state = &chand->connectivity_state;
grpc_channel_next_op(grpc_channel_stack_element(
grpc_channel_get_channel_stack(chand->channel), 0),
- &op, call_list);
+ &op, closure_list);
} else {
gpr_mu_lock(&server->mu_global);
- destroy_channel(chand, call_list);
+ destroy_channel(chand, closure_list);
gpr_mu_unlock(&server->mu_global);
- GRPC_CHANNEL_INTERNAL_UNREF(chand->channel, "connectivity", call_list);
+ GRPC_CHANNEL_INTERNAL_UNREF(chand->channel, "connectivity", closure_list);
}
}
static 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) {
call_data *calld = elem->call_data;
channel_data *chand = elem->channel_data;
memset(calld, 0, sizeof(call_data));
@@ -705,7 +714,7 @@ static void init_call_elem(grpc_call_element *elem,
}
static void destroy_call_elem(grpc_call_element *elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
channel_data *chand = elem->channel_data;
call_data *calld = elem->call_data;
@@ -720,13 +729,13 @@ static void destroy_call_elem(grpc_call_element *elem,
gpr_mu_destroy(&calld->mu_state);
- server_unref(chand->server, call_list);
+ server_unref(chand->server, closure_list);
}
static 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) {
channel_data *chand = elem->channel_data;
GPR_ASSERT(is_first);
GPR_ASSERT(!is_last);
@@ -743,7 +752,7 @@ static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
}
static void destroy_channel_elem(grpc_channel_element *elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t i;
channel_data *chand = elem->channel_data;
if (chand->registered_methods) {
@@ -762,11 +771,11 @@ static void destroy_channel_elem(grpc_channel_element *elem,
chand->next->prev = chand->prev;
chand->prev->next = chand->next;
chand->next = chand->prev = chand;
- maybe_finish_shutdown(chand->server, call_list);
+ maybe_finish_shutdown(chand->server, closure_list);
gpr_mu_unlock(&chand->server->mu_global);
GRPC_MDSTR_UNREF(chand->path_key);
GRPC_MDSTR_UNREF(chand->authority_key);
- server_unref(chand->server, call_list);
+ server_unref(chand->server, closure_list);
}
}
@@ -890,7 +899,7 @@ void *grpc_server_register_method(grpc_server *server, const char *method,
void grpc_server_start(grpc_server *server) {
listener *l;
size_t i;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
server->pollsets = gpr_malloc(sizeof(grpc_pollset *) * server->cq_count);
for (i = 0; i < server->cq_count; i++) {
@@ -898,17 +907,17 @@ void grpc_server_start(grpc_server *server) {
}
for (l = server->listeners; l; l = l->next) {
- l->start(server, l->arg, server->pollsets, server->cq_count, &call_list);
+ l->start(server, l->arg, server->pollsets, server->cq_count, &closure_list);
}
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
void grpc_server_setup_transport(grpc_server *s, grpc_transport *transport,
grpc_channel_filter const **extra_filters,
size_t num_extra_filters, grpc_mdctx *mdctx,
const grpc_channel_args *args,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t num_filters = s->channel_filter_count + num_extra_filters + 1;
grpc_channel_filter const **filters =
gpr_malloc(sizeof(grpc_channel_filter *) * num_filters);
@@ -938,11 +947,11 @@ void grpc_server_setup_transport(grpc_server *s, grpc_transport *transport,
for (i = 0; i < s->cq_count; i++) {
memset(&op, 0, sizeof(op));
op.bind_pollset = grpc_cq_pollset(s->cqs[i]);
- grpc_transport_perform_op(transport, &op, call_list);
+ grpc_transport_perform_op(transport, &op, closure_list);
}
channel = grpc_channel_create_from_filters(NULL, filters, num_filters, args,
- mdctx, 0, call_list);
+ mdctx, 0, closure_list);
chand = (channel_data *)grpc_channel_stack_element(
grpc_channel_get_channel_stack(channel), 0)
->channel_data;
@@ -998,21 +1007,21 @@ void grpc_server_setup_transport(grpc_server *s, grpc_transport *transport,
op.on_connectivity_state_change = &chand->channel_connectivity_changed;
op.connectivity_state = &chand->connectivity_state;
op.disconnect = gpr_atm_acq_load(&s->shutdown_flag) != 0;
- grpc_transport_perform_op(transport, &op, call_list);
+ grpc_transport_perform_op(transport, &op, closure_list);
}
void done_published_shutdown(void *done_arg, grpc_cq_completion *storage,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
(void) done_arg;
gpr_free(storage);
}
static void listener_destroy_done(void *s, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_server *server = s;
gpr_mu_lock(&server->mu_global);
server->listeners_destroyed++;
- maybe_finish_shutdown(server, call_list);
+ maybe_finish_shutdown(server, closure_list);
gpr_mu_unlock(&server->mu_global);
}
@@ -1021,7 +1030,7 @@ void grpc_server_shutdown_and_notify(grpc_server *server,
listener *l;
shutdown_tag *sdt;
channel_broadcaster broadcaster;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
GRPC_SERVER_LOG_SHUTDOWN(GPR_INFO, server, cq, tag);
@@ -1030,7 +1039,7 @@ void grpc_server_shutdown_and_notify(grpc_server *server,
grpc_cq_begin_op(cq);
if (server->shutdown_published) {
grpc_cq_end_op(cq, tag, 1, done_published_shutdown, NULL,
- gpr_malloc(sizeof(grpc_cq_completion)), &call_list);
+ gpr_malloc(sizeof(grpc_cq_completion)), &closure_list);
gpr_mu_unlock(&server->mu_global);
goto done;
}
@@ -1051,40 +1060,40 @@ void grpc_server_shutdown_and_notify(grpc_server *server,
/* collect all unregistered then registered calls */
gpr_mu_lock(&server->mu_call);
- kill_pending_work_locked(server, &call_list);
+ kill_pending_work_locked(server, &closure_list);
gpr_mu_unlock(&server->mu_call);
gpr_atm_rel_store(&server->shutdown_flag, 1);
- maybe_finish_shutdown(server, &call_list);
+ maybe_finish_shutdown(server, &closure_list);
gpr_mu_unlock(&server->mu_global);
/* Shutdown listeners */
for (l = server->listeners; l; l = l->next) {
grpc_closure_init(&l->destroy_done, listener_destroy_done, server);
- l->destroy(server, l->arg, &l->destroy_done, &call_list);
+ l->destroy(server, l->arg, &l->destroy_done, &closure_list);
}
- channel_broadcaster_shutdown(&broadcaster, 1, 0, &call_list);
+ channel_broadcaster_shutdown(&broadcaster, 1, 0, &closure_list);
done:
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
void grpc_server_cancel_all_calls(grpc_server *server) {
channel_broadcaster broadcaster;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
gpr_mu_lock(&server->mu_global);
channel_broadcaster_init(server, &broadcaster);
gpr_mu_unlock(&server->mu_global);
- channel_broadcaster_shutdown(&broadcaster, 0, 1, &call_list);
- grpc_call_list_run(&call_list);
+ channel_broadcaster_shutdown(&broadcaster, 0, 1, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
void grpc_server_destroy(grpc_server *server) {
listener *l;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
gpr_mu_lock(&server->mu_global);
GPR_ASSERT(gpr_atm_acq_load(&server->shutdown_flag) || !server->listeners);
@@ -1098,17 +1107,17 @@ void grpc_server_destroy(grpc_server *server) {
gpr_mu_unlock(&server->mu_global);
- server_unref(server, &call_list);
- grpc_call_list_run(&call_list);
+ server_unref(server, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
void grpc_server_add_listener(
grpc_server *server, void *arg,
void (*start)(grpc_server *server, void *arg, grpc_pollset **pollsets,
- size_t pollset_count, grpc_call_list *call_list),
+ size_t pollset_count, grpc_closure_list *closure_list),
void (*destroy)(grpc_server *server, void *arg, grpc_closure *on_done,
- grpc_call_list *call_list),
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list),
+ grpc_closure_list *closure_list) {
listener *l = gpr_malloc(sizeof(listener));
l->arg = arg;
l->start = start;
@@ -1119,18 +1128,18 @@ void grpc_server_add_listener(
static grpc_call_error queue_call_request(grpc_server *server,
requested_call *rc,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
call_data *calld = NULL;
request_matcher *request_matcher = NULL;
int request_id;
if (gpr_atm_acq_load(&server->shutdown_flag)) {
- fail_call(server, rc, call_list);
+ fail_call(server, rc, closure_list);
return GRPC_CALL_OK;
}
request_id = gpr_stack_lockfree_pop(server->request_freelist);
if (request_id == -1) {
/* out of request ids: just fail this one */
- fail_call(server, rc, call_list);
+ fail_call(server, rc, closure_list);
return GRPC_CALL_OK;
}
switch (rc->type) {
@@ -1158,13 +1167,13 @@ static grpc_call_error queue_call_request(grpc_server *server,
grpc_closure_init(
&calld->kill_zombie_closure, kill_zombie,
grpc_call_stack_element(grpc_call_get_call_stack(calld->call), 0));
- grpc_call_list_add(call_list, &calld->kill_zombie_closure, 1);
+ grpc_closure_list_add(closure_list, &calld->kill_zombie_closure, 1);
} else {
GPR_ASSERT(calld->state == PENDING);
calld->state = ACTIVATED;
gpr_mu_unlock(&calld->mu_state);
begin_call(server, calld, &server->requested_calls[request_id],
- call_list);
+ closure_list);
}
gpr_mu_lock(&server->mu_call);
}
@@ -1179,7 +1188,7 @@ grpc_call_error grpc_server_request_call(
grpc_completion_queue *cq_bound_to_call,
grpc_completion_queue *cq_for_notification, void *tag) {
grpc_call_error error;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
requested_call *rc = gpr_malloc(sizeof(*rc));
GRPC_SERVER_LOG_REQUEST_CALL(GPR_INFO, server, call, details,
initial_metadata, cq_bound_to_call,
@@ -1199,9 +1208,9 @@ grpc_call_error grpc_server_request_call(
rc->call = call;
rc->data.batch.details = details;
rc->data.batch.initial_metadata = initial_metadata;
- error = queue_call_request(server, rc, &call_list);
+ error = queue_call_request(server, rc, &closure_list);
done:
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
return error;
}
@@ -1211,7 +1220,7 @@ grpc_call_error grpc_server_request_registered_call(
grpc_completion_queue *cq_bound_to_call,
grpc_completion_queue *cq_for_notification, void *tag) {
grpc_call_error error;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
requested_call *rc = gpr_malloc(sizeof(*rc));
registered_method *registered_method = rm;
if (!grpc_cq_is_server_cq(cq_for_notification)) {
@@ -1230,16 +1239,16 @@ grpc_call_error grpc_server_request_registered_call(
rc->data.registered.deadline = deadline;
rc->data.registered.initial_metadata = initial_metadata;
rc->data.registered.optional_payload = optional_payload;
- error = queue_call_request(server, rc, &call_list);
+ error = queue_call_request(server, rc, &closure_list);
done:
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
return error;
}
static void publish_registered_or_batch(grpc_call *call, int success, void *tag,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
static void publish_was_not_set(grpc_call *call, int success, void *tag,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
abort();
}
@@ -1255,7 +1264,7 @@ static void cpstr(char **dest, size_t *capacity, grpc_mdstr *value) {
}
static void begin_call(grpc_server *server, call_data *calld,
- requested_call *rc, grpc_call_list *call_list) {
+ requested_call *rc, grpc_closure_list *closure_list) {
grpc_ioreq_completion_func publish = publish_was_not_set;
grpc_ioreq req[2];
grpc_ioreq *r = req;
@@ -1266,7 +1275,8 @@ static void begin_call(grpc_server *server, call_data *calld,
fill in the metadata array passed by the client, we need to perform
an ioreq op, that should complete immediately. */
- grpc_call_set_completion_queue(calld->call, rc->cq_bound_to_call, call_list);
+ grpc_call_set_completion_queue(calld->call, rc->cq_bound_to_call,
+ closure_list);
*rc->call = calld->call;
calld->cq_new = rc->cq_for_notification;
switch (rc->type) {
@@ -1302,11 +1312,11 @@ static void begin_call(grpc_server *server, call_data *calld,
GRPC_CALL_INTERNAL_REF(calld->call, "server");
grpc_call_start_ioreq_and_call_back(calld->call, req, (size_t)(r - req),
- publish, rc, call_list);
+ publish, rc, closure_list);
}
static void done_request_event(void *req, grpc_cq_completion *c,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
requested_call *rc = req;
grpc_server *server = rc->server;
@@ -1319,11 +1329,11 @@ static void done_request_event(void *req, grpc_cq_completion *c,
gpr_free(req);
}
- server_unref(server, call_list);
+ server_unref(server, closure_list);
}
static void fail_call(grpc_server *server, requested_call *rc,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
*rc->call = NULL;
switch (rc->type) {
case BATCH_CALL:
@@ -1335,11 +1345,11 @@ static void fail_call(grpc_server *server, requested_call *rc,
}
server_ref(server);
grpc_cq_end_op(rc->cq_for_notification, rc->tag, 0, done_request_event, rc,
- &rc->completion, call_list);
+ &rc->completion, closure_list);
}
static void publish_registered_or_batch(grpc_call *call, int success, void *prc,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_call_element *elem =
grpc_call_stack_element(grpc_call_get_call_stack(call), 0);
requested_call *rc = prc;
@@ -1347,8 +1357,8 @@ static void publish_registered_or_batch(grpc_call *call, int success, void *prc,
channel_data *chand = elem->channel_data;
server_ref(chand->server);
grpc_cq_end_op(calld->cq_new, rc->tag, success, done_request_event, rc,
- &rc->completion, call_list);
- GRPC_CALL_INTERNAL_UNREF(call, "server", call_list);
+ &rc->completion, closure_list);
+ GRPC_CALL_INTERNAL_UNREF(call, "server", closure_list);
}
const grpc_channel_args *grpc_server_get_channel_args(grpc_server *server) {
diff --git a/src/core/surface/server.h b/src/core/surface/server.h
index d08a03863975a8046f9aa48a71b0768c9531e25f..985fb01893ea25dc98a1a88a8503d60c53ed288e 100644
--- a/src/core/surface/server.h
+++ b/src/core/surface/server.h
@@ -48,10 +48,10 @@ grpc_server *grpc_server_create_from_filters(
void grpc_server_add_listener(
grpc_server *server, void *listener,
void (*start)(grpc_server *server, void *arg, grpc_pollset **pollsets,
- size_t npollsets, grpc_call_list *call_list),
+ size_t npollsets, grpc_closure_list *closure_list),
void (*destroy)(grpc_server *server, void *arg, grpc_closure *on_done,
- grpc_call_list *call_list),
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list),
+ grpc_closure_list *closure_list);
/* Setup a transport - creates a channel stack, binds the transport to the
server */
@@ -59,7 +59,7 @@ void grpc_server_setup_transport(grpc_server *server, grpc_transport *transport,
grpc_channel_filter const **extra_filters,
size_t num_extra_filters, grpc_mdctx *mdctx,
const grpc_channel_args *args,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
const grpc_channel_args *grpc_server_get_channel_args(grpc_server *server);
diff --git a/src/core/surface/server_chttp2.c b/src/core/surface/server_chttp2.c
index 395c88827d4c88a16cdb5d860779d668d0ab7b36..ad44aed73baf5928e613059bdc39f4b85f8881c0 100644
--- a/src/core/surface/server_chttp2.c
+++ b/src/core/surface/server_chttp2.c
@@ -43,16 +43,17 @@
#include <grpc/support/useful.h>
static void setup_transport(void *server, grpc_transport *transport,
- grpc_mdctx *mdctx, grpc_call_list *call_list) {
+ grpc_mdctx *mdctx,
+ grpc_closure_list *closure_list) {
static grpc_channel_filter const *extra_filters[] = {
&grpc_http_server_filter};
- grpc_server_setup_transport(server, transport, extra_filters,
- GPR_ARRAY_SIZE(extra_filters), mdctx,
- grpc_server_get_channel_args(server), call_list);
+ grpc_server_setup_transport(
+ server, transport, extra_filters, GPR_ARRAY_SIZE(extra_filters), mdctx,
+ grpc_server_get_channel_args(server), closure_list);
}
static void new_transport(void *server, grpc_endpoint *tcp,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
/*
* Beware that the call to grpc_create_chttp2_transport() has to happen before
* grpc_tcp_server_destroy(). This is fine here, but similar code
@@ -62,25 +63,25 @@ static void new_transport(void *server, grpc_endpoint *tcp,
*/
grpc_mdctx *mdctx = grpc_mdctx_create();
grpc_transport *transport = grpc_create_chttp2_transport(
- grpc_server_get_channel_args(server), tcp, mdctx, 0, call_list);
- setup_transport(server, transport, mdctx, call_list);
- grpc_chttp2_transport_start_reading(transport, NULL, 0, call_list);
+ grpc_server_get_channel_args(server), tcp, mdctx, 0, closure_list);
+ setup_transport(server, transport, mdctx, closure_list);
+ grpc_chttp2_transport_start_reading(transport, NULL, 0, closure_list);
}
/* Server callback: start listening on our ports */
static void start(grpc_server *server, void *tcpp, grpc_pollset **pollsets,
- size_t pollset_count, grpc_call_list *call_list) {
+ size_t pollset_count, grpc_closure_list *closure_list) {
grpc_tcp_server *tcp = tcpp;
grpc_tcp_server_start(tcp, pollsets, pollset_count, new_transport, server,
- call_list);
+ closure_list);
}
/* Server callback: destroy the tcp listener (so we don't generate further
callbacks) */
static void destroy(grpc_server *server, void *tcpp, grpc_closure *destroy_done,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_tcp_server *tcp = tcpp;
- grpc_tcp_server_destroy(tcp, destroy_done, call_list);
+ grpc_tcp_server_destroy(tcp, destroy_done, closure_list);
}
int grpc_server_add_insecure_http2_port(grpc_server *server, const char *addr) {
@@ -90,7 +91,7 @@ int grpc_server_add_insecure_http2_port(grpc_server *server, const char *addr) {
unsigned count = 0;
int port_num = -1;
int port_temp;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
resolved = grpc_blocking_resolve_address(addr, "http");
if (!resolved) {
@@ -127,7 +128,7 @@ int grpc_server_add_insecure_http2_port(grpc_server *server, const char *addr) {
grpc_resolved_addresses_destroy(resolved);
/* Register with the server only upon success */
- grpc_server_add_listener(server, tcp, start, destroy, &call_list);
+ grpc_server_add_listener(server, tcp, start, destroy, &closure_list);
goto done;
/* Error path: cleanup and return */
@@ -141,6 +142,6 @@ error:
port_num = 0;
done:
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
return port_num;
}
diff --git a/src/core/transport/chttp2/frame_data.c b/src/core/transport/chttp2/frame_data.c
index ef12c910cd72ea5adaf6702aaa4a08b117f1050b..a58189a1366e2a50c3f6bc4cb0f210d9ba75980c 100644
--- a/src/core/transport/chttp2/frame_data.c
+++ b/src/core/transport/chttp2/frame_data.c
@@ -72,7 +72,7 @@ grpc_chttp2_parse_error grpc_chttp2_data_parser_begin_frame(
grpc_chttp2_parse_error grpc_chttp2_data_parser_parse(
void *parser, grpc_chttp2_transport_parsing *transport_parsing,
grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
gpr_uint8 *const beg = GPR_SLICE_START_PTR(slice);
gpr_uint8 *const end = GPR_SLICE_END_PTR(slice);
gpr_uint8 *cur = beg;
diff --git a/src/core/transport/chttp2/frame_data.h b/src/core/transport/chttp2/frame_data.h
index 7530f0f64460a4ceee6292b8b7a1b67298d692b2..89a503eb7ca6d55837c82038069d3d8106207692 100644
--- a/src/core/transport/chttp2/frame_data.h
+++ b/src/core/transport/chttp2/frame_data.h
@@ -76,7 +76,7 @@ grpc_chttp2_parse_error grpc_chttp2_data_parser_begin_frame(
grpc_chttp2_parse_error grpc_chttp2_data_parser_parse(
void *parser, grpc_chttp2_transport_parsing *transport_parsing,
grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* create a slice with an empty data frame and is_last set */
gpr_slice grpc_chttp2_data_frame_create_empty_close(gpr_uint32 id);
diff --git a/src/core/transport/chttp2/frame_goaway.c b/src/core/transport/chttp2/frame_goaway.c
index 1c2bce6736dedaf486dfa38505131ffdc6839a4d..d338b56611220274c6b9af8eadbd90bca8c1ab47 100644
--- a/src/core/transport/chttp2/frame_goaway.c
+++ b/src/core/transport/chttp2/frame_goaway.c
@@ -65,7 +65,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_begin_frame(
grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
void *parser, grpc_chttp2_transport_parsing *transport_parsing,
grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
gpr_uint8 *const beg = GPR_SLICE_START_PTR(slice);
gpr_uint8 *const end = GPR_SLICE_END_PTR(slice);
gpr_uint8 *cur = beg;
diff --git a/src/core/transport/chttp2/frame_goaway.h b/src/core/transport/chttp2/frame_goaway.h
index ec991f435031ac9d0ebdbd9ec12cf021f46c2081..6f9ce94a0cb39e57c9c29e3743c24b7a7d263cae 100644
--- a/src/core/transport/chttp2/frame_goaway.h
+++ b/src/core/transport/chttp2/frame_goaway.h
@@ -68,7 +68,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_begin_frame(
grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
void *parser, grpc_chttp2_transport_parsing *transport_parsing,
grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void grpc_chttp2_goaway_append(gpr_uint32 last_stream_id, gpr_uint32 error_code,
gpr_slice debug_data,
diff --git a/src/core/transport/chttp2/frame_ping.c b/src/core/transport/chttp2/frame_ping.c
index 2fb8850a45904d22ddae4f6672b2a9125d3cddb7..d4bf43eb37c106bfc9c8f3fb6a1bee759e51544c 100644
--- a/src/core/transport/chttp2/frame_ping.c
+++ b/src/core/transport/chttp2/frame_ping.c
@@ -71,7 +71,7 @@ grpc_chttp2_parse_error grpc_chttp2_ping_parser_begin_frame(
grpc_chttp2_parse_error grpc_chttp2_ping_parser_parse(
void *parser, grpc_chttp2_transport_parsing *transport_parsing,
grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
gpr_uint8 *const beg = GPR_SLICE_START_PTR(slice);
gpr_uint8 *const end = GPR_SLICE_END_PTR(slice);
gpr_uint8 *cur = beg;
@@ -90,7 +90,7 @@ grpc_chttp2_parse_error grpc_chttp2_ping_parser_parse(
for (ping = transport_parsing->pings.next;
ping != &transport_parsing->pings; ping = ping->next) {
if (0 == memcmp(p->opaque_8bytes, ping->id, 8)) {
- grpc_call_list_add(call_list, ping->on_recv, 1);
+ grpc_closure_list_add(closure_list, ping->on_recv, 1);
}
ping->next->prev = ping->prev;
ping->prev->next = ping->next;
diff --git a/src/core/transport/chttp2/frame_ping.h b/src/core/transport/chttp2/frame_ping.h
index 70e19eb8ab73c2d0013b9964ed77224f395d239d..fb31147ed45930381eca86a02e0d020a1e1f6577 100644
--- a/src/core/transport/chttp2/frame_ping.h
+++ b/src/core/transport/chttp2/frame_ping.h
@@ -51,6 +51,6 @@ grpc_chttp2_parse_error grpc_chttp2_ping_parser_begin_frame(
grpc_chttp2_parse_error grpc_chttp2_ping_parser_parse(
void *parser, grpc_chttp2_transport_parsing *transport_parsing,
grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_TRANSPORT_CHTTP2_FRAME_PING_H */
diff --git a/src/core/transport/chttp2/frame_rst_stream.c b/src/core/transport/chttp2/frame_rst_stream.c
index 7cf8abe88f78203fbc8fe484a73da7216ef1851b..4d8323c11ddb5ccb10b4498ebea51a2cbae80f26 100644
--- a/src/core/transport/chttp2/frame_rst_stream.c
+++ b/src/core/transport/chttp2/frame_rst_stream.c
@@ -73,7 +73,7 @@ grpc_chttp2_parse_error grpc_chttp2_rst_stream_parser_begin_frame(
grpc_chttp2_parse_error grpc_chttp2_rst_stream_parser_parse(
void *parser, grpc_chttp2_transport_parsing *transport_parsing,
grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
gpr_uint8 *const beg = GPR_SLICE_START_PTR(slice);
gpr_uint8 *const end = GPR_SLICE_END_PTR(slice);
gpr_uint8 *cur = beg;
diff --git a/src/core/transport/chttp2/frame_rst_stream.h b/src/core/transport/chttp2/frame_rst_stream.h
index 17d57fae5e262d6c555c4a5f5bfaad4f04493ce0..05d9e560f4ecf925d82c034af4f43fee18030825 100644
--- a/src/core/transport/chttp2/frame_rst_stream.h
+++ b/src/core/transport/chttp2/frame_rst_stream.h
@@ -50,6 +50,6 @@ grpc_chttp2_parse_error grpc_chttp2_rst_stream_parser_begin_frame(
grpc_chttp2_parse_error grpc_chttp2_rst_stream_parser_parse(
void *parser, grpc_chttp2_transport_parsing *transport_parsing,
grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_TRANSPORT_CHTTP2_FRAME_RST_STREAM_H */
diff --git a/src/core/transport/chttp2/frame_settings.c b/src/core/transport/chttp2/frame_settings.c
index 78bd4bb09dd85b624a30b0c7a90a024121e48293..235ff5a352ffa85913d3fa35e932d2ab81188a77 100644
--- a/src/core/transport/chttp2/frame_settings.c
+++ b/src/core/transport/chttp2/frame_settings.c
@@ -140,7 +140,7 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_begin_frame(
grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
void *p, grpc_chttp2_transport_parsing *transport_parsing,
grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_chttp2_settings_parser *parser = p;
const gpr_uint8 *cur = GPR_SLICE_START_PTR(slice);
const gpr_uint8 *end = GPR_SLICE_END_PTR(slice);
diff --git a/src/core/transport/chttp2/frame_settings.h b/src/core/transport/chttp2/frame_settings.h
index a04a28b7da87ca282cf35a040777794c2c2b8d4d..7931b8b2ca14dada49ff26505cccd3ad11e2520c 100644
--- a/src/core/transport/chttp2/frame_settings.h
+++ b/src/core/transport/chttp2/frame_settings.h
@@ -97,6 +97,6 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_begin_frame(
grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
void *parser, grpc_chttp2_transport_parsing *transport_parsing,
grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_TRANSPORT_CHTTP2_FRAME_SETTINGS_H */
diff --git a/src/core/transport/chttp2/frame_window_update.c b/src/core/transport/chttp2/frame_window_update.c
index 51eb26134696812449efe8087de43876b454b2ab..b0f5f8698bda638871b1f9408c1a14d12ea7038e 100644
--- a/src/core/transport/chttp2/frame_window_update.c
+++ b/src/core/transport/chttp2/frame_window_update.c
@@ -76,7 +76,7 @@ grpc_chttp2_parse_error grpc_chttp2_window_update_parser_begin_frame(
grpc_chttp2_parse_error grpc_chttp2_window_update_parser_parse(
void *parser, grpc_chttp2_transport_parsing *transport_parsing,
grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
gpr_uint8 *const beg = GPR_SLICE_START_PTR(slice);
gpr_uint8 *const end = GPR_SLICE_END_PTR(slice);
gpr_uint8 *cur = beg;
diff --git a/src/core/transport/chttp2/frame_window_update.h b/src/core/transport/chttp2/frame_window_update.h
index 7f1168e551d1fc62fe057a94a3bda34ce35319d5..08931044e48c0bb548bf4fe108b9cf20a25063d4 100644
--- a/src/core/transport/chttp2/frame_window_update.h
+++ b/src/core/transport/chttp2/frame_window_update.h
@@ -53,6 +53,6 @@ grpc_chttp2_parse_error grpc_chttp2_window_update_parser_begin_frame(
grpc_chttp2_parse_error grpc_chttp2_window_update_parser_parse(
void *parser, grpc_chttp2_transport_parsing *transport_parsing,
grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_TRANSPORT_CHTTP2_FRAME_WINDOW_UPDATE_H */
diff --git a/src/core/transport/chttp2/hpack_parser.c b/src/core/transport/chttp2/hpack_parser.c
index e3b8e54e8d477c6729dea361c9394c2ec99d063f..e66a918fcdc97e01775397973083e9e561d7fcfb 100644
--- a/src/core/transport/chttp2/hpack_parser.c
+++ b/src/core/transport/chttp2/hpack_parser.c
@@ -1380,7 +1380,7 @@ int grpc_chttp2_hpack_parser_parse(grpc_chttp2_hpack_parser *p,
grpc_chttp2_parse_error grpc_chttp2_header_parser_parse(
void *hpack_parser, grpc_chttp2_transport_parsing *transport_parsing,
grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_chttp2_hpack_parser *parser = hpack_parser;
if (!grpc_chttp2_hpack_parser_parse(parser, GPR_SLICE_START_PTR(slice),
GPR_SLICE_END_PTR(slice))) {
diff --git a/src/core/transport/chttp2/hpack_parser.h b/src/core/transport/chttp2/hpack_parser.h
index c9ae6a97675efcce3f2cb35cb06e95a93136f162..946f8e34ef558df1018f0d242412300db4159ebe 100644
--- a/src/core/transport/chttp2/hpack_parser.h
+++ b/src/core/transport/chttp2/hpack_parser.h
@@ -110,6 +110,6 @@ int grpc_chttp2_hpack_parser_parse(grpc_chttp2_hpack_parser *p,
grpc_chttp2_parse_error grpc_chttp2_header_parser_parse(
void *hpack_parser, grpc_chttp2_transport_parsing *transport_parsing,
grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_TRANSPORT_CHTTP2_HPACK_PARSER_H */
diff --git a/src/core/transport/chttp2/internal.h b/src/core/transport/chttp2/internal.h
index b9dbbc25eefde4d17b87837411ffe3f1185b26dd..14a6c909ee0d0a117bc51276872b2f26bf1f9c48 100644
--- a/src/core/transport/chttp2/internal.h
+++ b/src/core/transport/chttp2/internal.h
@@ -268,7 +268,7 @@ struct grpc_chttp2_transport_parsing {
grpc_chttp2_parse_error (*parser)(
void *parser_user_data, grpc_chttp2_transport_parsing *transport_parsing,
grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* received settings */
gpr_uint32 settings[GRPC_CHTTP2_NUM_SETTINGS];
@@ -469,22 +469,22 @@ int grpc_chttp2_unlocking_check_writes(grpc_chttp2_transport_global *global,
grpc_chttp2_transport_writing *writing);
void grpc_chttp2_perform_writes(
grpc_chttp2_transport_writing *transport_writing, grpc_endpoint *endpoint,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void grpc_chttp2_terminate_writing(void *transport_writing, int success,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void grpc_chttp2_cleanup_writing(grpc_chttp2_transport_global *global,
grpc_chttp2_transport_writing *writing,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void grpc_chttp2_prepare_to_read(grpc_chttp2_transport_global *global,
grpc_chttp2_transport_parsing *parsing);
/** Process one slice of incoming data; return 1 if the connection is still
viable after reading, or 0 if the connection should be torn down */
int grpc_chttp2_perform_read(grpc_chttp2_transport_parsing *transport_parsing,
- gpr_slice slice, grpc_call_list *call_list);
+ gpr_slice slice, grpc_closure_list *closure_list);
void grpc_chttp2_publish_reads(grpc_chttp2_transport_global *global,
grpc_chttp2_transport_parsing *parsing,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** Get a writable stream
returns non-zero if there was a stream available */
@@ -577,7 +577,7 @@ grpc_chttp2_stream_parsing *grpc_chttp2_parsing_accept_stream(
void grpc_chttp2_add_incoming_goaway(
grpc_chttp2_transport_global *transport_global, gpr_uint32 goaway_error,
- gpr_slice goaway_text, grpc_call_list *call_list);
+ gpr_slice goaway_text, grpc_closure_list *closure_list);
void grpc_chttp2_register_stream(grpc_chttp2_transport *t,
grpc_chttp2_stream *s);
diff --git a/src/core/transport/chttp2/parsing.c b/src/core/transport/chttp2/parsing.c
index 2d95963f1fd1df306254d0989ec6a96073089459..f6ce35f9accc8d2b94030a41d1fe1da3a1fbbbc2 100644
--- a/src/core/transport/chttp2/parsing.c
+++ b/src/core/transport/chttp2/parsing.c
@@ -60,7 +60,7 @@ static int init_skip_frame_parser(
static int parse_frame_slice(grpc_chttp2_transport_parsing *transport_parsing,
gpr_slice slice, int is_last,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void grpc_chttp2_prepare_to_read(
grpc_chttp2_transport_global *transport_global,
@@ -93,7 +93,7 @@ void grpc_chttp2_prepare_to_read(
void grpc_chttp2_publish_reads(grpc_chttp2_transport_global *transport_global,
grpc_chttp2_transport_parsing *transport_parsing,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_chttp2_stream_global *stream_global;
grpc_chttp2_stream_parsing *stream_parsing;
@@ -131,9 +131,9 @@ void grpc_chttp2_publish_reads(grpc_chttp2_transport_global *transport_global,
/* move goaway to the global state if we received one (it will be
published later */
if (transport_parsing->goaway_received) {
- grpc_chttp2_add_incoming_goaway(transport_global,
- (gpr_uint32)transport_parsing->goaway_error,
- transport_parsing->goaway_text, call_list);
+ grpc_chttp2_add_incoming_goaway(
+ transport_global, (gpr_uint32)transport_parsing->goaway_error,
+ transport_parsing->goaway_text, closure_list);
transport_parsing->goaway_text = gpr_empty_slice();
transport_parsing->goaway_received = 0;
}
@@ -236,7 +236,7 @@ void grpc_chttp2_publish_reads(grpc_chttp2_transport_global *transport_global,
}
int grpc_chttp2_perform_read(grpc_chttp2_transport_parsing *transport_parsing,
- gpr_slice slice, grpc_call_list *call_list) {
+ gpr_slice slice, grpc_closure_list *closure_list) {
gpr_uint8 *beg = GPR_SLICE_START_PTR(slice);
gpr_uint8 *end = GPR_SLICE_END_PTR(slice);
gpr_uint8 *cur = beg;
@@ -366,7 +366,7 @@ int grpc_chttp2_perform_read(grpc_chttp2_transport_parsing *transport_parsing,
}
if (transport_parsing->incoming_frame_size == 0) {
if (!parse_frame_slice(transport_parsing, gpr_empty_slice(), 1,
- call_list)) {
+ closure_list)) {
return 0;
}
transport_parsing->incoming_stream = NULL;
@@ -386,7 +386,7 @@ int grpc_chttp2_perform_read(grpc_chttp2_transport_parsing *transport_parsing,
if (!parse_frame_slice(transport_parsing,
gpr_slice_sub_no_ref(slice, (size_t)(cur - beg),
(size_t)(end - beg)),
- 1, call_list)) {
+ 1, closure_list)) {
return 0;
}
transport_parsing->deframe_state = GRPC_DTS_FH_0;
@@ -400,7 +400,7 @@ int grpc_chttp2_perform_read(grpc_chttp2_transport_parsing *transport_parsing,
gpr_slice_sub_no_ref(
slice, cur_offset,
cur_offset + transport_parsing->incoming_frame_size),
- 1, call_list)) {
+ 1, closure_list)) {
return 0;
}
cur += transport_parsing->incoming_frame_size;
@@ -410,7 +410,7 @@ int grpc_chttp2_perform_read(grpc_chttp2_transport_parsing *transport_parsing,
if (!parse_frame_slice(transport_parsing,
gpr_slice_sub_no_ref(slice, (size_t)(cur - beg),
(size_t)(end - beg)),
- 0, call_list)) {
+ 0, closure_list)) {
return 0;
}
transport_parsing->incoming_frame_size -= (gpr_uint32)(end - cur);
@@ -473,7 +473,7 @@ static int init_frame_parser(grpc_chttp2_transport_parsing *transport_parsing) {
static grpc_chttp2_parse_error skip_parser(
void *parser, grpc_chttp2_transport_parsing *transport_parsing,
grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
return GRPC_CHTTP2_PARSE_OK;
}
@@ -793,12 +793,12 @@ static int is_window_update_legal(gpr_int64 window_update, gpr_int64 window) {
static int parse_frame_slice(grpc_chttp2_transport_parsing *transport_parsing,
gpr_slice slice, int is_last,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_chttp2_stream_parsing *stream_parsing =
transport_parsing->incoming_stream;
switch (transport_parsing->parser(transport_parsing->parser_data,
transport_parsing, stream_parsing, slice,
- is_last, call_list)) {
+ is_last, closure_list)) {
case GRPC_CHTTP2_PARSE_OK:
if (stream_parsing) {
grpc_chttp2_list_add_parsing_seen_stream(transport_parsing,
diff --git a/src/core/transport/chttp2/writing.c b/src/core/transport/chttp2/writing.c
index 18f4bfbc77c8cd92fcbf857576c4e899e0e7f02e..e6f169c280743a91a96196051eebe4758eafa385 100644
--- a/src/core/transport/chttp2/writing.c
+++ b/src/core/transport/chttp2/writing.c
@@ -164,7 +164,7 @@ int grpc_chttp2_unlocking_check_writes(
void grpc_chttp2_perform_writes(
grpc_chttp2_transport_writing *transport_writing, grpc_endpoint *endpoint,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
GPR_ASSERT(transport_writing->outbuf.count > 0 ||
grpc_chttp2_list_have_writing_streams(transport_writing));
@@ -174,7 +174,7 @@ void grpc_chttp2_perform_writes(
GPR_ASSERT(endpoint);
grpc_endpoint_write(endpoint, &transport_writing->outbuf,
- &transport_writing->done_cb, call_list);
+ &transport_writing->done_cb, closure_list);
}
static void finalize_outbuf(grpc_chttp2_transport_writing *transport_writing) {
@@ -213,7 +213,7 @@ static void finalize_outbuf(grpc_chttp2_transport_writing *transport_writing) {
void grpc_chttp2_cleanup_writing(
grpc_chttp2_transport_global *transport_global,
grpc_chttp2_transport_writing *transport_writing,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_chttp2_stream_writing *stream_writing;
grpc_chttp2_stream_global *stream_global;
@@ -231,7 +231,8 @@ void grpc_chttp2_cleanup_writing(
stream_global->outgoing_sopb->nops == 0) {
GPR_ASSERT(stream_global->write_state != GRPC_WRITE_STATE_QUEUED_CLOSE);
stream_global->outgoing_sopb = NULL;
- grpc_call_list_add(call_list, stream_global->send_done_closure, 1);
+ grpc_closure_list_add(closure_list, stream_global->send_done_closure,
+ 1);
}
}
stream_global->writing_now = 0;
diff --git a/src/core/transport/chttp2_transport.c b/src/core/transport/chttp2_transport.c
index acd7cbdc1d7025cad6b1d3dd504e2af600bb7323..766b55b5fa700ff52ac5d283971dc6082dbb7aab 100644
--- a/src/core/transport/chttp2_transport.c
+++ b/src/core/transport/chttp2_transport.c
@@ -78,31 +78,31 @@ int grpc_flowctl_trace = 0;
static const grpc_transport_vtable vtable;
static void lock(grpc_chttp2_transport *t);
-static void unlock(grpc_chttp2_transport *t, grpc_call_list *call_list);
+static void unlock(grpc_chttp2_transport *t, grpc_closure_list *closure_list);
static void unlock_check_read_write_state(grpc_chttp2_transport *t,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* forward declarations of various callbacks that we'll build closures around */
static void writing_action(void *t, int iomgr_success_ignored,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** Set a transport level setting, and push it to our peer */
static void push_setting(grpc_chttp2_transport *t, grpc_chttp2_setting_id id,
gpr_uint32 value);
/** Endpoint callback to process incoming data */
-static void recv_data(void *tp, int success, grpc_call_list *call_list);
+static void recv_data(void *tp, int success, grpc_closure_list *closure_list);
/** Start disconnection chain */
static void drop_connection(grpc_chttp2_transport *t,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** Perform a transport_op */
static void perform_stream_op_locked(
grpc_chttp2_transport_global *transport_global,
grpc_chttp2_stream_global *stream_global, grpc_transport_stream_op *op,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** Cancel a stream: coming from the transport API */
static void cancel_from_api(grpc_chttp2_transport_global *transport_global,
@@ -117,26 +117,27 @@ static void close_from_api(grpc_chttp2_transport_global *transport_global,
/** Add endpoint from this transport to pollset */
static void add_to_pollset_locked(grpc_chttp2_transport *t,
grpc_pollset *pollset,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
static void add_to_pollset_set_locked(grpc_chttp2_transport *t,
grpc_pollset_set *pollset_set,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** Start new streams that have been created if we can */
static void maybe_start_some_streams(
- grpc_chttp2_transport_global *transport_global, grpc_call_list *call_list);
+ grpc_chttp2_transport_global *transport_global,
+ grpc_closure_list *closure_list);
static void connectivity_state_set(
grpc_chttp2_transport_global *transport_global,
grpc_connectivity_state state, const char *reason,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/*
* CONSTRUCTION/DESTRUCTION/REFCOUNTING
*/
static void destruct_transport(grpc_chttp2_transport *t,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t i;
gpr_mu_lock(&t->mu);
@@ -166,7 +167,7 @@ static void destruct_transport(grpc_chttp2_transport *t,
grpc_chttp2_stream_map_destroy(&t->parsing_stream_map);
grpc_chttp2_stream_map_destroy(&t->new_stream_map);
grpc_connectivity_state_destroy(&t->channel_callback.state_tracker,
- call_list);
+ closure_list);
gpr_mu_unlock(&t->mu);
gpr_mu_destroy(&t->mu);
@@ -175,7 +176,7 @@ static void destruct_transport(grpc_chttp2_transport *t,
and maybe they hold resources that need to be freed */
while (t->global.pings.next != &t->global.pings) {
grpc_chttp2_outstanding_ping *ping = t->global.pings.next;
- grpc_call_list_add(call_list, ping->on_recv, 0);
+ grpc_closure_list_add(closure_list, ping->on_recv, 0);
ping->next->prev = ping->prev;
ping->prev->next = ping->next;
gpr_free(ping);
@@ -190,12 +191,13 @@ static void destruct_transport(grpc_chttp2_transport *t,
#ifdef REFCOUNTING_DEBUG
#define REF_TRANSPORT(t, r) ref_transport(t, r, __FILE__, __LINE__)
#define UNREF_TRANSPORT(t, r, cl) unref_transport(t, cl, r, __FILE__, __LINE__)
-static void unref_transport(grpc_chttp2_transport *t, grpc_call_list *call_list,
- const char *reason, const char *file, int line) {
+static void unref_transport(grpc_chttp2_transport *t,
+ grpc_closure_list *closure_list, const char *reason,
+ const char *file, int line) {
gpr_log(GPR_DEBUG, "chttp2:unref:%p %d->%d %s [%s:%d]", t, t->refs.count,
t->refs.count - 1, reason, file, line);
if (!gpr_unref(&t->refs)) return;
- destruct_transport(t, call_list);
+ destruct_transport(t, closure_list);
}
static void ref_transport(grpc_chttp2_transport *t, const char *reason,
@@ -208,9 +210,9 @@ static void ref_transport(grpc_chttp2_transport *t, const char *reason,
#define REF_TRANSPORT(t, r) ref_transport(t)
#define UNREF_TRANSPORT(t, r, cl) unref_transport(t, cl)
static void unref_transport(grpc_chttp2_transport *t,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
if (!gpr_unref(&t->refs)) return;
- destruct_transport(t, call_list);
+ destruct_transport(t, closure_list);
}
static void ref_transport(grpc_chttp2_transport *t) { gpr_ref(&t->refs); }
@@ -219,7 +221,8 @@ static void ref_transport(grpc_chttp2_transport *t) { gpr_ref(&t->refs); }
static void init_transport(grpc_chttp2_transport *t,
const grpc_channel_args *channel_args,
grpc_endpoint *ep, grpc_mdctx *mdctx,
- gpr_uint8 is_client, grpc_call_list *call_list) {
+ gpr_uint8 is_client,
+ grpc_closure_list *closure_list) {
size_t i;
int j;
@@ -339,15 +342,16 @@ static void init_transport(grpc_chttp2_transport *t,
}
}
-static void destroy_transport(grpc_transport *gt, grpc_call_list *call_list) {
+static void destroy_transport(grpc_transport *gt,
+ grpc_closure_list *closure_list) {
grpc_chttp2_transport *t = (grpc_chttp2_transport *)gt;
lock(t);
t->destroying = 1;
- drop_connection(t, call_list);
- unlock(t, call_list);
+ drop_connection(t, closure_list);
+ unlock(t, closure_list);
- UNREF_TRANSPORT(t, "destroy", call_list);
+ UNREF_TRANSPORT(t, "destroy", closure_list);
}
/** block grpc_endpoint_shutdown being called until a paired
@@ -358,41 +362,41 @@ static void prevent_endpoint_shutdown(grpc_chttp2_transport *t) {
}
static void allow_endpoint_shutdown_locked(grpc_chttp2_transport *t,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
if (gpr_unref(&t->shutdown_ep_refs)) {
if (t->ep) {
- grpc_endpoint_shutdown(t->ep, call_list);
+ grpc_endpoint_shutdown(t->ep, closure_list);
}
}
}
static void allow_endpoint_shutdown_unlocked(grpc_chttp2_transport *t,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
if (gpr_unref(&t->shutdown_ep_refs)) {
gpr_mu_lock(&t->mu);
if (t->ep) {
- grpc_endpoint_shutdown(t->ep, call_list);
+ grpc_endpoint_shutdown(t->ep, closure_list);
}
gpr_mu_unlock(&t->mu);
}
}
static void destroy_endpoint(grpc_chttp2_transport *t,
- grpc_call_list *call_list) {
- grpc_endpoint_destroy(t->ep, call_list);
+ grpc_closure_list *closure_list) {
+ grpc_endpoint_destroy(t->ep, closure_list);
t->ep = NULL;
/* safe because we'll still have the ref for write */
- UNREF_TRANSPORT(t, "disconnect", call_list);
+ UNREF_TRANSPORT(t, "disconnect", closure_list);
}
static void close_transport_locked(grpc_chttp2_transport *t,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
if (!t->closed) {
t->closed = 1;
connectivity_state_set(&t->global, GRPC_CHANNEL_FATAL_FAILURE,
- "close_transport", call_list);
+ "close_transport", closure_list);
if (t->ep) {
- allow_endpoint_shutdown_locked(t, call_list);
+ allow_endpoint_shutdown_locked(t, closure_list);
}
}
}
@@ -400,7 +404,7 @@ static void close_transport_locked(grpc_chttp2_transport *t,
static int init_stream(grpc_transport *gt, grpc_stream *gs,
const void *server_data,
grpc_transport_stream_op *initial_op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_chttp2_transport *t = (grpc_chttp2_transport *)gt;
grpc_chttp2_stream *s = (grpc_chttp2_stream *)gs;
@@ -432,14 +436,14 @@ static int init_stream(grpc_transport *gt, grpc_stream *gs,
}
if (initial_op)
- perform_stream_op_locked(&t->global, &s->global, initial_op, call_list);
- unlock(t, call_list);
+ perform_stream_op_locked(&t->global, &s->global, initial_op, closure_list);
+ unlock(t, closure_list);
return 0;
}
static void destroy_stream(grpc_transport *gt, grpc_stream *gs,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_chttp2_transport *t = (grpc_chttp2_transport *)gt;
grpc_chttp2_stream *s = (grpc_chttp2_stream *)gs;
int i;
@@ -450,7 +454,7 @@ static void destroy_stream(grpc_transport *gt, grpc_stream *gs,
s->global.id == 0);
GPR_ASSERT(!s->global.in_stream_map);
if (grpc_chttp2_unregister_stream(t, s) && t->global.sent_goaway) {
- close_transport_locked(t, call_list);
+ close_transport_locked(t, closure_list);
}
if (!t->parsing_active && s->global.id) {
GPR_ASSERT(grpc_chttp2_stream_map_find(&t->parsing_stream_map,
@@ -480,7 +484,7 @@ static void destroy_stream(grpc_transport *gt, grpc_stream *gs,
grpc_chttp2_incoming_metadata_live_op_buffer_end(
&s->global.outstanding_metadata);
- UNREF_TRANSPORT(t, "stream", call_list);
+ UNREF_TRANSPORT(t, "stream", closure_list);
}
grpc_chttp2_stream_parsing *grpc_chttp2_parsing_lookup_stream(
@@ -515,13 +519,13 @@ grpc_chttp2_stream_parsing *grpc_chttp2_parsing_accept_stream(
static void lock(grpc_chttp2_transport *t) { gpr_mu_lock(&t->mu); }
-static void unlock(grpc_chttp2_transport *t, grpc_call_list *call_list) {
- unlock_check_read_write_state(t, call_list);
+static void unlock(grpc_chttp2_transport *t, grpc_closure_list *closure_list) {
+ unlock_check_read_write_state(t, closure_list);
if (!t->writing_active && !t->closed &&
grpc_chttp2_unlocking_check_writes(&t->global, &t->writing)) {
t->writing_active = 1;
REF_TRANSPORT(t, "writing");
- grpc_call_list_add(call_list, &t->writing_action, 1);
+ grpc_closure_list_add(closure_list, &t->writing_action, 1);
prevent_endpoint_shutdown(t);
}
@@ -548,53 +552,54 @@ static void push_setting(grpc_chttp2_transport *t, grpc_chttp2_setting_id id,
}
void grpc_chttp2_terminate_writing(void *transport_writing_ptr, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_chttp2_transport_writing *transport_writing = transport_writing_ptr;
grpc_chttp2_transport *t = TRANSPORT_FROM_WRITING(transport_writing);
lock(t);
- allow_endpoint_shutdown_locked(t, call_list);
+ allow_endpoint_shutdown_locked(t, closure_list);
if (!success) {
- drop_connection(t, call_list);
+ drop_connection(t, closure_list);
}
/* cleanup writing related jazz */
- grpc_chttp2_cleanup_writing(&t->global, &t->writing, call_list);
+ grpc_chttp2_cleanup_writing(&t->global, &t->writing, closure_list);
/* leave the writing flag up on shutdown to prevent further writes in unlock()
from starting */
t->writing_active = 0;
if (t->ep && !t->endpoint_reading) {
- destroy_endpoint(t, call_list);
+ destroy_endpoint(t, closure_list);
}
- unlock(t, call_list);
+ unlock(t, closure_list);
- UNREF_TRANSPORT(t, "writing", call_list);
+ UNREF_TRANSPORT(t, "writing", closure_list);
}
static void writing_action(void *gt, int iomgr_success_ignored,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_chttp2_transport *t = gt;
- grpc_chttp2_perform_writes(&t->writing, t->ep, call_list);
+ grpc_chttp2_perform_writes(&t->writing, t->ep, closure_list);
}
void grpc_chttp2_add_incoming_goaway(
grpc_chttp2_transport_global *transport_global, gpr_uint32 goaway_error,
- gpr_slice goaway_text, grpc_call_list *call_list) {
+ gpr_slice goaway_text, grpc_closure_list *closure_list) {
char *msg = gpr_dump_slice(goaway_text, GPR_DUMP_HEX | GPR_DUMP_ASCII);
gpr_log(GPR_DEBUG, "got goaway [%d]: %s", goaway_error, msg);
gpr_free(msg);
gpr_slice_unref(goaway_text);
transport_global->seen_goaway = 1;
connectivity_state_set(transport_global, GRPC_CHANNEL_FATAL_FAILURE,
- "got_goaway", call_list);
+ "got_goaway", closure_list);
}
static void maybe_start_some_streams(
- grpc_chttp2_transport_global *transport_global, grpc_call_list *call_list) {
+ grpc_chttp2_transport_global *transport_global,
+ grpc_closure_list *closure_list) {
grpc_chttp2_stream_global *stream_global;
/* start streams where we have free grpc_chttp2_stream ids and free
* concurrency */
@@ -616,7 +621,7 @@ static void maybe_start_some_streams(
if (transport_global->next_stream_id >= MAX_CLIENT_STREAM_ID) {
connectivity_state_set(transport_global, GRPC_CHANNEL_TRANSIENT_FAILURE,
- "no_more_stream_ids", call_list);
+ "no_more_stream_ids", closure_list);
}
stream_global->outgoing_window =
@@ -647,7 +652,7 @@ static void maybe_start_some_streams(
static void perform_stream_op_locked(
grpc_chttp2_transport_global *transport_global,
grpc_chttp2_stream_global *stream_global, grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
if (op->cancel_with_status != GRPC_STATUS_OK) {
cancel_from_api(transport_global, stream_global, op->cancel_with_status);
}
@@ -674,13 +679,13 @@ static void perform_stream_op_locked(
transport_global->is_client ? "CLI" : "SVR", stream_global));
grpc_chttp2_list_add_waiting_for_concurrency(transport_global,
stream_global);
- maybe_start_some_streams(transport_global, call_list);
+ maybe_start_some_streams(transport_global, closure_list);
} else if (stream_global->outgoing_window > 0) {
grpc_chttp2_list_add_writable_stream(transport_global, stream_global);
}
} else {
grpc_sopb_reset(op->send_ops);
- grpc_call_list_add(call_list, stream_global->send_done_closure, 0);
+ grpc_closure_list_add(closure_list, stream_global->send_done_closure, 0);
}
}
@@ -715,21 +720,21 @@ static void perform_stream_op_locked(
if (op->bind_pollset) {
add_to_pollset_locked(TRANSPORT_FROM_GLOBAL(transport_global),
- op->bind_pollset, call_list);
+ op->bind_pollset, closure_list);
}
- grpc_call_list_add(call_list, op->on_consumed, 1);
+ grpc_closure_list_add(closure_list, op->on_consumed, 1);
}
static void perform_stream_op(grpc_transport *gt, grpc_stream *gs,
grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_chttp2_transport *t = (grpc_chttp2_transport *)gt;
grpc_chttp2_stream *s = (grpc_chttp2_stream *)gs;
lock(t);
- perform_stream_op_locked(&t->global, &s->global, op, call_list);
- unlock(t, call_list);
+ perform_stream_op_locked(&t->global, &s->global, op, closure_list);
+ unlock(t, closure_list);
}
static void send_ping_locked(grpc_chttp2_transport *t, grpc_closure *on_recv) {
@@ -750,18 +755,18 @@ static void send_ping_locked(grpc_chttp2_transport *t, grpc_closure *on_recv) {
}
static void perform_transport_op(grpc_transport *gt, grpc_transport_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_chttp2_transport *t = (grpc_chttp2_transport *)gt;
int close_transport = 0;
lock(t);
- grpc_call_list_add(call_list, op->on_consumed, 1);
+ grpc_closure_list_add(closure_list, op->on_consumed, 1);
if (op->on_connectivity_state_change) {
grpc_connectivity_state_notify_on_state_change(
&t->channel_callback.state_tracker, op->connectivity_state,
- op->on_connectivity_state_change, call_list);
+ op->on_connectivity_state_change, closure_list);
}
if (op->send_goaway) {
@@ -780,11 +785,11 @@ static void perform_transport_op(grpc_transport *gt, grpc_transport_op *op,
}
if (op->bind_pollset) {
- add_to_pollset_locked(t, op->bind_pollset, call_list);
+ add_to_pollset_locked(t, op->bind_pollset, closure_list);
}
if (op->bind_pollset_set) {
- add_to_pollset_set_locked(t, op->bind_pollset_set, call_list);
+ add_to_pollset_set_locked(t, op->bind_pollset_set, closure_list);
}
if (op->send_ping) {
@@ -792,15 +797,15 @@ static void perform_transport_op(grpc_transport *gt, grpc_transport_op *op,
}
if (op->disconnect) {
- close_transport_locked(t, call_list);
+ close_transport_locked(t, closure_list);
}
- unlock(t, call_list);
+ unlock(t, closure_list);
if (close_transport) {
lock(t);
- close_transport_locked(t, call_list);
- unlock(t, call_list);
+ close_transport_locked(t, closure_list);
+ unlock(t, closure_list);
}
}
@@ -817,7 +822,7 @@ static grpc_stream_state compute_state(gpr_uint8 write_closed,
}
static void remove_stream(grpc_chttp2_transport *t, gpr_uint32 id,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t new_stream_count;
grpc_chttp2_stream *s =
grpc_chttp2_stream_map_delete(&t->parsing_stream_map, id);
@@ -832,7 +837,7 @@ static void remove_stream(grpc_chttp2_transport *t, gpr_uint32 id,
grpc_chttp2_parsing_become_skip_parser(&t->parsing);
}
if (grpc_chttp2_unregister_stream(t, s) && t->global.sent_goaway) {
- close_transport_locked(t, call_list);
+ close_transport_locked(t, closure_list);
}
new_stream_count = grpc_chttp2_stream_map_size(&t->parsing_stream_map) +
@@ -840,12 +845,12 @@ static void remove_stream(grpc_chttp2_transport *t, gpr_uint32 id,
GPR_ASSERT(new_stream_count <= GPR_UINT32_MAX);
if (new_stream_count != t->global.concurrent_stream_count) {
t->global.concurrent_stream_count = (gpr_uint32)new_stream_count;
- maybe_start_some_streams(&t->global, call_list);
+ maybe_start_some_streams(&t->global, closure_list);
}
}
static void unlock_check_read_write_state(grpc_chttp2_transport *t,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_chttp2_transport_global *transport_global = &t->global;
grpc_chttp2_stream_global *stream_global;
grpc_stream_state state;
@@ -859,7 +864,7 @@ static void unlock_check_read_write_state(grpc_chttp2_transport *t,
GPR_ASSERT(stream_global->in_stream_map);
GPR_ASSERT(stream_global->write_state != GRPC_WRITE_STATE_OPEN);
GPR_ASSERT(stream_global->read_closed);
- remove_stream(t, stream_global->id, call_list);
+ remove_stream(t, stream_global->id, closure_list);
grpc_chttp2_list_add_read_write_state_changed(transport_global,
stream_global);
}
@@ -885,7 +890,8 @@ static void unlock_check_read_write_state(grpc_chttp2_transport *t,
if (stream_global->outgoing_sopb != NULL) {
grpc_sopb_reset(stream_global->outgoing_sopb);
stream_global->outgoing_sopb = NULL;
- grpc_call_list_add(call_list, stream_global->send_done_closure, 1);
+ grpc_closure_list_add(closure_list, stream_global->send_done_closure,
+ 1);
}
stream_global->read_closed = 1;
if (!stream_global->published_cancelled) {
@@ -907,7 +913,7 @@ static void unlock_check_read_write_state(grpc_chttp2_transport *t,
grpc_chttp2_list_add_closed_waiting_for_parsing(transport_global,
stream_global);
} else {
- remove_stream(t, stream_global->id, call_list);
+ remove_stream(t, stream_global->id, closure_list);
}
}
if (!stream_global->publish_sopb) {
@@ -935,7 +941,7 @@ static void unlock_check_read_write_state(grpc_chttp2_transport *t,
&stream_global->outstanding_metadata);
grpc_sopb_swap(stream_global->publish_sopb, &stream_global->incoming_sopb);
stream_global->published_state = *stream_global->publish_state = state;
- grpc_call_list_add(call_list, stream_global->recv_done_closure, 1);
+ grpc_closure_list_add(closure_list, stream_global->recv_done_closure, 1);
stream_global->recv_done_closure = NULL;
stream_global->publish_sopb = NULL;
stream_global->publish_state = NULL;
@@ -1071,8 +1077,8 @@ static void end_all_the_calls(grpc_chttp2_transport *t) {
}
static void drop_connection(grpc_chttp2_transport *t,
- grpc_call_list *call_list) {
- close_transport_locked(t, call_list);
+ grpc_closure_list *closure_list) {
+ close_transport_locked(t, closure_list);
end_all_the_calls(t);
}
@@ -1098,15 +1104,15 @@ static void update_global_window(void *args, gpr_uint32 id, void *stream) {
}
static void read_error_locked(grpc_chttp2_transport *t,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
t->endpoint_reading = 0;
if (!t->writing_active && t->ep) {
- destroy_endpoint(t, call_list);
+ destroy_endpoint(t, closure_list);
}
}
/* tcp read callback */
-static void recv_data(void *tp, int success, grpc_call_list *call_list) {
+static void recv_data(void *tp, int success, grpc_closure_list *closure_list) {
size_t i;
int keep_reading = 0;
grpc_chttp2_transport *t = tp;
@@ -1123,12 +1129,12 @@ static void recv_data(void *tp, int success, grpc_call_list *call_list) {
gpr_mu_unlock(&t->mu);
for (; i < t->read_buffer.count &&
grpc_chttp2_perform_read(&t->parsing, t->read_buffer.slices[i],
- call_list);
+ closure_list);
i++)
;
gpr_mu_lock(&t->mu);
if (i != t->read_buffer.count) {
- drop_connection(t, call_list);
+ drop_connection(t, closure_list);
}
/* merge stream lists */
grpc_chttp2_stream_map_move_into(&t->new_stream_map,
@@ -1141,26 +1147,26 @@ static void recv_data(void *tp, int success, grpc_call_list *call_list) {
t->parsing.initial_window_update = 0;
}
/* handle higher level things */
- grpc_chttp2_publish_reads(&t->global, &t->parsing, call_list);
+ grpc_chttp2_publish_reads(&t->global, &t->parsing, closure_list);
t->parsing_active = 0;
}
if (!success || i != t->read_buffer.count) {
- drop_connection(t, call_list);
- read_error_locked(t, call_list);
+ drop_connection(t, closure_list);
+ read_error_locked(t, closure_list);
} else if (!t->closed) {
keep_reading = 1;
REF_TRANSPORT(t, "keep_reading");
prevent_endpoint_shutdown(t);
}
gpr_slice_buffer_reset_and_unref(&t->read_buffer);
- unlock(t, call_list);
+ unlock(t, closure_list);
if (keep_reading) {
- grpc_endpoint_read(t->ep, &t->read_buffer, &t->recv_data, call_list);
- allow_endpoint_shutdown_unlocked(t, call_list);
- UNREF_TRANSPORT(t, "keep_reading", call_list);
+ grpc_endpoint_read(t->ep, &t->read_buffer, &t->recv_data, closure_list);
+ allow_endpoint_shutdown_unlocked(t, closure_list);
+ UNREF_TRANSPORT(t, "keep_reading", closure_list);
} else {
- UNREF_TRANSPORT(t, "recv_data", call_list);
+ UNREF_TRANSPORT(t, "recv_data", closure_list);
}
}
@@ -1171,12 +1177,12 @@ static void recv_data(void *tp, int success, grpc_call_list *call_list) {
static void connectivity_state_set(
grpc_chttp2_transport_global *transport_global,
grpc_connectivity_state state, const char *reason,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
GRPC_CHTTP2_IF_TRACING(
gpr_log(GPR_DEBUG, "set connectivity_state=%d", state));
grpc_connectivity_state_set(
&TRANSPORT_FROM_GLOBAL(transport_global)->channel_callback.state_tracker,
- state, reason, call_list);
+ state, reason, closure_list);
}
/*
@@ -1185,17 +1191,17 @@ static void connectivity_state_set(
static void add_to_pollset_locked(grpc_chttp2_transport *t,
grpc_pollset *pollset,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
if (t->ep) {
- grpc_endpoint_add_to_pollset(t->ep, pollset, call_list);
+ grpc_endpoint_add_to_pollset(t->ep, pollset, closure_list);
}
}
static void add_to_pollset_set_locked(grpc_chttp2_transport *t,
grpc_pollset_set *pollset_set,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
if (t->ep) {
- grpc_endpoint_add_to_pollset_set(t->ep, pollset_set, call_list);
+ grpc_endpoint_add_to_pollset_set(t->ep, pollset_set, closure_list);
}
}
@@ -1234,7 +1240,8 @@ void grpc_chttp2_flowctl_trace(const char *file, int line, const char *reason,
* INTEGRATION GLUE
*/
-static char *chttp2_get_peer(grpc_transport *t, grpc_call_list *call_list) {
+static char *chttp2_get_peer(grpc_transport *t,
+ grpc_closure_list *closure_list) {
return gpr_strdup(((grpc_chttp2_transport *)t)->peer_string);
}
@@ -1248,17 +1255,17 @@ static const grpc_transport_vtable vtable = {sizeof(grpc_chttp2_stream),
grpc_transport *grpc_create_chttp2_transport(
const grpc_channel_args *channel_args, grpc_endpoint *ep, grpc_mdctx *mdctx,
- int is_client, grpc_call_list *call_list) {
+ int is_client, grpc_closure_list *closure_list) {
grpc_chttp2_transport *t = gpr_malloc(sizeof(grpc_chttp2_transport));
- init_transport(t, channel_args, ep, mdctx, is_client != 0, call_list);
+ init_transport(t, channel_args, ep, mdctx, is_client != 0, closure_list);
return &t->base;
}
void grpc_chttp2_transport_start_reading(grpc_transport *transport,
gpr_slice *slices, size_t nslices,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_chttp2_transport *t = (grpc_chttp2_transport *)transport;
REF_TRANSPORT(t, "recv_data"); /* matches unref inside recv_data */
gpr_slice_buffer_addn(&t->read_buffer, slices, nslices);
- recv_data(t, 1, call_list);
+ recv_data(t, 1, closure_list);
}
diff --git a/src/core/transport/chttp2_transport.h b/src/core/transport/chttp2_transport.h
index e963e16707b6bb1f0e252f0d1fac9b7b9a9cca82..93a654bc83e7c9ad196ad3d545f3247cb0aa2ee4 100644
--- a/src/core/transport/chttp2_transport.h
+++ b/src/core/transport/chttp2_transport.h
@@ -42,10 +42,11 @@ extern int grpc_flowctl_trace;
grpc_transport *grpc_create_chttp2_transport(
const grpc_channel_args *channel_args, grpc_endpoint *ep,
- grpc_mdctx *metadata_context, int is_client, grpc_call_list *call_list);
+ grpc_mdctx *metadata_context, int is_client,
+ grpc_closure_list *closure_list);
void grpc_chttp2_transport_start_reading(grpc_transport *transport,
gpr_slice *slices, size_t nslices,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_TRANSPORT_CHTTP2_TRANSPORT_H */
diff --git a/src/core/transport/connectivity_state.c b/src/core/transport/connectivity_state.c
index d04c3a2209a1ae1f85d9edfed8fdf88575ced940..638ec62e734668ea03451ff06d2251d29c8fe29f 100644
--- a/src/core/transport/connectivity_state.c
+++ b/src/core/transport/connectivity_state.c
@@ -67,7 +67,7 @@ void grpc_connectivity_state_init(grpc_connectivity_state_tracker *tracker,
}
void grpc_connectivity_state_destroy(grpc_connectivity_state_tracker *tracker,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
int success;
grpc_connectivity_state_watcher *w;
while ((w = tracker->watchers)) {
@@ -79,7 +79,7 @@ void grpc_connectivity_state_destroy(grpc_connectivity_state_tracker *tracker,
} else {
success = 0;
}
- grpc_call_list_add(call_list, w->notify, success);
+ grpc_closure_list_add(closure_list, w->notify, success);
gpr_free(w);
}
gpr_free(tracker->name);
@@ -96,7 +96,7 @@ grpc_connectivity_state grpc_connectivity_state_check(
int grpc_connectivity_state_notify_on_state_change(
grpc_connectivity_state_tracker *tracker, grpc_connectivity_state *current,
- grpc_closure *notify, grpc_call_list *call_list) {
+ grpc_closure *notify, grpc_closure_list *closure_list) {
if (grpc_connectivity_state_trace) {
gpr_log(GPR_DEBUG, "CONWATCH: %s: from %s [cur=%s] notify=%p",
tracker->name, grpc_connectivity_state_name(*current),
@@ -104,7 +104,7 @@ int grpc_connectivity_state_notify_on_state_change(
}
if (tracker->current_state != *current) {
*current = tracker->current_state;
- grpc_call_list_add(call_list, notify, 1);
+ grpc_closure_list_add(closure_list, notify, 1);
} else {
grpc_connectivity_state_watcher *w = gpr_malloc(sizeof(*w));
w->current = current;
@@ -118,7 +118,7 @@ int grpc_connectivity_state_notify_on_state_change(
void grpc_connectivity_state_set(grpc_connectivity_state_tracker *tracker,
grpc_connectivity_state state,
const char *reason,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_connectivity_state_watcher *w;
if (grpc_connectivity_state_trace) {
gpr_log(GPR_DEBUG, "SET: %s: %s --> %s [%s]", tracker->name,
@@ -133,7 +133,7 @@ void grpc_connectivity_state_set(grpc_connectivity_state_tracker *tracker,
while ((w = tracker->watchers) != NULL) {
*w->current = tracker->current_state;
tracker->watchers = w->next;
- grpc_call_list_add(call_list, w->notify, 1);
+ grpc_closure_list_add(closure_list, w->notify, 1);
gpr_free(w);
}
}
diff --git a/src/core/transport/connectivity_state.h b/src/core/transport/connectivity_state.h
index 6ade8e19f73861ee3c4b2c63a6367b1d1f33a18a..26f8874fbc420ba66598aea0bffeefc382b82050 100644
--- a/src/core/transport/connectivity_state.h
+++ b/src/core/transport/connectivity_state.h
@@ -61,13 +61,14 @@ void grpc_connectivity_state_init(grpc_connectivity_state_tracker *tracker,
grpc_connectivity_state init_state,
const char *name);
void grpc_connectivity_state_destroy(grpc_connectivity_state_tracker *tracker,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/** Set connectivity state; not thread safe; access must be serialized with an
* external lock */
void grpc_connectivity_state_set(grpc_connectivity_state_tracker *tracker,
grpc_connectivity_state state,
- const char *reason, grpc_call_list *call_list);
+ const char *reason,
+ grpc_closure_list *closure_list);
grpc_connectivity_state grpc_connectivity_state_check(
grpc_connectivity_state_tracker *tracker);
@@ -75,6 +76,6 @@ grpc_connectivity_state grpc_connectivity_state_check(
/** Return 1 if the channel should start connecting, 0 otherwise */
int grpc_connectivity_state_notify_on_state_change(
grpc_connectivity_state_tracker *tracker, grpc_connectivity_state *current,
- grpc_closure *notify, grpc_call_list *call_list);
+ grpc_closure *notify, grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_TRANSPORT_CONNECTIVITY_STATE_H */
diff --git a/src/core/transport/transport.c b/src/core/transport/transport.c
index f7c87c1e90b6f3a6b41c6af8ba563a54d229efdc..24d549a29b7fef085cdb87066335e1d7fb0b4062 100644
--- a/src/core/transport/transport.c
+++ b/src/core/transport/transport.c
@@ -41,46 +41,46 @@ size_t grpc_transport_stream_size(grpc_transport *transport) {
}
void grpc_transport_destroy(grpc_transport *transport,
- grpc_call_list *call_list) {
- transport->vtable->destroy(transport, call_list);
+ grpc_closure_list *closure_list) {
+ transport->vtable->destroy(transport, closure_list);
}
int grpc_transport_init_stream(grpc_transport *transport, grpc_stream *stream,
const void *server_data,
grpc_transport_stream_op *initial_op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
return transport->vtable->init_stream(transport, stream, server_data,
- initial_op, call_list);
+ initial_op, closure_list);
}
void grpc_transport_perform_stream_op(grpc_transport *transport,
grpc_stream *stream,
grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
- transport->vtable->perform_stream_op(transport, stream, op, call_list);
+ grpc_closure_list *closure_list) {
+ transport->vtable->perform_stream_op(transport, stream, op, closure_list);
}
void grpc_transport_perform_op(grpc_transport *transport, grpc_transport_op *op,
- grpc_call_list *call_list) {
- transport->vtable->perform_op(transport, op, call_list);
+ grpc_closure_list *closure_list) {
+ transport->vtable->perform_op(transport, op, closure_list);
}
void grpc_transport_destroy_stream(grpc_transport *transport,
grpc_stream *stream,
- grpc_call_list *call_list) {
- transport->vtable->destroy_stream(transport, stream, call_list);
+ grpc_closure_list *closure_list) {
+ transport->vtable->destroy_stream(transport, stream, closure_list);
}
char *grpc_transport_get_peer(grpc_transport *transport,
- grpc_call_list *call_list) {
- return transport->vtable->get_peer(transport, call_list);
+ grpc_closure_list *closure_list) {
+ return transport->vtable->get_peer(transport, closure_list);
}
-void grpc_transport_stream_op_finish_with_failure(grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
- grpc_call_list_add(call_list, op->on_done_recv, 0);
- grpc_call_list_add(call_list, op->on_done_send, 0);
- grpc_call_list_add(call_list, op->on_consumed, 0);
+void grpc_transport_stream_op_finish_with_failure(
+ grpc_transport_stream_op *op, grpc_closure_list *closure_list) {
+ grpc_closure_list_add(closure_list, op->on_done_recv, 0);
+ grpc_closure_list_add(closure_list, op->on_done_send, 0);
+ grpc_closure_list_add(closure_list, op->on_consumed, 0);
}
void grpc_transport_stream_op_add_cancellation(grpc_transport_stream_op *op,
@@ -105,11 +105,11 @@ typedef struct {
} close_message_data;
static void free_message(void *p, int iomgr_success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
close_message_data *cmd = p;
gpr_slice_unref(cmd->message);
if (cmd->then_call != NULL) {
- cmd->then_call->cb(cmd->then_call->cb_arg, iomgr_success, call_list);
+ cmd->then_call->cb(cmd->then_call->cb_arg, iomgr_success, closure_list);
}
gpr_free(cmd);
}
diff --git a/src/core/transport/transport.h b/src/core/transport/transport.h
index d5383ad11a47e5fdffd2eac2e636dd77f7832cc7..1d6dd1e735aa1bef08c0ae091f4fa03e9501c1e0 100644
--- a/src/core/transport/transport.h
+++ b/src/core/transport/transport.h
@@ -137,7 +137,7 @@ size_t grpc_transport_stream_size(grpc_transport *transport);
int grpc_transport_init_stream(grpc_transport *transport, grpc_stream *stream,
const void *server_data,
grpc_transport_stream_op *initial_op,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Destroy transport data for a stream.
@@ -151,10 +151,10 @@ int grpc_transport_init_stream(grpc_transport *transport, grpc_stream *stream,
caller, but any child memory must be cleaned up) */
void grpc_transport_destroy_stream(grpc_transport *transport,
grpc_stream *stream,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
-void grpc_transport_stream_op_finish_with_failure(grpc_transport_stream_op *op,
- grpc_call_list *call_list);
+void grpc_transport_stream_op_finish_with_failure(
+ grpc_transport_stream_op *op, grpc_closure_list *closure_list);
void grpc_transport_stream_op_add_cancellation(grpc_transport_stream_op *op,
grpc_status_code status);
@@ -177,10 +177,10 @@ char *grpc_transport_stream_op_string(grpc_transport_stream_op *op);
void grpc_transport_perform_stream_op(grpc_transport *transport,
grpc_stream *stream,
grpc_transport_stream_op *op,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
void grpc_transport_perform_op(grpc_transport *transport, grpc_transport_op *op,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Send a ping on a transport
@@ -196,10 +196,10 @@ void grpc_transport_close(grpc_transport *transport);
/* Destroy the transport */
void grpc_transport_destroy(grpc_transport *transport,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* Get the transports peer */
char *grpc_transport_get_peer(grpc_transport *transport,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
#endif /* GRPC_INTERNAL_CORE_TRANSPORT_TRANSPORT_H */
diff --git a/src/core/transport/transport_impl.h b/src/core/transport/transport_impl.h
index 9adb16b94119afca8c09efeafdf91ea0f5c9945f..c7eebc9bb20dac52f82c34d278fa3a0f6c244c0b 100644
--- a/src/core/transport/transport_impl.h
+++ b/src/core/transport/transport_impl.h
@@ -45,26 +45,26 @@ typedef struct grpc_transport_vtable {
int (*init_stream)(grpc_transport *self, grpc_stream *stream,
const void *server_data,
grpc_transport_stream_op *initial_op,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* implementation of grpc_transport_perform_stream_op */
void (*perform_stream_op)(grpc_transport *self, grpc_stream *stream,
grpc_transport_stream_op *op,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* implementation of grpc_transport_perform_op */
void (*perform_op)(grpc_transport *self, grpc_transport_op *op,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* implementation of grpc_transport_destroy_stream */
void (*destroy_stream)(grpc_transport *self, grpc_stream *stream,
- grpc_call_list *call_list);
+ grpc_closure_list *closure_list);
/* implementation of grpc_transport_destroy */
- void (*destroy)(grpc_transport *self, grpc_call_list *call_list);
+ void (*destroy)(grpc_transport *self, grpc_closure_list *closure_list);
/* implementation of grpc_transport_get_peer */
- char *(*get_peer)(grpc_transport *self, grpc_call_list *call_list);
+ char *(*get_peer)(grpc_transport *self, grpc_closure_list *closure_list);
} grpc_transport_vtable;
/* an instance of a grpc transport */
diff --git a/test/core/bad_client/bad_client.c b/test/core/bad_client/bad_client.c
index 747ce4050b849c51d3474b4ec7ae2f575a467574..760590441146a1e44a9daa589a3a616ead49cd8a 100644
--- a/test/core/bad_client/bad_client.c
+++ b/test/core/bad_client/bad_client.c
@@ -59,7 +59,8 @@ static void thd_func(void *arg) {
gpr_event_set(&a->done_thd, (void *)1);
}
-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) {
thd_args *a = arg;
gpr_event_set(&a->done_write, (void *)1);
}
@@ -69,11 +70,11 @@ static void server_setup_transport(void *ts, grpc_transport *transport,
thd_args *a = ts;
static grpc_channel_filter const *extra_filters[] = {
&grpc_http_server_filter};
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_server_setup_transport(
a->server, transport, extra_filters, GPR_ARRAY_SIZE(extra_filters), mdctx,
- grpc_server_get_channel_args(a->server), &call_list);
- grpc_call_list_run(&call_list);
+ grpc_server_get_channel_args(a->server), &closure_list);
+ grpc_closure_list_run(&closure_list);
}
void grpc_run_bad_client_test(grpc_bad_client_server_side_validator validator,
@@ -89,7 +90,7 @@ void grpc_run_bad_client_test(grpc_bad_client_server_side_validator validator,
gpr_slice_from_copied_buffer(client_payload, client_payload_length);
gpr_slice_buffer outgoing;
grpc_closure done_write_closure;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
hex = gpr_dump(client_payload, client_payload_length,
GPR_DUMP_HEX | GPR_DUMP_ASCII);
@@ -114,14 +115,16 @@ void grpc_run_bad_client_test(grpc_bad_client_server_side_validator validator,
grpc_server_register_completion_queue(a.server, a.cq, NULL);
grpc_server_start(a.server);
transport =
- grpc_create_chttp2_transport(NULL, sfd.server, mdctx, 0, &call_list);
+ grpc_create_chttp2_transport(NULL, sfd.server, mdctx, 0, &closure_list);
server_setup_transport(&a, transport, mdctx);
- grpc_chttp2_transport_start_reading(transport, NULL, 0, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_chttp2_transport_start_reading(transport, NULL, 0, &closure_list);
+ grpc_closure_list_run(&closure_list);
/* Bind everything into the same pollset */
- grpc_endpoint_add_to_pollset(sfd.client, grpc_cq_pollset(a.cq), &call_list);
- grpc_endpoint_add_to_pollset(sfd.server, grpc_cq_pollset(a.cq), &call_list);
+ grpc_endpoint_add_to_pollset(sfd.client, grpc_cq_pollset(a.cq),
+ &closure_list);
+ grpc_endpoint_add_to_pollset(sfd.server, grpc_cq_pollset(a.cq),
+ &closure_list);
/* Check a ground truth */
GPR_ASSERT(grpc_server_has_open_connections(a.server));
@@ -134,17 +137,18 @@ void grpc_run_bad_client_test(grpc_bad_client_server_side_validator validator,
grpc_closure_init(&done_write_closure, done_write, &a);
/* Write data */
- grpc_endpoint_write(sfd.client, &outgoing, &done_write_closure, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_endpoint_write(sfd.client, &outgoing, &done_write_closure,
+ &closure_list);
+ grpc_closure_list_run(&closure_list);
/* Await completion */
GPR_ASSERT(
gpr_event_wait(&a.done_write, GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5)));
if (flags & GRPC_BAD_CLIENT_DISCONNECT) {
- grpc_endpoint_shutdown(sfd.client, &call_list);
- grpc_endpoint_destroy(sfd.client, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_endpoint_shutdown(sfd.client, &closure_list);
+ grpc_endpoint_destroy(sfd.client, &closure_list);
+ grpc_closure_list_run(&closure_list);
sfd.client = NULL;
}
@@ -152,9 +156,9 @@ void grpc_run_bad_client_test(grpc_bad_client_server_side_validator validator,
/* Shutdown */
if (sfd.client) {
- grpc_endpoint_shutdown(sfd.client, &call_list);
- grpc_endpoint_destroy(sfd.client, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_endpoint_shutdown(sfd.client, &closure_list);
+ grpc_endpoint_destroy(sfd.client, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
grpc_server_shutdown_and_notify(a.server, a.cq, NULL);
GPR_ASSERT(grpc_completion_queue_pluck(
@@ -164,6 +168,6 @@ void grpc_run_bad_client_test(grpc_bad_client_server_side_validator validator,
grpc_completion_queue_destroy(a.cq);
gpr_slice_buffer_destroy(&outgoing);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
grpc_shutdown();
}
diff --git a/test/core/channel/channel_stack_test.c b/test/core/channel/channel_stack_test.c
index 07df92127010970e2278e4c030f94a1c481d4885..72b48e208d383f9a25019919bc728d3c6eefe4f0 100644
--- a/test/core/channel/channel_stack_test.c
+++ b/test/core/channel/channel_stack_test.c
@@ -44,7 +44,7 @@
static void channel_init_func(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) {
GPR_ASSERT(args->num_args == 1);
GPR_ASSERT(args->args[0].type == GRPC_ARG_INTEGER);
GPR_ASSERT(0 == strcmp(args->args[0].key, "test_key"));
@@ -57,30 +57,31 @@ static void channel_init_func(grpc_channel_element *elem, grpc_channel *master,
static void call_init_func(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) {
++*(int *)(elem->channel_data);
*(int *)(elem->call_data) = 0;
}
static void channel_destroy_func(grpc_channel_element *elem,
- grpc_call_list *call_list) {}
+ grpc_closure_list *closure_list) {}
static void call_destroy_func(grpc_call_element *elem,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
++*(int *)(elem->channel_data);
}
static void call_func(grpc_call_element *elem, grpc_transport_stream_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
++*(int *)(elem->call_data);
}
static void channel_func(grpc_channel_element *elem, grpc_transport_op *op,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
++*(int *)(elem->channel_data);
}
-static char *get_peer(grpc_call_element *elem, grpc_call_list *call_list) {
+static char *get_peer(grpc_call_element *elem,
+ grpc_closure_list *closure_list) {
return gpr_strdup("peer");
}
@@ -100,7 +101,7 @@ static void test_create_channel_stack(void) {
grpc_mdctx *metadata_context;
int *channel_data;
int *call_data;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
metadata_context = grpc_mdctx_create();
@@ -113,14 +114,14 @@ static void test_create_channel_stack(void) {
channel_stack = gpr_malloc(grpc_channel_stack_size(&filters, 1));
grpc_channel_stack_init(&filters, 1, NULL, &chan_args, metadata_context,
- channel_stack, &call_list);
+ channel_stack, &closure_list);
GPR_ASSERT(channel_stack->count == 1);
channel_elem = grpc_channel_stack_element(channel_stack, 0);
channel_data = (int *)channel_elem->channel_data;
GPR_ASSERT(*channel_data == 0);
call_stack = gpr_malloc(channel_stack->call_stack_size);
- grpc_call_stack_init(channel_stack, NULL, NULL, call_stack, &call_list);
+ grpc_call_stack_init(channel_stack, NULL, NULL, call_stack, &closure_list);
GPR_ASSERT(call_stack->count == 1);
call_elem = grpc_call_stack_element(call_stack, 0);
GPR_ASSERT(call_elem->filter == channel_elem->filter);
@@ -129,16 +130,16 @@ static void test_create_channel_stack(void) {
GPR_ASSERT(*call_data == 0);
GPR_ASSERT(*channel_data == 1);
- grpc_call_stack_destroy(call_stack, &call_list);
+ grpc_call_stack_destroy(call_stack, &closure_list);
gpr_free(call_stack);
GPR_ASSERT(*channel_data == 2);
- grpc_channel_stack_destroy(channel_stack, &call_list);
+ grpc_channel_stack_destroy(channel_stack, &closure_list);
gpr_free(channel_stack);
grpc_mdctx_unref(metadata_context);
- GPR_ASSERT(grpc_call_list_empty(call_list));
+ GPR_ASSERT(grpc_closure_list_empty(closure_list));
}
int main(int argc, char **argv) {
diff --git a/test/core/client_config/lb_policies_test.c b/test/core/client_config/lb_policies_test.c
index ee3164f4fd0abf1588175ce113b069809ade59aa..411e96598ab407050658e84d522b9367177d9c34 100644
--- a/test/core/client_config/lb_policies_test.c
+++ b/test/core/client_config/lb_policies_test.c
@@ -387,15 +387,15 @@ static void assert_channel_connectivity(
grpc_channel_stack *client_stack;
grpc_channel_element *client_channel_filter;
grpc_connectivity_state actual_conn_state;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
va_list ap;
client_stack = grpc_channel_get_channel_stack(ch);
client_channel_filter = grpc_channel_stack_last_element(client_stack);
actual_conn_state = grpc_client_channel_check_connectivity_state(
- client_channel_filter, 0 /* don't try to connect */, &call_list);
- grpc_call_list_run(&call_list);
+ client_channel_filter, 0 /* don't try to connect */, &closure_list);
+ grpc_closure_list_run(&closure_list);
va_start(ap, accepted_conn_state);
for (i = 0; i < num_accepted_conn_states; i++) {
if (actual_conn_state == accepted_conn_state) {
diff --git a/test/core/end2end/fixtures/h2_sockpair+trace.c b/test/core/end2end/fixtures/h2_sockpair+trace.c
index d0279e79bad0e0d52d5af337aff330f167373a41..b79c483703eb9388276a8969275403ca75fd2966 100644
--- a/test/core/end2end/fixtures/h2_sockpair+trace.c
+++ b/test/core/end2end/fixtures/h2_sockpair+trace.c
@@ -62,11 +62,11 @@ static void server_setup_transport(void *ts, grpc_transport *transport,
grpc_end2end_test_fixture *f = ts;
static grpc_channel_filter const *extra_filters[] = {
&grpc_http_server_filter};
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_server_setup_transport(
f->server, transport, extra_filters, GPR_ARRAY_SIZE(extra_filters), mdctx,
- grpc_server_get_channel_args(f->server), &call_list);
- grpc_call_list_run(&call_list);
+ grpc_server_get_channel_args(f->server), &closure_list);
+ grpc_closure_list_run(&closure_list);
}
typedef struct {
@@ -76,7 +76,7 @@ typedef struct {
static void client_setup_transport(void *ts, grpc_transport *transport,
grpc_mdctx *mdctx,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
sp_client_setup *cs = ts;
const grpc_channel_filter *filters[] = {&grpc_http_client_filter,
@@ -85,7 +85,7 @@ static void client_setup_transport(void *ts, grpc_transport *transport,
size_t nfilters = sizeof(filters) / sizeof(*filters);
grpc_channel *channel =
grpc_channel_create_from_filters("socketpair-target", filters, nfilters,
- cs->client_args, mdctx, 1, call_list);
+ cs->client_args, mdctx, 1, closure_list);
cs->f->client = channel;
@@ -109,7 +109,7 @@ static grpc_end2end_test_fixture chttp2_create_fixture_socketpair(
static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
grpc_channel_args *client_args) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_endpoint_pair *sfd = f->fixture_data;
grpc_transport *transport;
grpc_mdctx *mdctx = grpc_mdctx_create();
@@ -117,16 +117,16 @@ static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
cs.client_args = client_args;
cs.f = f;
transport = grpc_create_chttp2_transport(client_args, sfd->client, mdctx, 1,
- &call_list);
- client_setup_transport(&cs, transport, mdctx, &call_list);
+ &closure_list);
+ client_setup_transport(&cs, transport, mdctx, &closure_list);
GPR_ASSERT(f->client);
- grpc_chttp2_transport_start_reading(transport, NULL, 0, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_chttp2_transport_start_reading(transport, NULL, 0, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f,
grpc_channel_args *server_args) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_endpoint_pair *sfd = f->fixture_data;
grpc_mdctx *mdctx = grpc_mdctx_create();
grpc_transport *transport;
@@ -135,10 +135,10 @@ static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f,
grpc_server_register_completion_queue(f->server, f->cq, NULL);
grpc_server_start(f->server);
transport = grpc_create_chttp2_transport(server_args, sfd->server, mdctx, 0,
- &call_list);
+ &closure_list);
server_setup_transport(f, transport, mdctx);
- grpc_chttp2_transport_start_reading(transport, NULL, 0, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_chttp2_transport_start_reading(transport, NULL, 0, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
static void chttp2_tear_down_socketpair(grpc_end2end_test_fixture *f) {
@@ -154,7 +154,7 @@ static grpc_end2end_test_config configs[] = {
int main(int argc, char **argv) {
size_t i;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
/* force tracing on, with a value to force many
code paths in trace.c to be taken */
@@ -167,7 +167,7 @@ int main(int argc, char **argv) {
grpc_test_init(argc, argv);
grpc_init();
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
GPR_ASSERT(0 == grpc_tracer_set_enabled("also-doesnt-exist", 0));
GPR_ASSERT(1 == grpc_tracer_set_enabled("http", 1));
diff --git a/test/core/end2end/fixtures/h2_sockpair.c b/test/core/end2end/fixtures/h2_sockpair.c
index 57fc98697405edf5dc3f98a84b84a7c5bb53bbb2..e927a0e0d8005ab62e6e6b3f42d213b1fd94edfc 100644
--- a/test/core/end2end/fixtures/h2_sockpair.c
+++ b/test/core/end2end/fixtures/h2_sockpair.c
@@ -61,11 +61,11 @@ static void server_setup_transport(void *ts, grpc_transport *transport,
grpc_end2end_test_fixture *f = ts;
static grpc_channel_filter const *extra_filters[] = {
&grpc_http_server_filter};
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_server_setup_transport(
f->server, transport, extra_filters, GPR_ARRAY_SIZE(extra_filters), mdctx,
- grpc_server_get_channel_args(f->server), &call_list);
- grpc_call_list_run(&call_list);
+ grpc_server_get_channel_args(f->server), &closure_list);
+ grpc_closure_list_run(&closure_list);
}
typedef struct {
@@ -75,7 +75,7 @@ typedef struct {
static void client_setup_transport(void *ts, grpc_transport *transport,
grpc_mdctx *mdctx,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
sp_client_setup *cs = ts;
const grpc_channel_filter *filters[] = {&grpc_http_client_filter,
@@ -84,7 +84,7 @@ static void client_setup_transport(void *ts, grpc_transport *transport,
size_t nfilters = sizeof(filters) / sizeof(*filters);
grpc_channel *channel =
grpc_channel_create_from_filters("socketpair-target", filters, nfilters,
- cs->client_args, mdctx, 1, call_list);
+ cs->client_args, mdctx, 1, closure_list);
cs->f->client = channel;
@@ -108,7 +108,7 @@ static grpc_end2end_test_fixture chttp2_create_fixture_socketpair(
static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
grpc_channel_args *client_args) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_endpoint_pair *sfd = f->fixture_data;
grpc_transport *transport;
grpc_mdctx *mdctx = grpc_mdctx_create();
@@ -116,16 +116,16 @@ static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
cs.client_args = client_args;
cs.f = f;
transport = grpc_create_chttp2_transport(client_args, sfd->client, mdctx, 1,
- &call_list);
- client_setup_transport(&cs, transport, mdctx, &call_list);
+ &closure_list);
+ client_setup_transport(&cs, transport, mdctx, &closure_list);
GPR_ASSERT(f->client);
- grpc_chttp2_transport_start_reading(transport, NULL, 0, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_chttp2_transport_start_reading(transport, NULL, 0, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f,
grpc_channel_args *server_args) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_endpoint_pair *sfd = f->fixture_data;
grpc_mdctx *mdctx = grpc_mdctx_create();
grpc_transport *transport;
@@ -134,10 +134,10 @@ static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f,
grpc_server_register_completion_queue(f->server, f->cq, NULL);
grpc_server_start(f->server);
transport = grpc_create_chttp2_transport(server_args, sfd->server, mdctx, 0,
- &call_list);
+ &closure_list);
server_setup_transport(f, transport, mdctx);
- grpc_chttp2_transport_start_reading(transport, NULL, 0, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_chttp2_transport_start_reading(transport, NULL, 0, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
static void chttp2_tear_down_socketpair(grpc_end2end_test_fixture *f) {
diff --git a/test/core/end2end/fixtures/h2_sockpair_1byte.c b/test/core/end2end/fixtures/h2_sockpair_1byte.c
index d0c552a66921b577191acd52514b193fdfe42c6a..8a9196d3b609685a81fe5bb6ee17393150ccc972 100644
--- a/test/core/end2end/fixtures/h2_sockpair_1byte.c
+++ b/test/core/end2end/fixtures/h2_sockpair_1byte.c
@@ -61,11 +61,11 @@ static void server_setup_transport(void *ts, grpc_transport *transport,
grpc_end2end_test_fixture *f = ts;
static grpc_channel_filter const *extra_filters[] = {
&grpc_http_server_filter};
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_server_setup_transport(
f->server, transport, extra_filters, GPR_ARRAY_SIZE(extra_filters), mdctx,
- grpc_server_get_channel_args(f->server), &call_list);
- grpc_call_list_run(&call_list);
+ grpc_server_get_channel_args(f->server), &closure_list);
+ grpc_closure_list_run(&closure_list);
}
typedef struct {
@@ -75,7 +75,7 @@ typedef struct {
static void client_setup_transport(void *ts, grpc_transport *transport,
grpc_mdctx *mdctx,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
sp_client_setup *cs = ts;
const grpc_channel_filter *filters[] = {&grpc_http_client_filter,
@@ -84,7 +84,7 @@ static void client_setup_transport(void *ts, grpc_transport *transport,
size_t nfilters = sizeof(filters) / sizeof(*filters);
grpc_channel *channel =
grpc_channel_create_from_filters("socketpair-target", filters, nfilters,
- cs->client_args, mdctx, 1, call_list);
+ cs->client_args, mdctx, 1, closure_list);
cs->f->client = channel;
@@ -108,7 +108,7 @@ static grpc_end2end_test_fixture chttp2_create_fixture_socketpair(
static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
grpc_channel_args *client_args) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_endpoint_pair *sfd = f->fixture_data;
grpc_transport *transport;
grpc_mdctx *mdctx = grpc_mdctx_create();
@@ -116,16 +116,16 @@ static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
cs.client_args = client_args;
cs.f = f;
transport = grpc_create_chttp2_transport(client_args, sfd->client, mdctx, 1,
- &call_list);
- client_setup_transport(&cs, transport, mdctx, &call_list);
+ &closure_list);
+ client_setup_transport(&cs, transport, mdctx, &closure_list);
GPR_ASSERT(f->client);
- grpc_chttp2_transport_start_reading(transport, NULL, 0, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_chttp2_transport_start_reading(transport, NULL, 0, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f,
grpc_channel_args *server_args) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_endpoint_pair *sfd = f->fixture_data;
grpc_mdctx *mdctx = grpc_mdctx_create();
grpc_transport *transport;
@@ -134,10 +134,10 @@ static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f,
grpc_server_register_completion_queue(f->server, f->cq, NULL);
grpc_server_start(f->server);
transport = grpc_create_chttp2_transport(server_args, sfd->server, mdctx, 0,
- &call_list);
+ &closure_list);
server_setup_transport(f, transport, mdctx);
- grpc_chttp2_transport_start_reading(transport, NULL, 0, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_chttp2_transport_start_reading(transport, NULL, 0, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
static void chttp2_tear_down_socketpair(grpc_end2end_test_fixture *f) {
diff --git a/test/core/httpcli/httpcli_test.c b/test/core/httpcli/httpcli_test.c
index bcb544e50289e40133d2201db2cd4f7c5e5afb31..063565ecfc89a4f210c0a77a5d85c97b486942ec 100644
--- a/test/core/httpcli/httpcli_test.c
+++ b/test/core/httpcli/httpcli_test.c
@@ -54,7 +54,7 @@ static gpr_timespec n_seconds_time(int seconds) {
}
static void on_finish(void *arg, const grpc_httpcli_response *response,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
const char *expect =
"<html><head><title>Hello world!</title></head>"
"<body><p>This is a test</p></body></html>";
@@ -72,7 +72,7 @@ static void on_finish(void *arg, const grpc_httpcli_response *response,
static void test_get(int use_ssl, int port) {
grpc_httpcli_request req;
char *host;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
g_done = 0;
gpr_log(GPR_INFO, "running %s with use_ssl=%d.", "test_get", use_ssl);
@@ -86,14 +86,14 @@ static void test_get(int use_ssl, int port) {
req.handshaker = use_ssl ? &grpc_httpcli_ssl : &grpc_httpcli_plaintext;
grpc_httpcli_get(&g_context, &g_pollset, &req, n_seconds_time(15), on_finish,
- (void *)42, &call_list);
+ (void *)42, &closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
while (!g_done) {
grpc_pollset_worker worker;
grpc_pollset_work(&g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- n_seconds_time(20), &call_list);
+ n_seconds_time(20), &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
}
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
@@ -103,7 +103,7 @@ static void test_get(int use_ssl, int port) {
static void test_post(int use_ssl, int port) {
grpc_httpcli_request req;
char *host;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
g_done = 0;
gpr_log(GPR_INFO, "running %s with use_ssl=%d.", "test_post", (int)use_ssl);
@@ -117,27 +117,28 @@ static void test_post(int use_ssl, int port) {
req.handshaker = use_ssl ? &grpc_httpcli_ssl : &grpc_httpcli_plaintext;
grpc_httpcli_post(&g_context, &g_pollset, &req, "hello", 5,
- n_seconds_time(15), on_finish, (void *)42, &call_list);
+ n_seconds_time(15), on_finish, (void *)42, &closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
while (!g_done) {
grpc_pollset_worker worker;
grpc_pollset_work(&g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- n_seconds_time(20), &call_list);
+ n_seconds_time(20), &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
}
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
gpr_free(host);
}
-static void destroy_pollset(void *p, int success, grpc_call_list *call_list) {
+static void destroy_pollset(void *p, int success,
+ grpc_closure_list *closure_list) {
grpc_pollset_destroy(p);
}
int main(int argc, char **argv) {
grpc_closure destroyed;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
gpr_subprocess *server;
char *me = argv[0];
char *lslash = strrchr(me, '/');
@@ -175,8 +176,8 @@ int main(int argc, char **argv) {
grpc_httpcli_context_destroy(&g_context);
grpc_closure_init(&destroyed, destroy_pollset, &g_pollset);
- grpc_pollset_shutdown(&g_pollset, &destroyed, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_pollset_shutdown(&g_pollset, &destroyed, &closure_list);
+ grpc_closure_list_run(&closure_list);
grpc_shutdown();
gpr_subprocess_destroy(server);
diff --git a/test/core/iomgr/alarm_list_test.c b/test/core/iomgr/alarm_list_test.c
index 8082532434c0eaf4d6c287681da881ed82fe83fd..90ff49cb8f5a5ec0c9555a56211e0f19f462987f 100644
--- a/test/core/iomgr/alarm_list_test.c
+++ b/test/core/iomgr/alarm_list_test.c
@@ -43,7 +43,7 @@
static int cb_called[MAX_CB][2];
-static void cb(void *arg, int success, grpc_call_list *call_list) {
+static void cb(void *arg, int success, grpc_closure_list *closure_list) {
cb_called[(gpr_intptr)arg][success]++;
}
@@ -51,7 +51,7 @@ static void add_test(void) {
gpr_timespec start = gpr_now(GPR_CLOCK_REALTIME);
int i;
grpc_alarm alarms[20];
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_alarm_list_init(start);
memset(cb_called, 0, sizeof(cb_called));
@@ -60,21 +60,21 @@ static void add_test(void) {
for (i = 0; i < 10; i++) {
grpc_alarm_init(&alarms[i],
gpr_time_add(start, gpr_time_from_millis(10, GPR_TIMESPAN)),
- cb, (void *)(gpr_intptr)i, start, &call_list);
+ cb, (void *)(gpr_intptr)i, start, &closure_list);
}
/* 1010 ms alarms. will expire in the next epoch */
for (i = 10; i < 20; i++) {
grpc_alarm_init(&alarms[i], gpr_time_add(start, gpr_time_from_millis(
1010, GPR_TIMESPAN)),
- cb, (void *)(gpr_intptr)i, start, &call_list);
+ cb, (void *)(gpr_intptr)i, start, &closure_list);
}
/* collect alarms. Only the first batch should be ready. */
GPR_ASSERT(10 == grpc_alarm_check(gpr_time_add(start, gpr_time_from_millis(
500, GPR_TIMESPAN)),
- NULL, &call_list));
- grpc_call_list_run(&call_list);
+ NULL, &closure_list));
+ grpc_closure_list_run(&closure_list);
for (i = 0; i < 20; i++) {
GPR_ASSERT(cb_called[i][1] == (i < 10));
GPR_ASSERT(cb_called[i][0] == 0);
@@ -82,8 +82,8 @@ static void add_test(void) {
GPR_ASSERT(0 == grpc_alarm_check(gpr_time_add(start, gpr_time_from_millis(
600, GPR_TIMESPAN)),
- NULL, &call_list));
- grpc_call_list_run(&call_list);
+ NULL, &closure_list));
+ grpc_closure_list_run(&closure_list);
for (i = 0; i < 30; i++) {
GPR_ASSERT(cb_called[i][1] == (i < 10));
GPR_ASSERT(cb_called[i][0] == 0);
@@ -93,8 +93,8 @@ static void add_test(void) {
GPR_ASSERT(10 ==
grpc_alarm_check(
gpr_time_add(start, gpr_time_from_millis(1500, GPR_TIMESPAN)),
- NULL, &call_list));
- grpc_call_list_run(&call_list);
+ NULL, &closure_list));
+ grpc_closure_list_run(&closure_list);
for (i = 0; i < 30; i++) {
GPR_ASSERT(cb_called[i][1] == (i < 20));
GPR_ASSERT(cb_called[i][0] == 0);
@@ -102,14 +102,14 @@ static void add_test(void) {
GPR_ASSERT(0 == grpc_alarm_check(gpr_time_add(start, gpr_time_from_millis(
1600, GPR_TIMESPAN)),
- NULL, &call_list));
+ NULL, &closure_list));
for (i = 0; i < 30; i++) {
GPR_ASSERT(cb_called[i][1] == (i < 20));
GPR_ASSERT(cb_called[i][0] == 0);
}
- grpc_alarm_list_shutdown(&call_list);
- grpc_call_list_run(&call_list);
+ grpc_alarm_list_shutdown(&closure_list);
+ grpc_closure_list_run(&closure_list);
}
static gpr_timespec tfm(int m) {
@@ -121,32 +121,32 @@ static gpr_timespec tfm(int m) {
/* Cleaning up a list with pending alarms. */
void destruction_test(void) {
grpc_alarm alarms[5];
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_alarm_list_init(gpr_time_0(GPR_CLOCK_REALTIME));
memset(cb_called, 0, sizeof(cb_called));
grpc_alarm_init(&alarms[0], tfm(100), cb, (void *)(gpr_intptr)0,
- gpr_time_0(GPR_CLOCK_REALTIME), &call_list);
+ gpr_time_0(GPR_CLOCK_REALTIME), &closure_list);
grpc_alarm_init(&alarms[1], tfm(3), cb, (void *)(gpr_intptr)1,
- gpr_time_0(GPR_CLOCK_REALTIME), &call_list);
+ gpr_time_0(GPR_CLOCK_REALTIME), &closure_list);
grpc_alarm_init(&alarms[2], tfm(100), cb, (void *)(gpr_intptr)2,
- gpr_time_0(GPR_CLOCK_REALTIME), &call_list);
+ gpr_time_0(GPR_CLOCK_REALTIME), &closure_list);
grpc_alarm_init(&alarms[3], tfm(3), cb, (void *)(gpr_intptr)3,
- gpr_time_0(GPR_CLOCK_REALTIME), &call_list);
+ gpr_time_0(GPR_CLOCK_REALTIME), &closure_list);
grpc_alarm_init(&alarms[4], tfm(1), cb, (void *)(gpr_intptr)4,
- gpr_time_0(GPR_CLOCK_REALTIME), &call_list);
- GPR_ASSERT(1 == grpc_alarm_check(tfm(2), NULL, &call_list));
- grpc_call_list_run(&call_list);
+ gpr_time_0(GPR_CLOCK_REALTIME), &closure_list);
+ GPR_ASSERT(1 == grpc_alarm_check(tfm(2), NULL, &closure_list));
+ grpc_closure_list_run(&closure_list);
GPR_ASSERT(1 == cb_called[4][1]);
- grpc_alarm_cancel(&alarms[0], &call_list);
- grpc_alarm_cancel(&alarms[3], &call_list);
- grpc_call_list_run(&call_list);
+ grpc_alarm_cancel(&alarms[0], &closure_list);
+ grpc_alarm_cancel(&alarms[3], &closure_list);
+ grpc_closure_list_run(&closure_list);
GPR_ASSERT(1 == cb_called[0][0]);
GPR_ASSERT(1 == cb_called[3][0]);
- grpc_alarm_list_shutdown(&call_list);
- grpc_call_list_run(&call_list);
+ grpc_alarm_list_shutdown(&closure_list);
+ grpc_closure_list_run(&closure_list);
GPR_ASSERT(1 == cb_called[1][0]);
GPR_ASSERT(1 == cb_called[2][0]);
}
diff --git a/test/core/iomgr/endpoint_pair_test.c b/test/core/iomgr/endpoint_pair_test.c
index 491effd5ae2fe3d6a9670d61e616b0b6f85b0c1e..32c715c4286dc5aa7db8f47cb6c8a5a327376491 100644
--- a/test/core/iomgr/endpoint_pair_test.c
+++ b/test/core/iomgr/endpoint_pair_test.c
@@ -48,15 +48,15 @@ static void clean_up(void) {}
static grpc_endpoint_test_fixture create_fixture_endpoint_pair(
size_t slice_size) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_endpoint_test_fixture f;
grpc_endpoint_pair p = grpc_iomgr_create_endpoint_pair("test", slice_size);
f.client_ep = p.client;
f.server_ep = p.server;
- grpc_endpoint_add_to_pollset(f.client_ep, &g_pollset, &call_list);
- grpc_endpoint_add_to_pollset(f.server_ep, &g_pollset, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_endpoint_add_to_pollset(f.client_ep, &g_pollset, &closure_list);
+ grpc_endpoint_add_to_pollset(f.server_ep, &g_pollset, &closure_list);
+ grpc_closure_list_run(&closure_list);
return f;
}
@@ -65,20 +65,21 @@ static grpc_endpoint_test_config configs[] = {
{"tcp/tcp_socketpair", create_fixture_endpoint_pair, clean_up},
};
-static void destroy_pollset(void *p, int success, grpc_call_list *call_list) {
+static void destroy_pollset(void *p, int success,
+ grpc_closure_list *closure_list) {
grpc_pollset_destroy(p);
}
int main(int argc, char **argv) {
grpc_closure destroyed;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_test_init(argc, argv);
grpc_init();
grpc_pollset_init(&g_pollset);
grpc_endpoint_tests(configs[0], &g_pollset);
grpc_closure_init(&destroyed, destroy_pollset, &g_pollset);
- grpc_pollset_shutdown(&g_pollset, &destroyed, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_pollset_shutdown(&g_pollset, &destroyed, &closure_list);
+ grpc_closure_list_run(&closure_list);
grpc_shutdown();
return 0;
diff --git a/test/core/iomgr/endpoint_tests.c b/test/core/iomgr/endpoint_tests.c
index 31743167cd29e5b42f8dd602e8c9578939606ccb..e106881d91b3c4efa02652023bb312758c4fddb9 100644
--- a/test/core/iomgr/endpoint_tests.c
+++ b/test/core/iomgr/endpoint_tests.c
@@ -127,7 +127,7 @@ struct read_and_write_test_state {
};
static void read_and_write_test_read_handler(void *data, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
struct read_and_write_test_state *state = data;
state->bytes_read += count_slices(
@@ -140,12 +140,12 @@ static void read_and_write_test_read_handler(void *data, int success,
gpr_mu_unlock(GRPC_POLLSET_MU(g_pollset));
} else if (success) {
grpc_endpoint_read(state->read_ep, &state->incoming, &state->done_read,
- call_list);
+ closure_list);
}
}
static void read_and_write_test_write_handler(void *data, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
struct read_and_write_test_state *state = data;
gpr_slice *slices = NULL;
size_t nslices;
@@ -162,7 +162,7 @@ static void read_and_write_test_write_handler(void *data, int success,
gpr_slice_buffer_reset_and_unref(&state->outgoing);
gpr_slice_buffer_addn(&state->outgoing, slices, nslices);
grpc_endpoint_write(state->write_ep, &state->outgoing, &state->done_write,
- call_list);
+ closure_list);
free(slices);
return;
}
@@ -186,7 +186,7 @@ static void read_and_write_test(grpc_endpoint_test_config config,
gpr_timespec deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE(20);
grpc_endpoint_test_fixture f =
begin_test(config, "read_and_write_test", slice_size);
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
gpr_log(GPR_DEBUG, "num_bytes=%d write_size=%d slice_size=%d shutdown=%d",
num_bytes, write_size, slice_size, shutdown);
@@ -218,36 +218,36 @@ static void read_and_write_test(grpc_endpoint_test_config config,
for the first iteration as for later iterations. It does the right thing
even when bytes_written is unsigned. */
state.bytes_written -= state.current_write_size;
- read_and_write_test_write_handler(&state, 1, &call_list);
- grpc_call_list_run(&call_list);
+ read_and_write_test_write_handler(&state, 1, &closure_list);
+ grpc_closure_list_run(&closure_list);
grpc_endpoint_read(state.read_ep, &state.incoming, &state.done_read,
- &call_list);
+ &closure_list);
if (shutdown) {
gpr_log(GPR_DEBUG, "shutdown read");
- grpc_endpoint_shutdown(state.read_ep, &call_list);
+ grpc_endpoint_shutdown(state.read_ep, &closure_list);
gpr_log(GPR_DEBUG, "shutdown write");
- grpc_endpoint_shutdown(state.write_ep, &call_list);
+ grpc_endpoint_shutdown(state.write_ep, &closure_list);
}
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(g_pollset));
while (!state.read_done || !state.write_done) {
grpc_pollset_worker worker;
GPR_ASSERT(gpr_time_cmp(gpr_now(GPR_CLOCK_MONOTONIC), deadline) < 0);
grpc_pollset_work(g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- deadline, &call_list);
+ deadline, &closure_list);
}
gpr_mu_unlock(GRPC_POLLSET_MU(g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
end_test(config);
gpr_slice_buffer_destroy(&state.outgoing);
gpr_slice_buffer_destroy(&state.incoming);
- grpc_endpoint_destroy(state.read_ep, &call_list);
- grpc_endpoint_destroy(state.write_ep, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_endpoint_destroy(state.read_ep, &closure_list);
+ grpc_endpoint_destroy(state.write_ep, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
void grpc_endpoint_tests(grpc_endpoint_test_config config,
diff --git a/test/core/iomgr/fd_conservation_posix_test.c b/test/core/iomgr/fd_conservation_posix_test.c
index a1b1171b07d6e2917e692ba66c81afa422dd3185..1ffb5808b728b9bb68e7196303006e8db6264865 100644
--- a/test/core/iomgr/fd_conservation_posix_test.c
+++ b/test/core/iomgr/fd_conservation_posix_test.c
@@ -54,11 +54,11 @@ int main(int argc, char **argv) {
GPR_ASSERT(0 == setrlimit(RLIMIT_NOFILE, &rlim));
for (i = 0; i < 100; i++) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
p = grpc_iomgr_create_endpoint_pair("test", 1);
- grpc_endpoint_destroy(p.client, &call_list);
- grpc_endpoint_destroy(p.server, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_endpoint_destroy(p.client, &closure_list);
+ grpc_endpoint_destroy(p.server, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
grpc_iomgr_shutdown();
diff --git a/test/core/iomgr/fd_posix_test.c b/test/core/iomgr/fd_posix_test.c
index f89d6c782480b878763401ed2db005a4ca61d0a4..0a8d40419b13f77c35555275bb321f34ac196187 100644
--- a/test/core/iomgr/fd_posix_test.c
+++ b/test/core/iomgr/fd_posix_test.c
@@ -118,18 +118,18 @@ typedef struct {
/* Called when an upload session can be safely shutdown.
Close session FD and start to shutdown listen FD. */
static void session_shutdown_cb(void *arg, /*session*/
- int success, grpc_call_list *call_list) {
+ int success, grpc_closure_list *closure_list) {
session *se = arg;
server *sv = se->sv;
- grpc_fd_orphan(se->em_fd, NULL, "a", call_list);
+ grpc_fd_orphan(se->em_fd, NULL, "a", closure_list);
gpr_free(se);
/* Start to shutdown listen fd. */
- grpc_fd_shutdown(sv->em_fd, call_list);
+ grpc_fd_shutdown(sv->em_fd, closure_list);
}
/* Called when data become readable in a session. */
static void session_read_cb(void *arg, /*session*/
- int success, grpc_call_list *call_list) {
+ int success, grpc_closure_list *closure_list) {
session *se = arg;
int fd = se->em_fd->fd;
@@ -137,7 +137,7 @@ static void session_read_cb(void *arg, /*session*/
ssize_t read_total = 0;
if (!success) {
- session_shutdown_cb(arg, 1, call_list);
+ session_shutdown_cb(arg, 1, closure_list);
return;
}
@@ -152,7 +152,7 @@ static void session_read_cb(void *arg, /*session*/
It is possible to read nothing due to spurious edge event or data has
been drained, In such a case, read() returns -1 and set errno to EAGAIN. */
if (read_once == 0) {
- session_shutdown_cb(arg, 1, call_list);
+ session_shutdown_cb(arg, 1, closure_list);
} else if (read_once == -1) {
if (errno == EAGAIN) {
/* An edge triggered event is cached in the kernel until next poll.
@@ -163,7 +163,8 @@ static void session_read_cb(void *arg, /*session*/
TODO(chenw): in multi-threaded version, callback and polling can be
run in different threads. polling may catch a persist read edge event
before notify_on_read is called. */
- grpc_fd_notify_on_read(se->em_fd, &se->session_read_closure, call_list);
+ grpc_fd_notify_on_read(se->em_fd, &se->session_read_closure,
+ closure_list);
} else {
gpr_log(GPR_ERROR, "Unhandled read error %s", strerror(errno));
abort();
@@ -174,10 +175,10 @@ static void session_read_cb(void *arg, /*session*/
/* Called when the listen FD can be safely shutdown.
Close listen FD and signal that server can be shutdown. */
static void listen_shutdown_cb(void *arg /*server*/, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
server *sv = arg;
- grpc_fd_orphan(sv->em_fd, NULL, "b", call_list);
+ grpc_fd_orphan(sv->em_fd, NULL, "b", closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
sv->done = 1;
@@ -187,7 +188,7 @@ static void listen_shutdown_cb(void *arg /*server*/, int success,
/* Called when a new TCP connection request arrives in the listening port. */
static void listen_cb(void *arg, /*=sv_arg*/
- int success, grpc_call_list *call_list) {
+ int success, grpc_closure_list *closure_list) {
server *sv = arg;
int fd;
int flags;
@@ -197,7 +198,7 @@ static void listen_cb(void *arg, /*=sv_arg*/
grpc_fd *listen_em_fd = sv->em_fd;
if (!success) {
- listen_shutdown_cb(arg, 1, call_list);
+ listen_shutdown_cb(arg, 1, closure_list);
return;
}
@@ -209,12 +210,12 @@ static void listen_cb(void *arg, /*=sv_arg*/
se = gpr_malloc(sizeof(*se));
se->sv = sv;
se->em_fd = grpc_fd_create(fd, "listener");
- grpc_pollset_add_fd(&g_pollset, se->em_fd, call_list);
+ grpc_pollset_add_fd(&g_pollset, se->em_fd, closure_list);
se->session_read_closure.cb = session_read_cb;
se->session_read_closure.cb_arg = se;
- grpc_fd_notify_on_read(se->em_fd, &se->session_read_closure, call_list);
+ grpc_fd_notify_on_read(se->em_fd, &se->session_read_closure, closure_list);
- grpc_fd_notify_on_read(listen_em_fd, &sv->listen_closure, call_list);
+ grpc_fd_notify_on_read(listen_em_fd, &sv->listen_closure, closure_list);
}
/* Max number of connections pending to be accepted by listen(). */
@@ -224,7 +225,7 @@ static void listen_cb(void *arg, /*=sv_arg*/
listen_cb() is registered to be interested in reading from listen_fd.
When connection request arrives, listen_cb() is called to accept the
connection request. */
-static int server_start(server *sv, grpc_call_list *call_list) {
+static int server_start(server *sv, grpc_closure_list *closure_list) {
int port = 0;
int fd;
struct sockaddr_in sin;
@@ -238,11 +239,11 @@ static int server_start(server *sv, grpc_call_list *call_list) {
GPR_ASSERT(listen(fd, MAX_NUM_FD) == 0);
sv->em_fd = grpc_fd_create(fd, "server");
- grpc_pollset_add_fd(&g_pollset, sv->em_fd, call_list);
+ grpc_pollset_add_fd(&g_pollset, sv->em_fd, closure_list);
/* Register to be interested in reading from listen_fd. */
sv->listen_closure.cb = listen_cb;
sv->listen_closure.cb_arg = sv;
- grpc_fd_notify_on_read(sv->em_fd, &sv->listen_closure, call_list);
+ grpc_fd_notify_on_read(sv->em_fd, &sv->listen_closure, closure_list);
return port;
}
@@ -251,12 +252,12 @@ static int server_start(server *sv, grpc_call_list *call_list) {
static void server_wait_and_shutdown(server *sv) {
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
while (!sv->done) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_pollset_worker worker;
grpc_pollset_work(&g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- gpr_inf_future(GPR_CLOCK_MONOTONIC), &call_list);
+ gpr_inf_future(GPR_CLOCK_MONOTONIC), &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
}
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
@@ -291,23 +292,23 @@ static void client_init(client *cl) {
/* Called when a client upload session is ready to shutdown. */
static void client_session_shutdown_cb(void *arg /*client*/, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
client *cl = arg;
- grpc_fd_orphan(cl->em_fd, NULL, "c", call_list);
+ grpc_fd_orphan(cl->em_fd, NULL, "c", closure_list);
cl->done = 1;
grpc_pollset_kick(&g_pollset, NULL);
}
/* Write as much as possible, then register notify_on_write. */
static void client_session_write(void *arg, /*client*/
- int success, grpc_call_list *call_list) {
+ int success, grpc_closure_list *closure_list) {
client *cl = arg;
int fd = cl->em_fd->fd;
ssize_t write_once = 0;
if (!success) {
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
- client_session_shutdown_cb(arg, 1, call_list);
+ client_session_shutdown_cb(arg, 1, closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
return;
}
@@ -322,10 +323,10 @@ static void client_session_write(void *arg, /*client*/
if (cl->client_write_cnt < CLIENT_TOTAL_WRITE_CNT) {
cl->write_closure.cb = client_session_write;
cl->write_closure.cb_arg = cl;
- grpc_fd_notify_on_write(cl->em_fd, &cl->write_closure, call_list);
+ grpc_fd_notify_on_write(cl->em_fd, &cl->write_closure, closure_list);
cl->client_write_cnt++;
} else {
- client_session_shutdown_cb(arg, 1, call_list);
+ client_session_shutdown_cb(arg, 1, closure_list);
}
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
} else {
@@ -335,7 +336,8 @@ static void client_session_write(void *arg, /*client*/
}
/* Start a client to send a stream of bytes. */
-static void client_start(client *cl, int port, grpc_call_list *call_list) {
+static void client_start(client *cl, int port,
+ grpc_closure_list *closure_list) {
int fd;
struct sockaddr_in sin;
create_test_socket(port, &fd, &sin);
@@ -356,9 +358,9 @@ static void client_start(client *cl, int port, grpc_call_list *call_list) {
}
cl->em_fd = grpc_fd_create(fd, "client");
- grpc_pollset_add_fd(&g_pollset, cl->em_fd, call_list);
+ grpc_pollset_add_fd(&g_pollset, cl->em_fd, closure_list);
- client_session_write(cl, 1, call_list);
+ client_session_write(cl, 1, closure_list);
}
/* Wait for the signal to shutdown a client. */
@@ -366,11 +368,11 @@ static void client_wait_and_shutdown(client *cl) {
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
while (!cl->done) {
grpc_pollset_worker worker;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_pollset_work(&g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- gpr_inf_future(GPR_CLOCK_MONOTONIC), &call_list);
+ gpr_inf_future(GPR_CLOCK_MONOTONIC), &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
}
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
@@ -383,13 +385,13 @@ static void test_grpc_fd(void) {
server sv;
client cl;
int port;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
server_init(&sv);
- port = server_start(&sv, &call_list);
+ port = server_start(&sv, &closure_list);
client_init(&cl);
- client_start(&cl, port, &call_list);
- grpc_call_list_run(&call_list);
+ client_start(&cl, port, &closure_list);
+ grpc_closure_list_run(&closure_list);
client_wait_and_shutdown(&cl);
server_wait_and_shutdown(&sv);
GPR_ASSERT(sv.read_bytes_total == cl.write_bytes_total);
@@ -397,7 +399,7 @@ static void test_grpc_fd(void) {
}
typedef struct fd_change_data {
- void (*cb_that_ran)(void *, int success, grpc_call_list *call_list);
+ void (*cb_that_ran)(void *, int success, grpc_closure_list *closure_list);
} fd_change_data;
void init_change_data(fd_change_data *fdc) { fdc->cb_that_ran = NULL; }
@@ -405,7 +407,7 @@ void init_change_data(fd_change_data *fdc) { fdc->cb_that_ran = NULL; }
void destroy_change_data(fd_change_data *fdc) {}
static void first_read_callback(void *arg /* fd_change_data */, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
fd_change_data *fdc = arg;
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
@@ -415,7 +417,7 @@ static void first_read_callback(void *arg /* fd_change_data */, int success,
}
static void second_read_callback(void *arg /* fd_change_data */, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
fd_change_data *fdc = arg;
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
@@ -437,7 +439,7 @@ static void test_grpc_fd_change(void) {
ssize_t result;
grpc_closure first_closure;
grpc_closure second_closure;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
first_closure.cb = first_read_callback;
first_closure.cb_arg = &a;
@@ -454,10 +456,10 @@ static void test_grpc_fd_change(void) {
GPR_ASSERT(fcntl(sv[1], F_SETFL, flags | O_NONBLOCK) == 0);
em_fd = grpc_fd_create(sv[0], "test_grpc_fd_change");
- grpc_pollset_add_fd(&g_pollset, em_fd, &call_list);
+ grpc_pollset_add_fd(&g_pollset, em_fd, &closure_list);
/* Register the first callback, then make its FD readable */
- grpc_fd_notify_on_read(em_fd, &first_closure, &call_list);
+ grpc_fd_notify_on_read(em_fd, &first_closure, &closure_list);
data = 0;
result = write(sv[1], &data, 1);
GPR_ASSERT(result == 1);
@@ -467,9 +469,9 @@ static void test_grpc_fd_change(void) {
while (a.cb_that_ran == NULL) {
grpc_pollset_worker worker;
grpc_pollset_work(&g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- gpr_inf_future(GPR_CLOCK_MONOTONIC), &call_list);
+ gpr_inf_future(GPR_CLOCK_MONOTONIC), &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
}
GPR_ASSERT(a.cb_that_ran == first_read_callback);
@@ -481,7 +483,7 @@ static void test_grpc_fd_change(void) {
/* Now register a second callback with distinct change data, and do the same
thing again. */
- grpc_fd_notify_on_read(em_fd, &second_closure, &call_list);
+ grpc_fd_notify_on_read(em_fd, &second_closure, &closure_list);
data = 0;
result = write(sv[1], &data, 1);
GPR_ASSERT(result == 1);
@@ -490,37 +492,38 @@ static void test_grpc_fd_change(void) {
while (b.cb_that_ran == NULL) {
grpc_pollset_worker worker;
grpc_pollset_work(&g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- gpr_inf_future(GPR_CLOCK_MONOTONIC), &call_list);
+ gpr_inf_future(GPR_CLOCK_MONOTONIC), &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
}
/* Except now we verify that second_read_callback ran instead */
GPR_ASSERT(b.cb_that_ran == second_read_callback);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_fd_orphan(em_fd, NULL, "d", &call_list);
- grpc_call_list_run(&call_list);
+ grpc_fd_orphan(em_fd, NULL, "d", &closure_list);
+ grpc_closure_list_run(&closure_list);
destroy_change_data(&a);
destroy_change_data(&b);
close(sv[1]);
}
-static void destroy_pollset(void *p, int success, grpc_call_list *call_list) {
+static void destroy_pollset(void *p, int success,
+ grpc_closure_list *closure_list) {
grpc_pollset_destroy(p);
}
int main(int argc, char **argv) {
grpc_closure destroyed;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_test_init(argc, argv);
grpc_iomgr_init();
grpc_pollset_init(&g_pollset);
test_grpc_fd();
test_grpc_fd_change();
grpc_closure_init(&destroyed, destroy_pollset, &g_pollset);
- grpc_pollset_shutdown(&g_pollset, &destroyed, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_pollset_shutdown(&g_pollset, &destroyed, &closure_list);
+ grpc_closure_list_run(&closure_list);
grpc_iomgr_shutdown();
return 0;
}
diff --git a/test/core/iomgr/resolve_address_test.c b/test/core/iomgr/resolve_address_test.c
index 2ea3b56ee626c209ba071a126d99ad3c4b35a80e..4d41020768af77587380783fdb7075601a34aa70 100644
--- a/test/core/iomgr/resolve_address_test.c
+++ b/test/core/iomgr/resolve_address_test.c
@@ -43,7 +43,7 @@ static gpr_timespec test_deadline(void) {
}
static void must_succeed(void* evp, grpc_resolved_addresses* p,
- grpc_call_list* call_list) {
+ grpc_closure_list* closure_list) {
GPR_ASSERT(p);
GPR_ASSERT(p->naddrs >= 1);
grpc_resolved_addresses_destroy(p);
@@ -51,7 +51,7 @@ static void must_succeed(void* evp, grpc_resolved_addresses* p,
}
static void must_fail(void* evp, grpc_resolved_addresses* p,
- grpc_call_list* call_list) {
+ grpc_closure_list* closure_list) {
GPR_ASSERT(!p);
gpr_event_set(evp, (void*)1);
}
diff --git a/test/core/iomgr/tcp_client_posix_test.c b/test/core/iomgr/tcp_client_posix_test.c
index 0dd752d841c23b115e37ef3ac1c7fc81f30ae366..436e5cf7dfa11b2f7675c7c5a59727f07de83de8 100644
--- a/test/core/iomgr/tcp_client_posix_test.c
+++ b/test/core/iomgr/tcp_client_posix_test.c
@@ -63,16 +63,17 @@ static void finish_connection() {
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
}
-static void must_succeed(void *arg, int success, grpc_call_list *call_list) {
+static void must_succeed(void *arg, int success,
+ grpc_closure_list *closure_list) {
GPR_ASSERT(g_connecting != NULL);
GPR_ASSERT(success);
- grpc_endpoint_shutdown(g_connecting, call_list);
- grpc_endpoint_destroy(g_connecting, call_list);
+ grpc_endpoint_shutdown(g_connecting, closure_list);
+ grpc_endpoint_destroy(g_connecting, closure_list);
g_connecting = NULL;
finish_connection();
}
-static void must_fail(void *arg, int success, grpc_call_list *call_list) {
+static void must_fail(void *arg, int success, grpc_closure_list *closure_list) {
GPR_ASSERT(g_connecting == NULL);
GPR_ASSERT(!success);
finish_connection();
@@ -85,7 +86,7 @@ void test_succeeds(void) {
int r;
int connections_complete_before;
grpc_closure done;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
gpr_log(GPR_DEBUG, "test_succeeds");
@@ -107,7 +108,7 @@ void test_succeeds(void) {
grpc_closure_init(&done, must_succeed, NULL);
grpc_tcp_client_connect(&done, &g_connecting, &g_pollset_set,
(struct sockaddr *)&addr, addr_len,
- gpr_inf_future(GPR_CLOCK_REALTIME), &call_list);
+ gpr_inf_future(GPR_CLOCK_REALTIME), &closure_list);
/* await the connection */
do {
@@ -122,9 +123,9 @@ void test_succeeds(void) {
while (g_connections_complete == connections_complete_before) {
grpc_pollset_worker worker;
grpc_pollset_work(&g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5), &call_list);
+ GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5), &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
}
@@ -136,7 +137,7 @@ void test_fails(void) {
socklen_t addr_len = sizeof(addr);
int connections_complete_before;
grpc_closure done;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
gpr_log(GPR_DEBUG, "test_fails");
@@ -151,7 +152,7 @@ void test_fails(void) {
grpc_closure_init(&done, must_fail, NULL);
grpc_tcp_client_connect(&done, &g_connecting, &g_pollset_set,
(struct sockaddr *)&addr, addr_len,
- gpr_inf_future(GPR_CLOCK_REALTIME), &call_list);
+ gpr_inf_future(GPR_CLOCK_REALTIME), &closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
@@ -159,9 +160,9 @@ void test_fails(void) {
while (g_connections_complete == connections_complete_before) {
grpc_pollset_worker worker;
grpc_pollset_work(&g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- test_deadline(), &call_list);
+ test_deadline(), &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
}
@@ -179,7 +180,7 @@ void test_times_out(void) {
int connections_complete_before;
gpr_timespec connect_deadline;
grpc_closure done;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
gpr_log(GPR_DEBUG, "test_times_out");
@@ -216,7 +217,7 @@ void test_times_out(void) {
grpc_closure_init(&done, must_fail, NULL);
grpc_tcp_client_connect(&done, &g_connecting, &g_pollset_set,
(struct sockaddr *)&addr, addr_len, connect_deadline,
- &call_list);
+ &closure_list);
/* Make sure the event doesn't trigger early */
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
@@ -242,9 +243,9 @@ void test_times_out(void) {
connections_complete_before + is_after_deadline);
}
grpc_pollset_work(&g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- GRPC_TIMEOUT_MILLIS_TO_DEADLINE(10), &call_list);
+ GRPC_TIMEOUT_MILLIS_TO_DEADLINE(10), &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
}
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
@@ -255,27 +256,28 @@ void test_times_out(void) {
}
}
-static void destroy_pollset(void *p, int success, grpc_call_list *call_list) {
+static void destroy_pollset(void *p, int success,
+ grpc_closure_list *closure_list) {
grpc_pollset_destroy(p);
}
int main(int argc, char **argv) {
grpc_closure destroyed;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_test_init(argc, argv);
grpc_init();
grpc_pollset_set_init(&g_pollset_set);
grpc_pollset_init(&g_pollset);
- grpc_pollset_set_add_pollset(&g_pollset_set, &g_pollset, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_pollset_set_add_pollset(&g_pollset_set, &g_pollset, &closure_list);
+ grpc_closure_list_run(&closure_list);
test_succeeds();
gpr_log(GPR_ERROR, "End of first test");
test_fails();
test_times_out();
grpc_pollset_set_destroy(&g_pollset_set);
grpc_closure_init(&destroyed, destroy_pollset, &g_pollset);
- grpc_pollset_shutdown(&g_pollset, &destroyed, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_pollset_shutdown(&g_pollset, &destroyed, &closure_list);
+ grpc_closure_list_run(&closure_list);
grpc_shutdown();
return 0;
}
diff --git a/test/core/iomgr/tcp_posix_test.c b/test/core/iomgr/tcp_posix_test.c
index 09e67155e41a425ecbdd4addd183c0cc2f03cd77..9edfe76e046f37774a1c21cee70a99163fbd8a3f 100644
--- a/test/core/iomgr/tcp_posix_test.c
+++ b/test/core/iomgr/tcp_posix_test.c
@@ -138,7 +138,8 @@ static size_t count_slices(gpr_slice *slices, size_t nslices,
return num_bytes;
}
-static void read_cb(void *user_data, int success, grpc_call_list *call_list) {
+static void read_cb(void *user_data, int success,
+ grpc_closure_list *closure_list) {
struct read_socket_state *state = (struct read_socket_state *)user_data;
size_t read_bytes;
int current_data;
@@ -155,7 +156,8 @@ static void read_cb(void *user_data, int success, grpc_call_list *call_list) {
if (state->read_bytes >= state->target_read_bytes) {
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
} else {
- grpc_endpoint_read(state->ep, &state->incoming, &state->read_cb, call_list);
+ grpc_endpoint_read(state->ep, &state->incoming, &state->read_cb,
+ closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
}
}
@@ -167,7 +169,7 @@ static void read_test(size_t num_bytes, size_t slice_size) {
struct read_socket_state state;
size_t written_bytes;
gpr_timespec deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE(20);
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
gpr_log(GPR_INFO, "Read test of size %d, slice size %d", num_bytes,
slice_size);
@@ -175,7 +177,7 @@ static void read_test(size_t num_bytes, size_t slice_size) {
create_sockets(sv);
ep = grpc_tcp_create(grpc_fd_create(sv[1], "read_test"), slice_size, "test");
- grpc_endpoint_add_to_pollset(ep, &g_pollset, &call_list);
+ grpc_endpoint_add_to_pollset(ep, &g_pollset, &closure_list);
written_bytes = fill_socket_partial(sv[0], num_bytes);
gpr_log(GPR_INFO, "Wrote %d bytes", written_bytes);
@@ -186,23 +188,23 @@ static void read_test(size_t num_bytes, size_t slice_size) {
gpr_slice_buffer_init(&state.incoming);
grpc_closure_init(&state.read_cb, read_cb, &state);
- grpc_endpoint_read(ep, &state.incoming, &state.read_cb, &call_list);
+ grpc_endpoint_read(ep, &state.incoming, &state.read_cb, &closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
while (state.read_bytes < state.target_read_bytes) {
grpc_pollset_worker worker;
grpc_pollset_work(&g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- deadline, &call_list);
+ deadline, &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
}
GPR_ASSERT(state.read_bytes == state.target_read_bytes);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
gpr_slice_buffer_destroy(&state.incoming);
- grpc_endpoint_destroy(ep, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_endpoint_destroy(ep, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
/* Write to a socket until it fills up, then read from it using the grpc_tcp
@@ -213,7 +215,7 @@ static void large_read_test(size_t slice_size) {
struct read_socket_state state;
ssize_t written_bytes;
gpr_timespec deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE(20);
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
gpr_log(GPR_INFO, "Start large read test, slice size %d", slice_size);
@@ -221,7 +223,7 @@ static void large_read_test(size_t slice_size) {
ep = grpc_tcp_create(grpc_fd_create(sv[1], "large_read_test"), slice_size,
"test");
- grpc_endpoint_add_to_pollset(ep, &g_pollset, &call_list);
+ grpc_endpoint_add_to_pollset(ep, &g_pollset, &closure_list);
written_bytes = fill_socket(sv[0]);
gpr_log(GPR_INFO, "Wrote %d bytes", written_bytes);
@@ -232,23 +234,23 @@ static void large_read_test(size_t slice_size) {
gpr_slice_buffer_init(&state.incoming);
grpc_closure_init(&state.read_cb, read_cb, &state);
- grpc_endpoint_read(ep, &state.incoming, &state.read_cb, &call_list);
+ grpc_endpoint_read(ep, &state.incoming, &state.read_cb, &closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
while (state.read_bytes < state.target_read_bytes) {
grpc_pollset_worker worker;
grpc_pollset_work(&g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- deadline, &call_list);
+ deadline, &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
}
GPR_ASSERT(state.read_bytes == state.target_read_bytes);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
gpr_slice_buffer_destroy(&state.incoming);
- grpc_endpoint_destroy(ep, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_endpoint_destroy(ep, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
struct write_socket_state {
@@ -280,7 +282,7 @@ static gpr_slice *allocate_blocks(size_t num_bytes, size_t slice_size,
}
static void write_done(void *user_data /* write_socket_state */, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
struct write_socket_state *state = (struct write_socket_state *)user_data;
gpr_log(GPR_INFO, "Write done callback called");
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
@@ -297,7 +299,7 @@ void drain_socket_blocking(int fd, size_t num_bytes, size_t read_size) {
int flags;
int current = 0;
int i;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
flags = fcntl(fd, F_GETFL, 0);
GPR_ASSERT(fcntl(fd, F_SETFL, flags & ~O_NONBLOCK) == 0);
@@ -306,9 +308,9 @@ void drain_socket_blocking(int fd, size_t num_bytes, size_t read_size) {
grpc_pollset_worker worker;
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
grpc_pollset_work(&g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- GRPC_TIMEOUT_MILLIS_TO_DEADLINE(10), &call_list);
+ GRPC_TIMEOUT_MILLIS_TO_DEADLINE(10), &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
do {
bytes_read =
read(fd, buf, bytes_left > read_size ? read_size : bytes_left);
@@ -340,7 +342,7 @@ static void write_test(size_t num_bytes, size_t slice_size) {
gpr_slice_buffer outgoing;
grpc_closure write_done_closure;
gpr_timespec deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE(20);
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
gpr_log(GPR_INFO, "Start write test with %d bytes, slice size %d", num_bytes,
slice_size);
@@ -349,7 +351,7 @@ static void write_test(size_t num_bytes, size_t slice_size) {
ep = grpc_tcp_create(grpc_fd_create(sv[1], "write_test"),
GRPC_TCP_DEFAULT_READ_SLICE_SIZE, "test");
- grpc_endpoint_add_to_pollset(ep, &g_pollset, &call_list);
+ grpc_endpoint_add_to_pollset(ep, &g_pollset, &closure_list);
state.ep = ep;
state.write_done = 0;
@@ -360,7 +362,7 @@ static void write_test(size_t num_bytes, size_t slice_size) {
gpr_slice_buffer_addn(&outgoing, slices, num_blocks);
grpc_closure_init(&write_done_closure, write_done, &state);
- grpc_endpoint_write(ep, &outgoing, &write_done_closure, &call_list);
+ grpc_endpoint_write(ep, &outgoing, &write_done_closure, &closure_list);
drain_socket_blocking(sv[0], num_bytes, num_bytes);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
for (;;) {
@@ -369,17 +371,17 @@ static void write_test(size_t num_bytes, size_t slice_size) {
break;
}
grpc_pollset_work(&g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- deadline, &call_list);
+ deadline, &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
}
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
gpr_slice_buffer_destroy(&outgoing);
- grpc_endpoint_destroy(ep, &call_list);
+ grpc_endpoint_destroy(ep, &closure_list);
gpr_free(slices);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
void run_tests(void) {
@@ -409,17 +411,17 @@ static grpc_endpoint_test_fixture create_fixture_tcp_socketpair(
size_t slice_size) {
int sv[2];
grpc_endpoint_test_fixture f;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
create_sockets(sv);
f.client_ep = grpc_tcp_create(grpc_fd_create(sv[0], "fixture:client"),
slice_size, "test");
f.server_ep = grpc_tcp_create(grpc_fd_create(sv[1], "fixture:server"),
slice_size, "test");
- grpc_endpoint_add_to_pollset(f.client_ep, &g_pollset, &call_list);
- grpc_endpoint_add_to_pollset(f.server_ep, &g_pollset, &call_list);
+ grpc_endpoint_add_to_pollset(f.client_ep, &g_pollset, &closure_list);
+ grpc_endpoint_add_to_pollset(f.server_ep, &g_pollset, &closure_list);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
return f;
}
@@ -428,21 +430,22 @@ static grpc_endpoint_test_config configs[] = {
{"tcp/tcp_socketpair", create_fixture_tcp_socketpair, clean_up},
};
-static void destroy_pollset(void *p, int success, grpc_call_list *call_list) {
+static void destroy_pollset(void *p, int success,
+ grpc_closure_list *closure_list) {
grpc_pollset_destroy(p);
}
int main(int argc, char **argv) {
grpc_closure destroyed;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_test_init(argc, argv);
grpc_init();
grpc_pollset_init(&g_pollset);
run_tests();
grpc_endpoint_tests(configs[0], &g_pollset);
grpc_closure_init(&destroyed, destroy_pollset, &g_pollset);
- grpc_pollset_shutdown(&g_pollset, &destroyed, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_pollset_shutdown(&g_pollset, &destroyed, &closure_list);
+ grpc_closure_list_run(&closure_list);
grpc_shutdown();
return 0;
diff --git a/test/core/iomgr/tcp_server_posix_test.c b/test/core/iomgr/tcp_server_posix_test.c
index 6ce78d208882333a94247704f16c75e009337904..4a3b51efc69dca53729ca7906c99a719d70dde6d 100644
--- a/test/core/iomgr/tcp_server_posix_test.c
+++ b/test/core/iomgr/tcp_server_posix_test.c
@@ -49,9 +49,9 @@ static grpc_pollset g_pollset;
static int g_nconnects = 0;
static void on_connect(void *arg, grpc_endpoint *tcp,
- grpc_call_list *call_list) {
- grpc_endpoint_shutdown(tcp, call_list);
- grpc_endpoint_destroy(tcp, call_list);
+ grpc_closure_list *closure_list) {
+ grpc_endpoint_shutdown(tcp, closure_list);
+ grpc_endpoint_destroy(tcp, closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
g_nconnects++;
@@ -65,16 +65,16 @@ static void test_no_op(void) {
}
static void test_no_op_with_start(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_tcp_server *s = grpc_tcp_server_create();
LOG_TEST("test_no_op_with_start");
- grpc_tcp_server_start(s, NULL, 0, on_connect, NULL, &call_list);
+ grpc_tcp_server_start(s, NULL, 0, on_connect, NULL, &closure_list);
grpc_tcp_server_destroy(s, NULL, NULL);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
static void test_no_op_with_port(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
struct sockaddr_in addr;
grpc_tcp_server *s = grpc_tcp_server_create();
LOG_TEST("test_no_op_with_port");
@@ -84,12 +84,12 @@ static void test_no_op_with_port(void) {
GPR_ASSERT(
grpc_tcp_server_add_port(s, (struct sockaddr *)&addr, sizeof(addr)));
- grpc_tcp_server_destroy(s, NULL, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_tcp_server_destroy(s, NULL, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
static void test_no_op_with_port_and_start(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
struct sockaddr_in addr;
grpc_tcp_server *s = grpc_tcp_server_create();
LOG_TEST("test_no_op_with_port_and_start");
@@ -99,14 +99,14 @@ static void test_no_op_with_port_and_start(void) {
GPR_ASSERT(
grpc_tcp_server_add_port(s, (struct sockaddr *)&addr, sizeof(addr)));
- grpc_tcp_server_start(s, NULL, 0, on_connect, NULL, &call_list);
+ grpc_tcp_server_start(s, NULL, 0, on_connect, NULL, &closure_list);
- grpc_tcp_server_destroy(s, NULL, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_tcp_server_destroy(s, NULL, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
static void test_connect(int n) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
struct sockaddr_storage addr;
socklen_t addr_len = sizeof(addr);
int svrfd, clifd;
@@ -128,7 +128,7 @@ static void test_connect(int n) {
GPR_ASSERT(addr_len <= sizeof(addr));
pollsets[0] = &g_pollset;
- grpc_tcp_server_start(s, pollsets, 1, on_connect, NULL, &call_list);
+ grpc_tcp_server_start(s, pollsets, 1, on_connect, NULL, &closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
@@ -146,9 +146,9 @@ static void test_connect(int n) {
gpr_time_cmp(deadline, gpr_now(deadline.clock_type)) > 0) {
grpc_pollset_worker worker;
grpc_pollset_work(&g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- deadline, &call_list);
+ deadline, &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
}
gpr_log(GPR_DEBUG, "wait done");
@@ -159,17 +159,18 @@ static void test_connect(int n) {
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_tcp_server_destroy(s, NULL, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_tcp_server_destroy(s, NULL, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
-static void destroy_pollset(void *p, int success, grpc_call_list *call_list) {
+static void destroy_pollset(void *p, int success,
+ grpc_closure_list *closure_list) {
grpc_pollset_destroy(p);
}
int main(int argc, char **argv) {
grpc_closure destroyed;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_test_init(argc, argv);
grpc_iomgr_init();
grpc_pollset_init(&g_pollset);
@@ -182,8 +183,8 @@ int main(int argc, char **argv) {
test_connect(10);
grpc_closure_init(&destroyed, destroy_pollset, &g_pollset);
- grpc_pollset_shutdown(&g_pollset, &destroyed, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_pollset_shutdown(&g_pollset, &destroyed, &closure_list);
+ grpc_closure_list_run(&closure_list);
grpc_iomgr_shutdown();
return 0;
}
diff --git a/test/core/iomgr/udp_server_test.c b/test/core/iomgr/udp_server_test.c
index 86b6b9a9fa836633380aaf008ce45e78605e0587..067838777a085833b1ebf6acf7ce7e3c4c9007e2 100644
--- a/test/core/iomgr/udp_server_test.c
+++ b/test/core/iomgr/udp_server_test.c
@@ -69,12 +69,12 @@ static void test_no_op(void) {
}
static void test_no_op_with_start(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_udp_server *s = grpc_udp_server_create();
LOG_TEST("test_no_op_with_start");
- grpc_udp_server_start(s, NULL, 0, &call_list);
+ grpc_udp_server_start(s, NULL, 0, &closure_list);
grpc_udp_server_destroy(s, NULL, NULL);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
static void test_no_op_with_port(void) {
@@ -91,7 +91,7 @@ static void test_no_op_with_port(void) {
}
static void test_no_op_with_port_and_start(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
struct sockaddr_in addr;
grpc_udp_server *s = grpc_udp_server_create();
LOG_TEST("test_no_op_with_port_and_start");
@@ -101,14 +101,14 @@ static void test_no_op_with_port_and_start(void) {
GPR_ASSERT(grpc_udp_server_add_port(s, (struct sockaddr *)&addr, sizeof(addr),
on_read));
- grpc_udp_server_start(s, NULL, 0, &call_list);
+ grpc_udp_server_start(s, NULL, 0, &closure_list);
- grpc_udp_server_destroy(s, NULL, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_udp_server_destroy(s, NULL, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
static void test_receive(int number_of_clients) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
struct sockaddr_storage addr;
socklen_t addr_len = sizeof(addr);
int clifd, svrfd;
@@ -133,7 +133,7 @@ static void test_receive(int number_of_clients) {
GPR_ASSERT(addr_len <= sizeof(addr));
pollsets[0] = &g_pollset;
- grpc_udp_server_start(s, pollsets, 1, &call_list);
+ grpc_udp_server_start(s, pollsets, 1, &closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
@@ -150,9 +150,9 @@ static void test_receive(int number_of_clients) {
gpr_time_cmp(deadline, gpr_now(deadline.clock_type)) > 0) {
grpc_pollset_worker worker;
grpc_pollset_work(&g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- deadline, &call_list);
+ deadline, &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
}
GPR_ASSERT(g_number_of_reads == number_of_reads_before + 1);
@@ -165,13 +165,14 @@ static void test_receive(int number_of_clients) {
grpc_udp_server_destroy(s, NULL, NULL);
}
-static void destroy_pollset(void *p, int success, grpc_call_list *call_list) {
+static void destroy_pollset(void *p, int success,
+ grpc_closure_list *closure_list) {
grpc_pollset_destroy(p);
}
int main(int argc, char **argv) {
grpc_closure destroyed;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_test_init(argc, argv);
grpc_iomgr_init();
grpc_pollset_init(&g_pollset);
@@ -184,8 +185,8 @@ int main(int argc, char **argv) {
test_receive(10);
grpc_closure_init(&destroyed, destroy_pollset, &g_pollset);
- grpc_pollset_shutdown(&g_pollset, &destroyed, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_pollset_shutdown(&g_pollset, &destroyed, &closure_list);
+ grpc_closure_list_run(&closure_list);
grpc_iomgr_shutdown();
return 0;
}
diff --git a/test/core/iomgr/workqueue_test.c b/test/core/iomgr/workqueue_test.c
index 08030dfe8320d52e15de9fff06343b1828f3bc8c..e4f172d32e245e48ca4ced21892759500ff502b2 100644
--- a/test/core/iomgr/workqueue_test.c
+++ b/test/core/iomgr/workqueue_test.c
@@ -40,7 +40,8 @@
static grpc_pollset g_pollset;
-static void must_succeed(void *p, int success, grpc_call_list *call_list) {
+static void must_succeed(void *p, int success,
+ grpc_closure_list *closure_list) {
GPR_ASSERT(success == 1);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
*(int *)p = 1;
@@ -51,34 +52,35 @@ static void must_succeed(void *p, int success, grpc_call_list *call_list) {
static void test_add_closure(void) {
grpc_closure c;
int done = 0;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
- grpc_workqueue *wq = grpc_workqueue_create(&call_list);
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
+ grpc_workqueue *wq = grpc_workqueue_create(&closure_list);
gpr_timespec deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5);
grpc_pollset_worker worker;
grpc_closure_init(&c, must_succeed, &done);
grpc_workqueue_push(wq, &c, 1);
- grpc_workqueue_add_to_pollset(wq, &g_pollset, &call_list);
+ grpc_workqueue_add_to_pollset(wq, &g_pollset, &closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
GPR_ASSERT(!done);
grpc_pollset_work(&g_pollset, &worker, gpr_now(deadline.clock_type), deadline,
- &call_list);
+ &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
GPR_ASSERT(done);
- GRPC_WORKQUEUE_UNREF(wq, "destroy", &call_list);
- grpc_call_list_run(&call_list);
+ GRPC_WORKQUEUE_UNREF(wq, "destroy", &closure_list);
+ grpc_closure_list_run(&closure_list);
}
-static void destroy_pollset(void *p, int success, grpc_call_list *call_list) {
+static void destroy_pollset(void *p, int success,
+ grpc_closure_list *closure_list) {
grpc_pollset_destroy(p);
}
int main(int argc, char **argv) {
grpc_closure destroyed;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_test_init(argc, argv);
grpc_init();
grpc_pollset_init(&g_pollset);
@@ -86,8 +88,8 @@ int main(int argc, char **argv) {
test_add_closure();
grpc_closure_init(&destroyed, destroy_pollset, &g_pollset);
- grpc_pollset_shutdown(&g_pollset, &destroyed, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_pollset_shutdown(&g_pollset, &destroyed, &closure_list);
+ grpc_closure_list_run(&closure_list);
grpc_shutdown();
return 0;
}
diff --git a/test/core/security/credentials_test.c b/test/core/security/credentials_test.c
index c7bd7ab4f4fe17a358f95cfecf1d3b4d91ea661c..e48aab95fa4845b9a172cb2c61cdf898d57f64fc 100644
--- a/test/core/security/credentials_test.c
+++ b/test/core/security/credentials_test.c
@@ -319,7 +319,7 @@ static void check_google_iam_metadata(void *user_data,
grpc_credentials_md *md_elems,
size_t num_md,
grpc_credentials_status status,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_credentials *c = (grpc_credentials *)user_data;
expected_md emd[] = {{GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY,
test_google_iam_authorization_token},
@@ -332,7 +332,7 @@ static void check_google_iam_metadata(void *user_data,
}
static void test_google_iam_creds(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_credentials *creds = grpc_google_iam_credentials_create(
test_google_iam_authorization_token, test_google_iam_authority_selector,
NULL);
@@ -340,15 +340,15 @@ static void test_google_iam_creds(void) {
GPR_ASSERT(grpc_credentials_has_request_metadata_only(creds));
grpc_credentials_get_request_metadata(creds, NULL, test_service_url,
check_google_iam_metadata, creds,
- &call_list);
- grpc_call_list_run(&call_list);
+ &closure_list);
+ grpc_closure_list_run(&closure_list);
}
static void check_access_token_metadata(void *user_data,
grpc_credentials_md *md_elems,
size_t num_md,
grpc_credentials_status status,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_credentials *c = (grpc_credentials *)user_data;
expected_md emd[] = {{GRPC_AUTHORIZATION_METADATA_KEY, "Bearer blah"}};
GPR_ASSERT(status == GRPC_CREDENTIALS_OK);
@@ -358,22 +358,20 @@ static void check_access_token_metadata(void *user_data,
}
static void test_access_token_creds(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_credentials *creds = grpc_access_token_credentials_create("blah", NULL);
GPR_ASSERT(grpc_credentials_has_request_metadata(creds));
GPR_ASSERT(grpc_credentials_has_request_metadata_only(creds));
GPR_ASSERT(strcmp(creds->type, GRPC_CREDENTIALS_TYPE_OAUTH2) == 0);
grpc_credentials_get_request_metadata(creds, NULL, test_service_url,
check_access_token_metadata, creds,
- &call_list);
- grpc_call_list_run(&call_list);
+ &closure_list);
+ grpc_closure_list_run(&closure_list);
}
-static void check_ssl_oauth2_composite_metadata(void *user_data,
- grpc_credentials_md *md_elems,
- size_t num_md,
- grpc_credentials_status status,
- grpc_call_list *call_list) {
+static void check_ssl_oauth2_composite_metadata(
+ void *user_data, grpc_credentials_md *md_elems, size_t num_md,
+ grpc_credentials_status status, grpc_closure_list *closure_list) {
grpc_credentials *c = (grpc_credentials *)user_data;
expected_md emd[] = {
{GRPC_AUTHORIZATION_METADATA_KEY, test_oauth2_bearer_token}};
@@ -384,7 +382,7 @@ static void check_ssl_oauth2_composite_metadata(void *user_data,
}
static void test_ssl_oauth2_composite_creds(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_credentials *ssl_creds =
grpc_ssl_credentials_create(test_root_cert, NULL, NULL);
const grpc_credentials_array *creds_array;
@@ -406,8 +404,8 @@ static void test_ssl_oauth2_composite_creds(void) {
GRPC_CREDENTIALS_TYPE_OAUTH2) == 0);
grpc_credentials_get_request_metadata(composite_creds, NULL, test_service_url,
check_ssl_oauth2_composite_metadata,
- composite_creds, &call_list);
- grpc_call_list_run(&call_list);
+ composite_creds, &closure_list);
+ grpc_closure_list_run(&closure_list);
}
void test_ssl_fake_transport_security_composite_creds_failure(void) {
@@ -424,7 +422,7 @@ void test_ssl_fake_transport_security_composite_creds_failure(void) {
static void check_ssl_oauth2_google_iam_composite_metadata(
void *user_data, grpc_credentials_md *md_elems, size_t num_md,
- grpc_credentials_status status, grpc_call_list *call_list) {
+ grpc_credentials_status status, grpc_closure_list *closure_list) {
grpc_credentials *c = (grpc_credentials *)user_data;
expected_md emd[] = {
{GRPC_AUTHORIZATION_METADATA_KEY, test_oauth2_bearer_token},
@@ -439,7 +437,7 @@ static void check_ssl_oauth2_google_iam_composite_metadata(
}
static void test_ssl_oauth2_google_iam_composite_creds(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_credentials *ssl_creds =
grpc_ssl_credentials_create(test_root_cert, NULL, NULL);
const grpc_credentials_array *creds_array;
@@ -471,15 +469,13 @@ static void test_ssl_oauth2_google_iam_composite_creds(void) {
grpc_credentials_get_request_metadata(
composite_creds, NULL, test_service_url,
check_ssl_oauth2_google_iam_composite_metadata, composite_creds,
- &call_list);
- grpc_call_list_run(&call_list);
+ &closure_list);
+ grpc_closure_list_run(&closure_list);
}
-static void on_oauth2_creds_get_metadata_success(void *user_data,
- grpc_credentials_md *md_elems,
- size_t num_md,
- grpc_credentials_status status,
- grpc_call_list *call_list) {
+static void on_oauth2_creds_get_metadata_success(
+ void *user_data, grpc_credentials_md *md_elems, size_t num_md,
+ grpc_credentials_status status, grpc_closure_list *closure_list) {
GPR_ASSERT(status == GRPC_CREDENTIALS_OK);
GPR_ASSERT(num_md == 1);
GPR_ASSERT(gpr_slice_str_cmp(md_elems[0].key, "Authorization") == 0);
@@ -490,11 +486,9 @@ static void on_oauth2_creds_get_metadata_success(void *user_data,
GPR_ASSERT(strcmp((const char *)user_data, test_user_data) == 0);
}
-static void on_oauth2_creds_get_metadata_failure(void *user_data,
- grpc_credentials_md *md_elems,
- size_t num_md,
- grpc_credentials_status status,
- grpc_call_list *call_list) {
+static void on_oauth2_creds_get_metadata_failure(
+ void *user_data, grpc_credentials_md *md_elems, size_t num_md,
+ grpc_credentials_status status, grpc_closure_list *closure_list) {
GPR_ASSERT(status == GRPC_CREDENTIALS_ERROR);
GPR_ASSERT(num_md == 0);
GPR_ASSERT(user_data != NULL);
@@ -517,21 +511,21 @@ static void validate_compute_engine_http_request(
static int compute_engine_httpcli_get_success_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) {
grpc_httpcli_response response =
http_response(200, valid_oauth2_json_response);
validate_compute_engine_http_request(request);
- on_response(user_data, &response, call_list);
+ on_response(user_data, &response, closure_list);
return 1;
}
static int compute_engine_httpcli_get_failure_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) {
grpc_httpcli_response response = http_response(403, "Not Authorized.");
validate_compute_engine_http_request(request);
- on_response(user_data, &response, call_list);
+ on_response(user_data, &response, closure_list);
return 1;
}
@@ -539,7 +533,7 @@ static int httpcli_post_should_not_be_called(
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) {
GPR_ASSERT("HTTP POST should not be called" == NULL);
return 1;
}
@@ -547,13 +541,13 @@ static int httpcli_post_should_not_be_called(
static int httpcli_get_should_not_be_called(
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) {
GPR_ASSERT("HTTP GET should not be called" == NULL);
return 1;
}
static void test_compute_engine_creds_success(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_credentials *compute_engine_creds =
grpc_google_compute_engine_credentials_create(NULL);
GPR_ASSERT(grpc_credentials_has_request_metadata(compute_engine_creds));
@@ -562,37 +556,40 @@ static void test_compute_engine_creds_success(void) {
/* First request: http get should be called. */
grpc_httpcli_set_override(compute_engine_httpcli_get_success_override,
httpcli_post_should_not_be_called);
- grpc_credentials_get_request_metadata(
- compute_engine_creds, NULL, test_service_url,
- on_oauth2_creds_get_metadata_success, (void *)test_user_data, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_credentials_get_request_metadata(compute_engine_creds, NULL,
+ test_service_url,
+ on_oauth2_creds_get_metadata_success,
+ (void *)test_user_data, &closure_list);
+ grpc_closure_list_run(&closure_list);
/* Second request: the cached token should be served directly. */
grpc_httpcli_set_override(httpcli_get_should_not_be_called,
httpcli_post_should_not_be_called);
- grpc_credentials_get_request_metadata(
- compute_engine_creds, NULL, test_service_url,
- on_oauth2_creds_get_metadata_success, (void *)test_user_data, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_credentials_get_request_metadata(compute_engine_creds, NULL,
+ test_service_url,
+ on_oauth2_creds_get_metadata_success,
+ (void *)test_user_data, &closure_list);
+ grpc_closure_list_run(&closure_list);
grpc_credentials_unref(compute_engine_creds);
grpc_httpcli_set_override(NULL, NULL);
}
static void test_compute_engine_creds_failure(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_credentials *compute_engine_creds =
grpc_google_compute_engine_credentials_create(NULL);
grpc_httpcli_set_override(compute_engine_httpcli_get_failure_override,
httpcli_post_should_not_be_called);
GPR_ASSERT(grpc_credentials_has_request_metadata(compute_engine_creds));
GPR_ASSERT(grpc_credentials_has_request_metadata_only(compute_engine_creds));
- grpc_credentials_get_request_metadata(
- compute_engine_creds, NULL, test_service_url,
- on_oauth2_creds_get_metadata_failure, (void *)test_user_data, &call_list);
+ grpc_credentials_get_request_metadata(compute_engine_creds, NULL,
+ test_service_url,
+ on_oauth2_creds_get_metadata_failure,
+ (void *)test_user_data, &closure_list);
grpc_credentials_unref(compute_engine_creds);
grpc_httpcli_set_override(NULL, NULL);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
static void validate_refresh_token_http_request(
@@ -620,26 +617,26 @@ static void validate_refresh_token_http_request(
static int refresh_token_httpcli_post_success(
const grpc_httpcli_request *request, const char *body, size_t body_size,
gpr_timespec deadline, grpc_httpcli_response_cb on_response,
- void *user_data, grpc_call_list *call_list) {
+ void *user_data, grpc_closure_list *closure_list) {
grpc_httpcli_response response =
http_response(200, valid_oauth2_json_response);
validate_refresh_token_http_request(request, body, body_size);
- on_response(user_data, &response, call_list);
+ on_response(user_data, &response, closure_list);
return 1;
}
static int refresh_token_httpcli_post_failure(
const grpc_httpcli_request *request, const char *body, size_t body_size,
gpr_timespec deadline, grpc_httpcli_response_cb on_response,
- void *user_data, grpc_call_list *call_list) {
+ void *user_data, grpc_closure_list *closure_list) {
grpc_httpcli_response response = http_response(403, "Not Authorized.");
validate_refresh_token_http_request(request, body, body_size);
- on_response(user_data, &response, call_list);
+ on_response(user_data, &response, closure_list);
return 1;
}
static void test_refresh_token_creds_success(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_credentials *refresh_token_creds =
grpc_google_refresh_token_credentials_create(test_refresh_token_str,
NULL);
@@ -649,26 +646,28 @@ static void test_refresh_token_creds_success(void) {
/* First request: http get should be called. */
grpc_httpcli_set_override(httpcli_get_should_not_be_called,
refresh_token_httpcli_post_success);
- grpc_credentials_get_request_metadata(
- refresh_token_creds, NULL, test_service_url,
- on_oauth2_creds_get_metadata_success, (void *)test_user_data, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_credentials_get_request_metadata(refresh_token_creds, NULL,
+ test_service_url,
+ on_oauth2_creds_get_metadata_success,
+ (void *)test_user_data, &closure_list);
+ grpc_closure_list_run(&closure_list);
/* Second request: the cached token should be served directly. */
grpc_httpcli_set_override(httpcli_get_should_not_be_called,
httpcli_post_should_not_be_called);
- grpc_credentials_get_request_metadata(
- refresh_token_creds, NULL, test_service_url,
- on_oauth2_creds_get_metadata_success, (void *)test_user_data, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_credentials_get_request_metadata(refresh_token_creds, NULL,
+ test_service_url,
+ on_oauth2_creds_get_metadata_success,
+ (void *)test_user_data, &closure_list);
+ grpc_closure_list_run(&closure_list);
grpc_credentials_unref(refresh_token_creds);
grpc_httpcli_set_override(NULL, NULL);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
static void test_refresh_token_creds_failure(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_credentials *refresh_token_creds =
grpc_google_refresh_token_credentials_create(test_refresh_token_str,
NULL);
@@ -676,12 +675,13 @@ static void test_refresh_token_creds_failure(void) {
refresh_token_httpcli_post_failure);
GPR_ASSERT(grpc_credentials_has_request_metadata(refresh_token_creds));
GPR_ASSERT(grpc_credentials_has_request_metadata_only(refresh_token_creds));
- grpc_credentials_get_request_metadata(
- refresh_token_creds, NULL, test_service_url,
- on_oauth2_creds_get_metadata_failure, (void *)test_user_data, &call_list);
+ grpc_credentials_get_request_metadata(refresh_token_creds, NULL,
+ test_service_url,
+ on_oauth2_creds_get_metadata_failure,
+ (void *)test_user_data, &closure_list);
grpc_credentials_unref(refresh_token_creds);
grpc_httpcli_set_override(NULL, NULL);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
static void validate_jwt_encode_and_sign_params(
@@ -733,7 +733,7 @@ static void on_jwt_creds_get_metadata_success(void *user_data,
grpc_credentials_md *md_elems,
size_t num_md,
grpc_credentials_status status,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
char *expected_md_value;
gpr_asprintf(&expected_md_value, "Bearer %s", test_signed_jwt);
GPR_ASSERT(status == GRPC_CREDENTIALS_OK);
@@ -749,7 +749,7 @@ static void on_jwt_creds_get_metadata_failure(void *user_data,
grpc_credentials_md *md_elems,
size_t num_md,
grpc_credentials_status status,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
GPR_ASSERT(status == GRPC_CREDENTIALS_ERROR);
GPR_ASSERT(num_md == 0);
GPR_ASSERT(user_data != NULL);
@@ -758,7 +758,7 @@ static void on_jwt_creds_get_metadata_failure(void *user_data,
static void test_jwt_creds_success(void) {
char *json_key_string = test_json_key_str();
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_credentials *jwt_creds =
grpc_service_account_jwt_access_credentials_create(
json_key_string, grpc_max_auth_token_lifetime, NULL);
@@ -769,24 +769,24 @@ static void test_jwt_creds_success(void) {
grpc_jwt_encode_and_sign_set_override(encode_and_sign_jwt_success);
grpc_credentials_get_request_metadata(jwt_creds, NULL, test_service_url,
on_jwt_creds_get_metadata_success,
- (void *)test_user_data, &call_list);
- grpc_call_list_run(&call_list);
+ (void *)test_user_data, &closure_list);
+ grpc_closure_list_run(&closure_list);
/* Second request: the cached token should be served directly. */
grpc_jwt_encode_and_sign_set_override(
encode_and_sign_jwt_should_not_be_called);
grpc_credentials_get_request_metadata(jwt_creds, NULL, test_service_url,
on_jwt_creds_get_metadata_success,
- (void *)test_user_data, &call_list);
- grpc_call_list_run(&call_list);
+ (void *)test_user_data, &closure_list);
+ grpc_closure_list_run(&closure_list);
/* Third request: Different service url so jwt_encode_and_sign should be
called again (no caching). */
grpc_jwt_encode_and_sign_set_override(encode_and_sign_jwt_success);
grpc_credentials_get_request_metadata(jwt_creds, NULL, other_test_service_url,
on_jwt_creds_get_metadata_success,
- (void *)test_user_data, &call_list);
- grpc_call_list_run(&call_list);
+ (void *)test_user_data, &closure_list);
+ grpc_closure_list_run(&closure_list);
gpr_free(json_key_string);
grpc_credentials_unref(jwt_creds);
@@ -795,7 +795,7 @@ static void test_jwt_creds_success(void) {
static void test_jwt_creds_signing_failure(void) {
char *json_key_string = test_json_key_str();
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_credentials *jwt_creds =
grpc_service_account_jwt_access_credentials_create(
json_key_string, grpc_max_auth_token_lifetime, NULL);
@@ -805,12 +805,12 @@ static void test_jwt_creds_signing_failure(void) {
grpc_jwt_encode_and_sign_set_override(encode_and_sign_jwt_failure);
grpc_credentials_get_request_metadata(jwt_creds, NULL, test_service_url,
on_jwt_creds_get_metadata_failure,
- (void *)test_user_data, &call_list);
+ (void *)test_user_data, &closure_list);
gpr_free(json_key_string);
grpc_credentials_unref(jwt_creds);
grpc_jwt_encode_and_sign_set_override(NULL);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
static void set_google_default_creds_env_var_with_file_contents(
@@ -915,11 +915,9 @@ static void plugin_get_metadata_failure(void *state, const char *service_url,
"Could not get metadata for plugin.");
}
-static void on_plugin_metadata_received_success(void *user_data,
- grpc_credentials_md *md_elems,
- size_t num_md,
- grpc_credentials_status status,
- grpc_call_list *call_list) {
+static void on_plugin_metadata_received_success(
+ void *user_data, grpc_credentials_md *md_elems, size_t num_md,
+ grpc_credentials_status status, grpc_closure_list *closure_list) {
size_t i = 0;
GPR_ASSERT(user_data == NULL);
GPR_ASSERT(md_elems != NULL);
@@ -930,11 +928,9 @@ static void on_plugin_metadata_received_success(void *user_data,
}
}
-static void on_plugin_metadata_received_failure(void *user_data,
- grpc_credentials_md *md_elems,
- size_t num_md,
- grpc_credentials_status status,
- grpc_call_list *call_list) {
+static void on_plugin_metadata_received_failure(
+ void *user_data, grpc_credentials_md *md_elems, size_t num_md,
+ grpc_credentials_status status, grpc_closure_list *closure_list) {
GPR_ASSERT(user_data == NULL);
GPR_ASSERT(md_elems == NULL);
GPR_ASSERT(num_md == 0);
@@ -950,7 +946,7 @@ static void test_metadata_plugin_success(void) {
grpc_credentials *creds;
plugin_state state = PLUGIN_INITIAL_STATE;
grpc_metadata_credentials_plugin plugin;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
plugin.state = &state;
plugin.get_metadata = plugin_get_metadata_success;
@@ -960,18 +956,18 @@ static void test_metadata_plugin_success(void) {
GPR_ASSERT(state == PLUGIN_INITIAL_STATE);
grpc_credentials_get_request_metadata(creds, NULL, test_service_url,
on_plugin_metadata_received_success,
- NULL, &call_list);
+ NULL, &closure_list);
GPR_ASSERT(state == PLUGIN_GET_METADATA_CALLED_STATE);
grpc_credentials_release(creds);
GPR_ASSERT(state == PLUGIN_DESTROY_CALLED_STATE);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
static void test_metadata_plugin_failure(void) {
grpc_credentials *creds;
plugin_state state = PLUGIN_INITIAL_STATE;
grpc_metadata_credentials_plugin plugin;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
plugin.state = &state;
plugin.get_metadata = plugin_get_metadata_failure;
@@ -981,11 +977,11 @@ static void test_metadata_plugin_failure(void) {
GPR_ASSERT(state == PLUGIN_INITIAL_STATE);
grpc_credentials_get_request_metadata(creds, NULL, test_service_url,
on_plugin_metadata_received_failure,
- NULL, &call_list);
+ NULL, &closure_list);
GPR_ASSERT(state == PLUGIN_GET_METADATA_CALLED_STATE);
grpc_credentials_release(creds);
GPR_ASSERT(state == PLUGIN_DESTROY_CALLED_STATE);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
int main(int argc, char **argv) {
diff --git a/test/core/security/jwt_verifier_test.c b/test/core/security/jwt_verifier_test.c
index 00a079f54e213be5b2347de6416d0228d13a90f9..f2215e18227b2870e9673e6d61a66bad4ca978da 100644
--- a/test/core/security/jwt_verifier_test.c
+++ b/test/core/security/jwt_verifier_test.c
@@ -277,7 +277,7 @@ static int httpcli_post_should_not_be_called(
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) {
GPR_ASSERT("HTTP POST should not be called" == NULL);
return 1;
}
@@ -285,7 +285,7 @@ static int httpcli_post_should_not_be_called(
static int httpcli_get_google_keys_for_email(
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) {
grpc_httpcli_response response = http_response(200, good_google_email_keys());
GPR_ASSERT(request->handshaker == &grpc_httpcli_ssl);
GPR_ASSERT(strcmp(request->host, "www.googleapis.com") == 0);
@@ -293,7 +293,7 @@ static int httpcli_get_google_keys_for_email(
"/robot/v1/metadata/x509/"
"777-abaslkan11hlb6nmim3bpspl31ud@developer."
"gserviceaccount.com") == 0);
- on_response(user_data, &response, call_list);
+ on_response(user_data, &response, closure_list);
gpr_free(response.body);
return 1;
}
@@ -309,7 +309,7 @@ static void on_verification_success(void *user_data,
}
static void test_jwt_verifier_google_email_issuer_success(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_jwt_verifier *verifier = grpc_jwt_verifier_create(NULL, 0);
char *jwt = NULL;
char *key_str = json_key_str(json_key_str_part3_for_google_email_issuer);
@@ -324,28 +324,28 @@ static void test_jwt_verifier_google_email_issuer_success(void) {
GPR_ASSERT(jwt != NULL);
grpc_jwt_verifier_verify(verifier, NULL, jwt, expected_audience,
on_verification_success, (void *)expected_user_data,
- &call_list);
+ &closure_list);
gpr_free(jwt);
grpc_jwt_verifier_destroy(verifier);
grpc_httpcli_set_override(NULL, NULL);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
static int httpcli_get_custom_keys_for_email(
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) {
grpc_httpcli_response response = http_response(200, gpr_strdup(good_jwk_set));
GPR_ASSERT(request->handshaker == &grpc_httpcli_ssl);
GPR_ASSERT(strcmp(request->host, "keys.bar.com") == 0);
GPR_ASSERT(strcmp(request->path, "/jwk/foo@bar.com") == 0);
- on_response(user_data, &response, call_list);
+ on_response(user_data, &response, closure_list);
gpr_free(response.body);
return 1;
}
static void test_jwt_verifier_custom_email_issuer_success(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_jwt_verifier *verifier = grpc_jwt_verifier_create(&custom_mapping, 1);
char *jwt = NULL;
char *key_str = json_key_str(json_key_str_part3_for_custom_email_issuer);
@@ -360,22 +360,23 @@ static void test_jwt_verifier_custom_email_issuer_success(void) {
GPR_ASSERT(jwt != NULL);
grpc_jwt_verifier_verify(verifier, NULL, jwt, expected_audience,
on_verification_success, (void *)expected_user_data,
- &call_list);
+ &closure_list);
gpr_free(jwt);
grpc_jwt_verifier_destroy(verifier);
grpc_httpcli_set_override(NULL, NULL);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
static int httpcli_get_jwk_set(const grpc_httpcli_request *request,
gpr_timespec deadline,
grpc_httpcli_response_cb on_response,
- void *user_data, grpc_call_list *call_list) {
+ void *user_data,
+ grpc_closure_list *closure_list) {
grpc_httpcli_response response = http_response(200, gpr_strdup(good_jwk_set));
GPR_ASSERT(request->handshaker == &grpc_httpcli_ssl);
GPR_ASSERT(strcmp(request->host, "www.googleapis.com") == 0);
GPR_ASSERT(strcmp(request->path, "/oauth2/v3/certs") == 0);
- on_response(user_data, &response, call_list);
+ on_response(user_data, &response, closure_list);
gpr_free(response.body);
return 1;
}
@@ -384,7 +385,7 @@ static int httpcli_get_openid_config(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) {
grpc_httpcli_response response =
http_response(200, gpr_strdup(good_openid_config));
GPR_ASSERT(request->handshaker == &grpc_httpcli_ssl);
@@ -392,13 +393,13 @@ static int httpcli_get_openid_config(const grpc_httpcli_request *request,
GPR_ASSERT(strcmp(request->path, GRPC_OPENID_CONFIG_URL_SUFFIX) == 0);
grpc_httpcli_set_override(httpcli_get_jwk_set,
httpcli_post_should_not_be_called);
- on_response(user_data, &response, call_list);
+ on_response(user_data, &response, closure_list);
gpr_free(response.body);
return 1;
}
static void test_jwt_verifier_url_issuer_success(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_jwt_verifier *verifier = grpc_jwt_verifier_create(NULL, 0);
char *jwt = NULL;
char *key_str = json_key_str(json_key_str_part3_for_url_issuer);
@@ -413,11 +414,11 @@ static void test_jwt_verifier_url_issuer_success(void) {
GPR_ASSERT(jwt != NULL);
grpc_jwt_verifier_verify(verifier, NULL, jwt, expected_audience,
on_verification_success, (void *)expected_user_data,
- &call_list);
+ &closure_list);
gpr_free(jwt);
grpc_jwt_verifier_destroy(verifier);
grpc_httpcli_set_override(NULL, NULL);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
static void on_verification_key_retrieval_error(void *user_data,
@@ -431,17 +432,18 @@ static void on_verification_key_retrieval_error(void *user_data,
static int httpcli_get_bad_json(const grpc_httpcli_request *request,
gpr_timespec deadline,
grpc_httpcli_response_cb on_response,
- void *user_data, grpc_call_list *call_list) {
+ void *user_data,
+ grpc_closure_list *closure_list) {
grpc_httpcli_response response =
http_response(200, gpr_strdup("{\"bad\": \"stuff\"}"));
GPR_ASSERT(request->handshaker == &grpc_httpcli_ssl);
- on_response(user_data, &response, call_list);
+ on_response(user_data, &response, closure_list);
gpr_free(response.body);
return 1;
}
static void test_jwt_verifier_url_issuer_bad_config(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_jwt_verifier *verifier = grpc_jwt_verifier_create(NULL, 0);
char *jwt = NULL;
char *key_str = json_key_str(json_key_str_part3_for_url_issuer);
@@ -456,15 +458,15 @@ static void test_jwt_verifier_url_issuer_bad_config(void) {
GPR_ASSERT(jwt != NULL);
grpc_jwt_verifier_verify(verifier, NULL, jwt, expected_audience,
on_verification_key_retrieval_error,
- (void *)expected_user_data, &call_list);
+ (void *)expected_user_data, &closure_list);
gpr_free(jwt);
grpc_jwt_verifier_destroy(verifier);
grpc_httpcli_set_override(NULL, NULL);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
static void test_jwt_verifier_bad_json_key(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_jwt_verifier *verifier = grpc_jwt_verifier_create(NULL, 0);
char *jwt = NULL;
char *key_str = json_key_str(json_key_str_part3_for_google_email_issuer);
@@ -479,11 +481,11 @@ static void test_jwt_verifier_bad_json_key(void) {
GPR_ASSERT(jwt != NULL);
grpc_jwt_verifier_verify(verifier, NULL, jwt, expected_audience,
on_verification_key_retrieval_error,
- (void *)expected_user_data, &call_list);
+ (void *)expected_user_data, &closure_list);
gpr_free(jwt);
grpc_jwt_verifier_destroy(verifier);
grpc_httpcli_set_override(NULL, NULL);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
static void corrupt_jwt_sig(char *jwt) {
@@ -512,7 +514,7 @@ static void on_verification_bad_signature(void *user_data,
}
static void test_jwt_verifier_bad_signature(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_jwt_verifier *verifier = grpc_jwt_verifier_create(NULL, 0);
char *jwt = NULL;
char *key_str = json_key_str(json_key_str_part3_for_url_issuer);
@@ -528,17 +530,17 @@ static void test_jwt_verifier_bad_signature(void) {
GPR_ASSERT(jwt != NULL);
grpc_jwt_verifier_verify(verifier, NULL, jwt, expected_audience,
on_verification_bad_signature,
- (void *)expected_user_data, &call_list);
+ (void *)expected_user_data, &closure_list);
gpr_free(jwt);
grpc_jwt_verifier_destroy(verifier);
grpc_httpcli_set_override(NULL, NULL);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
static int httpcli_get_should_not_be_called(
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) {
GPR_ASSERT(0);
return 1;
}
@@ -552,16 +554,16 @@ static void on_verification_bad_format(void *user_data,
}
static void test_jwt_verifier_bad_format(void) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_jwt_verifier *verifier = grpc_jwt_verifier_create(NULL, 0);
grpc_httpcli_set_override(httpcli_get_should_not_be_called,
httpcli_post_should_not_be_called);
grpc_jwt_verifier_verify(verifier, NULL, "bad jwt", expected_audience,
on_verification_bad_format,
- (void *)expected_user_data, &call_list);
+ (void *)expected_user_data, &closure_list);
grpc_jwt_verifier_destroy(verifier);
grpc_httpcli_set_override(NULL, NULL);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
/* find verification key: bad jks, cannot find key in jks */
diff --git a/test/core/security/oauth2_utils.c b/test/core/security/oauth2_utils.c
index fad52d0c59d587d370d890f81a04679d50ce4725..30ad00cfbc9f71c3c3759c268c29512d8930d713 100644
--- a/test/core/security/oauth2_utils.c
+++ b/test/core/security/oauth2_utils.c
@@ -52,7 +52,7 @@ typedef struct {
static void on_oauth2_response(void *user_data, grpc_credentials_md *md_elems,
size_t num_md, grpc_credentials_status status,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
oauth2_request *request = user_data;
char *token = NULL;
gpr_slice token_slice;
@@ -73,11 +73,12 @@ static void on_oauth2_response(void *user_data, grpc_credentials_md *md_elems,
gpr_mu_unlock(GRPC_POLLSET_MU(&request->pollset));
}
-static void do_nothing(void *unused, int success, grpc_call_list *call_list) {}
+static void do_nothing(void *unused, int success,
+ grpc_closure_list *closure_list) {}
char *grpc_test_fetch_oauth2_token_with_credentials(grpc_credentials *creds) {
oauth2_request request;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_closure do_nothing_closure;
grpc_pollset_init(&request.pollset);
request.is_done = 0;
@@ -85,20 +86,20 @@ char *grpc_test_fetch_oauth2_token_with_credentials(grpc_credentials *creds) {
grpc_closure_init(&do_nothing_closure, do_nothing, NULL);
grpc_credentials_get_request_metadata(
- creds, &request.pollset, "", on_oauth2_response, &request, &call_list);
+ creds, &request.pollset, "", on_oauth2_response, &request, &closure_list);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&request.pollset));
while (!request.is_done) {
grpc_pollset_worker worker;
grpc_pollset_work(&request.pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- gpr_inf_future(GPR_CLOCK_MONOTONIC), &call_list);
+ gpr_inf_future(GPR_CLOCK_MONOTONIC), &closure_list);
}
gpr_mu_unlock(GRPC_POLLSET_MU(&request.pollset));
- grpc_pollset_shutdown(&request.pollset, &do_nothing_closure, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_pollset_shutdown(&request.pollset, &do_nothing_closure, &closure_list);
+ grpc_closure_list_run(&closure_list);
grpc_pollset_destroy(&request.pollset);
return request.token;
}
diff --git a/test/core/security/print_google_default_creds_token.c b/test/core/security/print_google_default_creds_token.c
index 5604d869c8dd315b2cb504cc4c8f1bf4959a7ec1..646109c0a1ff9e88088985eb596c08f16eb05564 100644
--- a/test/core/security/print_google_default_creds_token.c
+++ b/test/core/security/print_google_default_creds_token.c
@@ -51,7 +51,7 @@ typedef struct {
static void on_metadata_response(void *user_data, grpc_credentials_md *md_elems,
size_t num_md, grpc_credentials_status status,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
synchronizer *sync = user_data;
if (status == GRPC_CREDENTIALS_ERROR) {
fprintf(stderr, "Fetching token failed.\n");
@@ -70,7 +70,7 @@ static void on_metadata_response(void *user_data, grpc_credentials_md *md_elems,
int main(int argc, char **argv) {
int result = 0;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
synchronizer sync;
grpc_credentials *creds = NULL;
char *service_url = "https://test.foo.google.com/Foo";
@@ -93,15 +93,15 @@ int main(int argc, char **argv) {
grpc_credentials_get_request_metadata(creds, &sync.pollset, service_url,
on_metadata_response, &sync,
- &call_list);
+ &closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&sync.pollset));
while (!sync.is_done) {
grpc_pollset_worker worker;
grpc_pollset_work(&sync.pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- gpr_inf_future(GPR_CLOCK_MONOTONIC), &call_list);
+ gpr_inf_future(GPR_CLOCK_MONOTONIC), &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&sync.pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&sync.pollset));
}
gpr_mu_unlock(GRPC_POLLSET_MU(&sync.pollset));
diff --git a/test/core/security/secure_endpoint_test.c b/test/core/security/secure_endpoint_test.c
index 2e0f17f3ab091b65ef241f96f6a4ac12eace9af1..f68fde4c0acca8a2d401fa522165983ab18ef1ae 100644
--- a/test/core/security/secure_endpoint_test.c
+++ b/test/core/security/secure_endpoint_test.c
@@ -49,15 +49,15 @@ static grpc_pollset g_pollset;
static grpc_endpoint_test_fixture secure_endpoint_create_fixture_tcp_socketpair(
size_t slice_size, gpr_slice *leftover_slices, size_t leftover_nslices) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
tsi_frame_protector *fake_read_protector = tsi_create_fake_protector(NULL);
tsi_frame_protector *fake_write_protector = tsi_create_fake_protector(NULL);
grpc_endpoint_test_fixture f;
grpc_endpoint_pair tcp;
tcp = grpc_iomgr_create_endpoint_pair("fixture", slice_size);
- grpc_endpoint_add_to_pollset(tcp.client, &g_pollset, &call_list);
- grpc_endpoint_add_to_pollset(tcp.server, &g_pollset, &call_list);
+ grpc_endpoint_add_to_pollset(tcp.client, &g_pollset, &closure_list);
+ grpc_endpoint_add_to_pollset(tcp.server, &g_pollset, &closure_list);
if (leftover_nslices == 0) {
f.client_ep =
@@ -110,7 +110,7 @@ static grpc_endpoint_test_fixture secure_endpoint_create_fixture_tcp_socketpair(
f.server_ep =
grpc_secure_endpoint_create(fake_write_protector, tcp.server, NULL, 0);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
return f;
}
@@ -138,7 +138,8 @@ static grpc_endpoint_test_config configs[] = {
secure_endpoint_create_fixture_tcp_socketpair_leftover, clean_up},
};
-static void inc_call_ctr(void *arg, int success, grpc_call_list *call_list) {
+static void inc_call_ctr(void *arg, int success,
+ grpc_closure_list *closure_list) {
++*(int *)arg;
}
@@ -147,37 +148,38 @@ static void test_leftover(grpc_endpoint_test_config config, size_t slice_size) {
gpr_slice_buffer incoming;
gpr_slice s =
gpr_slice_from_copied_string("hello world 12345678900987654321");
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
int n = 0;
grpc_closure done_closure;
gpr_log(GPR_INFO, "Start test left over");
gpr_slice_buffer_init(&incoming);
grpc_closure_init(&done_closure, inc_call_ctr, &n);
- grpc_endpoint_read(f.client_ep, &incoming, &done_closure, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_endpoint_read(f.client_ep, &incoming, &done_closure, &closure_list);
+ grpc_closure_list_run(&closure_list);
GPR_ASSERT(n == 1);
GPR_ASSERT(incoming.count == 1);
GPR_ASSERT(0 == gpr_slice_cmp(s, incoming.slices[0]));
- grpc_endpoint_shutdown(f.client_ep, &call_list);
- grpc_endpoint_shutdown(f.server_ep, &call_list);
- grpc_endpoint_destroy(f.client_ep, &call_list);
- grpc_endpoint_destroy(f.server_ep, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_endpoint_shutdown(f.client_ep, &closure_list);
+ grpc_endpoint_shutdown(f.server_ep, &closure_list);
+ grpc_endpoint_destroy(f.client_ep, &closure_list);
+ grpc_endpoint_destroy(f.server_ep, &closure_list);
+ grpc_closure_list_run(&closure_list);
gpr_slice_unref(s);
gpr_slice_buffer_destroy(&incoming);
clean_up();
}
-static void destroy_pollset(void *p, int success, grpc_call_list *call_list) {
+static void destroy_pollset(void *p, int success,
+ grpc_closure_list *closure_list) {
grpc_pollset_destroy(p);
}
int main(int argc, char **argv) {
grpc_closure destroyed;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_test_init(argc, argv);
grpc_init();
@@ -185,8 +187,8 @@ int main(int argc, char **argv) {
grpc_endpoint_tests(configs[0], &g_pollset);
test_leftover(configs[1], 1);
grpc_closure_init(&destroyed, destroy_pollset, &g_pollset);
- grpc_pollset_shutdown(&g_pollset, &destroyed, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_pollset_shutdown(&g_pollset, &destroyed, &closure_list);
+ grpc_closure_list_run(&closure_list);
grpc_shutdown();
return 0;
diff --git a/test/core/security/verify_jwt.c b/test/core/security/verify_jwt.c
index 417152a3007a8994f7a43b66f0c350a12302e2f5..9be6ee6e336d58c121ce4d78bc68c9911398fbd8 100644
--- a/test/core/security/verify_jwt.c
+++ b/test/core/security/verify_jwt.c
@@ -89,7 +89,7 @@ int main(int argc, char **argv) {
gpr_cmdline *cl;
char *jwt = NULL;
char *aud = NULL;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
cl = gpr_cmdline_create("JWT verifier tool");
gpr_cmdline_add_string(cl, "jwt", "JSON web token to verify", &jwt);
@@ -107,15 +107,15 @@ int main(int argc, char **argv) {
sync.is_done = 0;
grpc_jwt_verifier_verify(verifier, &sync.pollset, jwt, aud,
- on_jwt_verification_done, &sync, &call_list);
+ on_jwt_verification_done, &sync, &closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&sync.pollset));
while (!sync.is_done) {
grpc_pollset_worker worker;
grpc_pollset_work(&sync.pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- gpr_inf_future(GPR_CLOCK_MONOTONIC), &call_list);
+ gpr_inf_future(GPR_CLOCK_MONOTONIC), &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&sync.pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&sync.pollset));
}
gpr_mu_unlock(GRPC_POLLSET_MU(&sync.pollset));
diff --git a/test/core/surface/completion_queue_test.c b/test/core/surface/completion_queue_test.c
index 85a021da89d1d7e2c9605a4c92aefcee6be1e132..3dee8f23afc97832dda71eb8ce3b68e3ce08e177 100644
--- a/test/core/surface/completion_queue_test.c
+++ b/test/core/surface/completion_queue_test.c
@@ -76,13 +76,13 @@ static void test_wait_empty(void) {
}
static void do_nothing_end_completion(void *arg, grpc_cq_completion *c,
- grpc_call_list *call_list) {}
+ grpc_closure_list *closure_list) {}
static void test_cq_end_op(void) {
grpc_event ev;
grpc_completion_queue *cc;
grpc_cq_completion completion;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
void *tag = create_test_tag();
LOG_TEST("test_cq_end_op");
@@ -91,7 +91,7 @@ static void test_cq_end_op(void) {
grpc_cq_begin_op(cc);
grpc_cq_end_op(cc, tag, 1, do_nothing_end_completion, NULL, &completion,
- &call_list);
+ &closure_list);
ev = grpc_completion_queue_next(cc, gpr_inf_past(GPR_CLOCK_REALTIME), NULL);
GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
@@ -99,7 +99,7 @@ static void test_cq_end_op(void) {
GPR_ASSERT(ev.success);
shutdown_and_destroy(cc);
- GPR_ASSERT(grpc_call_list_empty(call_list));
+ GPR_ASSERT(grpc_closure_list_empty(closure_list));
}
static void test_shutdown_then_next_polling(void) {
@@ -133,7 +133,7 @@ static void test_pluck(void) {
grpc_completion_queue *cc;
void *tags[128];
grpc_cq_completion completions[GPR_ARRAY_SIZE(tags)];
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
unsigned i, j;
LOG_TEST("test_pluck");
@@ -150,7 +150,7 @@ static void test_pluck(void) {
for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
grpc_cq_begin_op(cc);
grpc_cq_end_op(cc, tags[i], 1, do_nothing_end_completion, NULL,
- &completions[i], &call_list);
+ &completions[i], &closure_list);
}
for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
@@ -162,7 +162,7 @@ static void test_pluck(void) {
for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
grpc_cq_begin_op(cc);
grpc_cq_end_op(cc, tags[i], 1, do_nothing_end_completion, NULL,
- &completions[i], &call_list);
+ &completions[i], &closure_list);
}
for (i = 0; i < GPR_ARRAY_SIZE(tags); i++) {
@@ -172,7 +172,7 @@ static void test_pluck(void) {
}
shutdown_and_destroy(cc);
- GPR_ASSERT(grpc_call_list_empty(call_list));
+ GPR_ASSERT(grpc_closure_list_empty(closure_list));
}
#define TEST_THREAD_EVENTS 10000
@@ -193,14 +193,14 @@ gpr_timespec ten_seconds_time(void) {
}
static void free_completion(void *arg, grpc_cq_completion *completion,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
gpr_free(completion);
}
static void producer_thread(void *arg) {
test_thread_options *opt = arg;
int i;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
gpr_log(GPR_INFO, "producer %d started", opt->id);
gpr_event_set(&opt->on_started, (void *)(gpr_intptr)1);
@@ -218,14 +218,14 @@ static void producer_thread(void *arg) {
gpr_log(GPR_INFO, "producer %d phase 2", opt->id);
for (i = 0; i < TEST_THREAD_EVENTS; i++) {
grpc_cq_end_op(opt->cc, (void *)(gpr_intptr)1, 1, free_completion, NULL,
- gpr_malloc(sizeof(grpc_cq_completion)), &call_list);
+ gpr_malloc(sizeof(grpc_cq_completion)), &closure_list);
opt->events_triggered++;
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
gpr_log(GPR_INFO, "producer %d phase 2 done", opt->id);
gpr_event_set(&opt->on_finished, (void *)(gpr_intptr)1);
- GPR_ASSERT(grpc_call_list_empty(call_list));
+ GPR_ASSERT(grpc_closure_list_empty(closure_list));
}
static void consumer_thread(void *arg) {
diff --git a/test/core/util/port_posix.c b/test/core/util/port_posix.c
index 98b5686e9111fbc780fe56d8204f8d87ccc73bde..1987700139e6bb62e8b2c0f1cbdb03bbfc51c3d9 100644
--- a/test/core/util/port_posix.c
+++ b/test/core/util/port_posix.c
@@ -73,14 +73,14 @@ typedef struct freereq {
} freereq;
static void destroy_pollset_and_shutdown(void *p, int success,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
grpc_pollset_destroy(p);
grpc_shutdown();
}
static void freed_port_from_server(void *arg,
const grpc_httpcli_response *response,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
freereq *pr = arg;
gpr_mu_lock(GRPC_POLLSET_MU(&pr->pollset));
pr->done = 1;
@@ -93,7 +93,7 @@ static void free_port_using_server(char *server, int port) {
grpc_httpcli_request req;
freereq pr;
char *path;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_closure shutdown_closure;
grpc_init();
@@ -111,19 +111,19 @@ static void free_port_using_server(char *server, int port) {
grpc_httpcli_context_init(&context);
grpc_httpcli_get(&context, &pr.pollset, &req,
GRPC_TIMEOUT_SECONDS_TO_DEADLINE(10), freed_port_from_server,
- &pr, &call_list);
+ &pr, &closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&pr.pollset));
while (!pr.done) {
grpc_pollset_worker worker;
grpc_pollset_work(&pr.pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- GRPC_TIMEOUT_SECONDS_TO_DEADLINE(1), &call_list);
+ GRPC_TIMEOUT_SECONDS_TO_DEADLINE(1), &closure_list);
}
gpr_mu_unlock(GRPC_POLLSET_MU(&pr.pollset));
grpc_httpcli_context_destroy(&context);
- grpc_call_list_run(&call_list);
- grpc_pollset_shutdown(&pr.pollset, &shutdown_closure, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
+ grpc_pollset_shutdown(&pr.pollset, &shutdown_closure, &closure_list);
+ grpc_closure_list_run(&closure_list);
gpr_free(path);
}
@@ -210,7 +210,7 @@ typedef struct portreq {
static void got_port_from_server(void *arg,
const grpc_httpcli_response *response,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
size_t i;
int port = 0;
portreq *pr = arg;
@@ -226,7 +226,7 @@ static void got_port_from_server(void *arg,
sleep(1);
grpc_httpcli_get(pr->ctx, &pr->pollset, &req,
GRPC_TIMEOUT_SECONDS_TO_DEADLINE(10), got_port_from_server,
- pr, call_list);
+ pr, closure_list);
return;
}
GPR_ASSERT(response);
@@ -246,7 +246,7 @@ static int pick_port_using_server(char *server) {
grpc_httpcli_context context;
grpc_httpcli_request req;
portreq pr;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_closure shutdown_closure;
grpc_init();
@@ -266,19 +266,19 @@ static int pick_port_using_server(char *server) {
grpc_httpcli_context_init(&context);
grpc_httpcli_get(&context, &pr.pollset, &req,
GRPC_TIMEOUT_SECONDS_TO_DEADLINE(10), got_port_from_server,
- &pr, &call_list);
- grpc_call_list_run(&call_list);
+ &pr, &closure_list);
+ grpc_closure_list_run(&closure_list);
gpr_mu_lock(GRPC_POLLSET_MU(&pr.pollset));
while (pr.port == -1) {
grpc_pollset_worker worker;
grpc_pollset_work(&pr.pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- GRPC_TIMEOUT_SECONDS_TO_DEADLINE(1), &call_list);
+ GRPC_TIMEOUT_SECONDS_TO_DEADLINE(1), &closure_list);
}
gpr_mu_unlock(GRPC_POLLSET_MU(&pr.pollset));
grpc_httpcli_context_destroy(&context);
- grpc_pollset_shutdown(&pr.pollset, &shutdown_closure, &call_list);
- grpc_call_list_run(&call_list);
+ grpc_pollset_shutdown(&pr.pollset, &shutdown_closure, &closure_list);
+ grpc_closure_list_run(&closure_list);
return pr.port;
}
diff --git a/test/core/util/reconnect_server.c b/test/core/util/reconnect_server.c
index eeb3ecb55a892bcb87288ea90c6a2fcdaccc4351..8092cbc73a0d1470d5d4606d5504a8b4a6c1e7f7 100644
--- a/test/core/util/reconnect_server.c
+++ b/test/core/util/reconnect_server.c
@@ -66,15 +66,15 @@ static void pretty_print_backoffs(reconnect_server *server) {
}
static void on_connect(void *arg, grpc_endpoint *tcp,
- grpc_call_list *call_list) {
+ grpc_closure_list *closure_list) {
char *peer;
char *last_colon;
reconnect_server *server = (reconnect_server *)arg;
gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME);
timestamp_list *new_tail;
peer = grpc_endpoint_get_peer(tcp);
- grpc_endpoint_shutdown(tcp, call_list);
- grpc_endpoint_destroy(tcp, call_list);
+ grpc_endpoint_shutdown(tcp, closure_list);
+ grpc_endpoint_destroy(tcp, closure_list);
if (peer) {
last_colon = strrchr(peer, ':');
if (server->peer == NULL) {
@@ -115,7 +115,7 @@ void reconnect_server_init(reconnect_server *server) {
void reconnect_server_start(reconnect_server *server, int port) {
struct sockaddr_in addr;
int port_added;
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
addr.sin_family = AF_INET;
addr.sin_port = htons((gpr_uint16)port);
@@ -127,10 +127,10 @@ void reconnect_server_start(reconnect_server *server, int port) {
GPR_ASSERT(port_added == port);
grpc_tcp_server_start(server->tcp_server, server->pollsets, 1, on_connect,
- server, &call_list);
+ server, &closure_list);
gpr_log(GPR_INFO, "reconnect tcp server listening on 0.0.0.0:%d", port);
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
void reconnect_server_poll(reconnect_server *server, int seconds) {
@@ -138,12 +138,12 @@ void reconnect_server_poll(reconnect_server *server, int seconds) {
gpr_timespec deadline =
gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
gpr_time_from_seconds(seconds, GPR_TIMESPAN));
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
gpr_mu_lock(GRPC_POLLSET_MU(&server->pollset));
grpc_pollset_work(&server->pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
- deadline, &call_list);
+ deadline, &closure_list);
gpr_mu_unlock(GRPC_POLLSET_MU(&server->pollset));
- grpc_call_list_run(&call_list);
+ grpc_closure_list_run(&closure_list);
}
void reconnect_server_clear_timestamps(reconnect_server *server) {
@@ -158,18 +158,20 @@ void reconnect_server_clear_timestamps(reconnect_server *server) {
server->peer = NULL;
}
-static void do_nothing(void *ignored, int success, grpc_call_list *call_list) {}
+static void do_nothing(void *ignored, int success,
+ grpc_closure_list *closure_list) {}
void reconnect_server_destroy(reconnect_server *server) {
- grpc_call_list call_list = GRPC_CALL_LIST_INIT;
+ grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT;
grpc_closure do_nothing_closure[2];
grpc_closure_init(&do_nothing_closure[0], do_nothing, NULL);
grpc_closure_init(&do_nothing_closure[1], do_nothing, NULL);
grpc_tcp_server_destroy(server->tcp_server, &do_nothing_closure[0],
- &call_list);
+ &closure_list);
reconnect_server_clear_timestamps(server);
- grpc_pollset_shutdown(&server->pollset, &do_nothing_closure[1], &call_list);
- grpc_call_list_run(&call_list);
+ grpc_pollset_shutdown(&server->pollset, &do_nothing_closure[1],
+ &closure_list);
+ grpc_closure_list_run(&closure_list);
grpc_pollset_destroy(&server->pollset);
grpc_shutdown();
}