自学教程：C++ GRPC_ERROR_REF函数代码示例

static void cc_start_transport_op(grpc_exec_ctx *exec_ctx,                                  grpc_channel_element *elem,                                  grpc_transport_op *op) {  channel_data *chand = elem->channel_data;  grpc_exec_ctx_sched(exec_ctx, op->on_consumed, GRPC_ERROR_NONE, NULL);  GPR_ASSERT(op->set_accept_stream == false);  if (op->bind_pollset != NULL) {    grpc_pollset_set_add_pollset(exec_ctx, chand->interested_parties,                                 op->bind_pollset);  }  gpr_mu_lock(&chand->mu);  if (op->on_connectivity_state_change != NULL) {    grpc_connectivity_state_notify_on_state_change(        exec_ctx, &chand->state_tracker, op->connectivity_state,        op->on_connectivity_state_change);    op->on_connectivity_state_change = NULL;    op->connectivity_state = NULL;  }  if (op->send_ping != NULL) {    if (chand->lb_policy == NULL) {      grpc_exec_ctx_sched(exec_ctx, op->send_ping,                          GRPC_ERROR_CREATE("Ping with no load balancing"),                          NULL);    } else {      grpc_lb_policy_ping_one(exec_ctx, chand->lb_policy, op->send_ping);      op->bind_pollset = NULL;    }    op->send_ping = NULL;  }  if (op->disconnect_with_error != GRPC_ERROR_NONE) {    if (chand->resolver != NULL) {      set_channel_connectivity_state_locked(          exec_ctx, chand, GRPC_CHANNEL_SHUTDOWN,          GRPC_ERROR_REF(op->disconnect_with_error), "disconnect");      grpc_resolver_shutdown(exec_ctx, chand->resolver);      GRPC_RESOLVER_UNREF(exec_ctx, chand->resolver, "channel");      chand->resolver = NULL;      if (!chand->started_resolving) {        grpc_closure_list_fail_all(&chand->waiting_for_config_closures,                                   GRPC_ERROR_REF(op->disconnect_with_error));        grpc_exec_ctx_enqueue_list(exec_ctx,                                   &chand->waiting_for_config_closures, NULL);      }      if (chand->lb_policy != NULL) {        grpc_pollset_set_del_pollset_set(exec_ctx,                                         chand->lb_policy->interested_parties,                                         chand->interested_parties);        GRPC_LB_POLICY_UNREF(exec_ctx, chand->lb_policy, "channel");        chand->lb_policy = NULL;      }    }    GRPC_ERROR_UNREF(op->disconnect_with_error);  }  gpr_mu_unlock(&chand->mu);}

static void connected(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {  chttp2_connector *c = arg;  gpr_mu_lock(&c->mu);  GPR_ASSERT(c->connecting);  c->connecting = false;  if (error != GRPC_ERROR_NONE || c->shutdown) {    if (error == GRPC_ERROR_NONE) {      error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("connector shutdown");    } else {      error = GRPC_ERROR_REF(error);    }    memset(c->result, 0, sizeof(*c->result));    grpc_closure *notify = c->notify;    c->notify = NULL;    grpc_closure_sched(exec_ctx, notify, error);    if (c->endpoint != NULL) {      grpc_endpoint_shutdown(exec_ctx, c->endpoint, GRPC_ERROR_REF(error));    }    gpr_mu_unlock(&c->mu);    chttp2_connector_unref(exec_ctx, arg);  } else {    GPR_ASSERT(c->endpoint != NULL);    start_handshake_locked(exec_ctx, c);    gpr_mu_unlock(&c->mu);  }}

/* Might be called multiple times */static void fd_shutdown(grpc_exec_ctx *exec_ctx, grpc_fd *fd, grpc_error *why) {  if (grpc_lfev_set_shutdown(exec_ctx, &fd->read_closure,                             GRPC_ERROR_REF(why))) {    shutdown(fd->fd, SHUT_RDWR);    grpc_lfev_set_shutdown(exec_ctx, &fd->write_closure, GRPC_ERROR_REF(why));  }  GRPC_ERROR_UNREF(why);}

static void partly_done(grpc_exec_ctx *exec_ctx, state_watcher *w,                        bool due_to_completion, grpc_error *error) {  if (due_to_completion) {    grpc_timer_cancel(exec_ctx, &w->alarm);  } else {    grpc_channel_element *client_channel_elem = grpc_channel_stack_last_element(        grpc_channel_get_channel_stack(w->channel));    grpc_client_channel_watch_connectivity_state(        exec_ctx, client_channel_elem,        grpc_polling_entity_create_from_pollset(grpc_cq_pollset(w->cq)), NULL,        &w->on_complete, NULL);  }  gpr_mu_lock(&w->mu);  if (due_to_completion) {    if (GRPC_TRACER_ON(grpc_trace_operation_failures)) {      GRPC_LOG_IF_ERROR("watch_completion_error", GRPC_ERROR_REF(error));    }    GRPC_ERROR_UNREF(error);    error = GRPC_ERROR_NONE;  } else {    if (error == GRPC_ERROR_NONE) {      error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(          "Timed out waiting for connection state change");    } else if (error == GRPC_ERROR_CANCELLED) {      error = GRPC_ERROR_NONE;    }  }  switch (w->phase) {    case WAITING:      GRPC_ERROR_REF(error);      w->error = error;      w->phase = READY_TO_CALL_BACK;      break;    case READY_TO_CALL_BACK:      if (error != GRPC_ERROR_NONE) {        GPR_ASSERT(!due_to_completion);        GRPC_ERROR_UNREF(w->error);        GRPC_ERROR_REF(error);        w->error = error;      }      w->phase = CALLING_BACK_AND_FINISHED;      grpc_cq_end_op(exec_ctx, w->cq, w->tag, w->error, finished_completion, w,                     &w->completion_storage);      break;    case CALLING_BACK_AND_FINISHED:      GPR_UNREACHABLE_CODE(return );      break;  }  gpr_mu_unlock(&w->mu);  GRPC_ERROR_UNREF(error);}

/* sd is the subchannel_data associted with the updated subchannel. * shutdown_error will only be used upon policy transition to TRANSIENT_FAILURE * or SHUTDOWN */static grpc_connectivity_state update_lb_connectivity_status(    grpc_exec_ctx *exec_ctx, subchannel_data *sd, grpc_error *error) {  /* In priority order. The first rule to match terminates the search (ie, if we   * are on rule n, all previous rules were unfulfilled).   *   * 1) RULE: ANY subchannel is READY => policy is READY.   *    CHECK: At least one subchannel is ready iff p->ready_list is NOT empty.   *   * 2) RULE: ANY subchannel is CONNECTING => policy is CONNECTING.   *    CHECK: sd->curr_connectivity_state == CONNECTING.   *   * 3) RULE: ALL subchannels are SHUTDOWN => policy is SHUTDOWN.   *    CHECK: p->num_subchannels = 0.   *   * 4) RULE: ALL subchannels are TRANSIENT_FAILURE => policy is   *    TRANSIENT_FAILURE.   *    CHECK: p->num_transient_failures == p->num_subchannels.   *   * 5) RULE: ALL subchannels are IDLE => policy is IDLE.   *    CHECK: p->num_idle == p->num_subchannels.   */  round_robin_lb_policy *p = sd->policy;  if (!is_ready_list_empty(p)) { /* 1) READY */    grpc_connectivity_state_set(exec_ctx, &p->state_tracker, GRPC_CHANNEL_READY,                                GRPC_ERROR_NONE, "rr_ready");    return GRPC_CHANNEL_READY;  } else if (sd->curr_connectivity_state ==             GRPC_CHANNEL_CONNECTING) { /* 2) CONNECTING */    grpc_connectivity_state_set(exec_ctx, &p->state_tracker,                                GRPC_CHANNEL_CONNECTING, GRPC_ERROR_NONE,                                "rr_connecting");    return GRPC_CHANNEL_CONNECTING;  } else if (p->num_subchannels == 0) { /* 3) SHUTDOWN */    grpc_connectivity_state_set(exec_ctx, &p->state_tracker,                                GRPC_CHANNEL_SHUTDOWN, GRPC_ERROR_REF(error),                                "rr_shutdown");    return GRPC_CHANNEL_SHUTDOWN;  } else if (p->num_transient_failures ==             p->num_subchannels) { /* 4) TRANSIENT_FAILURE */    grpc_connectivity_state_set(exec_ctx, &p->state_tracker,                                GRPC_CHANNEL_TRANSIENT_FAILURE,                                GRPC_ERROR_REF(error), "rr_transient_failure");    return GRPC_CHANNEL_TRANSIENT_FAILURE;  } else if (p->num_idle == p->num_subchannels) { /* 5) IDLE */    grpc_connectivity_state_set(exec_ctx, &p->state_tracker, GRPC_CHANNEL_IDLE,                                GRPC_ERROR_NONE, "rr_idle");    return GRPC_CHANNEL_IDLE;  }  /* no change */  return sd->curr_connectivity_state;}

static void connected(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {    connector *c = arg;    grpc_endpoint *tcp = c->newly_connecting_endpoint;    if (tcp != NULL) {        gpr_mu_lock(&c->mu);        GPR_ASSERT(c->connecting_endpoint == NULL);        c->connecting_endpoint = tcp;        gpr_mu_unlock(&c->mu);        if (!GRPC_SLICE_IS_EMPTY(c->args.initial_connect_string)) {            grpc_closure_init(&c->initial_string_sent, on_initial_connect_string_sent,                              c);            grpc_slice_buffer_init(&c->initial_string_buffer);            grpc_slice_buffer_add(&c->initial_string_buffer,                                  c->args.initial_connect_string);            grpc_endpoint_write(exec_ctx, tcp, &c->initial_string_buffer,                                &c->initial_string_sent);        } else {            grpc_handshake_manager_do_handshake(                exec_ctx, c->handshake_mgr, tcp, c->args.channel_args,                c->args.deadline, NULL /* acceptor */, on_handshake_done, c);        }    } else {        memset(c->result, 0, sizeof(*c->result));        grpc_closure *notify = c->notify;        c->notify = NULL;        grpc_exec_ctx_sched(exec_ctx, notify, GRPC_ERROR_REF(error), NULL);    }}

/* Asynchronous callback from the IOCP, or the background thread. */static void on_read(grpc_exec_ctx *exec_ctx, void *tcpp, grpc_error *error) {  grpc_tcp *tcp = tcpp;  grpc_closure *cb = tcp->read_cb;  grpc_winsocket *socket = tcp->socket;  gpr_slice sub;  grpc_winsocket_callback_info *info = &socket->read_info;  GRPC_ERROR_REF(error);  if (error == GRPC_ERROR_NONE) {    if (info->wsa_error != 0 && !tcp->shutting_down) {      char *utf8_message = gpr_format_message(info->wsa_error);      error = GRPC_ERROR_CREATE(utf8_message);      gpr_free(utf8_message);      gpr_slice_unref(tcp->read_slice);    } else {      if (info->bytes_transfered != 0 && !tcp->shutting_down) {        sub = gpr_slice_sub_no_ref(tcp->read_slice, 0, info->bytes_transfered);        gpr_slice_buffer_add(tcp->read_slices, sub);      } else {        gpr_slice_unref(tcp->read_slice);        error = GRPC_ERROR_CREATE("End of TCP stream");      }    }  }  tcp->read_cb = NULL;  TCP_UNREF(tcp, "read");  grpc_exec_ctx_sched(exec_ctx, cb, error, NULL);}

/* The /a on_complete closure passed as part of the pick requires keeping a * reference to its associated round robin instance. We wrap this closure in * order to unref the round robin instance upon its invocation */static void wrapped_rr_closure(grpc_exec_ctx *exec_ctx, void *arg,                               grpc_error *error) {  wrapped_rr_closure_arg *wc_arg = arg;  if (wc_arg->rr_policy != NULL) {    if (grpc_lb_glb_trace) {      gpr_log(GPR_INFO, "Unreffing RR (0x%" PRIxPTR ")",              (intptr_t)wc_arg->rr_policy);    }    GRPC_LB_POLICY_UNREF(exec_ctx, wc_arg->rr_policy, "wrapped_rr_closure");    /* if target is NULL, no pick has been made by the RR policy (eg, all     * addresses failed to connect). There won't be any user_data/token     * available */    if (wc_arg->target != NULL) {      initial_metadata_add_lb_token(wc_arg->initial_metadata,                                    wc_arg->lb_token_mdelem_storage,                                    GRPC_MDELEM_REF(wc_arg->lb_token));    }  }  GPR_ASSERT(wc_arg->wrapped_closure != NULL);  grpc_exec_ctx_sched(exec_ctx, wc_arg->wrapped_closure, GRPC_ERROR_REF(error),                      NULL);  GPR_ASSERT(wc_arg->free_when_done != NULL);  gpr_free(wc_arg->free_when_done);}

static void cancel_get_request_metadata(grpc_exec_ctx *exec_ctx, void *arg,                                        grpc_error *error) {  grpc_call_element *elem = (grpc_call_element *)arg;  call_data *calld = (call_data *)elem->call_data;  grpc_call_credentials_cancel_get_request_metadata(      exec_ctx, calld->creds, &calld->md_array, GRPC_ERROR_REF(error));}

static void on_credentials_metadata(grpc_exec_ctx *exec_ctx, void *arg,                                    grpc_error *input_error) {  grpc_transport_stream_op_batch *batch = (grpc_transport_stream_op_batch *)arg;  grpc_call_element *elem = batch->handler_private.extra_arg;  call_data *calld = elem->call_data;  reset_auth_metadata_context(&calld->auth_md_context);  grpc_error *error = GRPC_ERROR_REF(input_error);  if (error == GRPC_ERROR_NONE) {    GPR_ASSERT(calld->md_array.size <= MAX_CREDENTIALS_METADATA_COUNT);    GPR_ASSERT(batch->send_initial_metadata);    grpc_metadata_batch *mdb =        batch->payload->send_initial_metadata.send_initial_metadata;    for (size_t i = 0; i < calld->md_array.size; ++i) {      add_error(&error, grpc_metadata_batch_add_tail(                            exec_ctx, mdb, &calld->md_links[i],                            GRPC_MDELEM_REF(calld->md_array.md[i])));    }  }  if (error == GRPC_ERROR_NONE) {    grpc_call_next_op(exec_ctx, elem, batch);  } else {    error = grpc_error_set_int(error, GRPC_ERROR_INT_GRPC_STATUS,                               GRPC_STATUS_UNAUTHENTICATED);    grpc_transport_stream_op_batch_finish_with_failure(exec_ctx, batch, error);  }}

// Callback invoked when we receive a message.  Here we check the max// receive message size.static void recv_message_ready(grpc_exec_ctx* exec_ctx, void* user_data,                               grpc_error* error) {  grpc_call_element* elem = (grpc_call_element*)user_data;  call_data* calld = (call_data*)elem->call_data;  if (*calld->recv_message != NULL && calld->limits.max_recv_size >= 0 &&      (*calld->recv_message)->length > (size_t)calld->limits.max_recv_size) {    char* message_string;    gpr_asprintf(&message_string,                 "Received message larger than max (%u vs. %d)",                 (*calld->recv_message)->length, calld->limits.max_recv_size);    grpc_error* new_error = grpc_error_set_int(        GRPC_ERROR_CREATE_FROM_COPIED_STRING(message_string),        GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED);    if (error == GRPC_ERROR_NONE) {      error = new_error;    } else {      error = grpc_error_add_child(error, new_error);      GRPC_ERROR_UNREF(new_error);    }    gpr_free(message_string);  } else {    GRPC_ERROR_REF(error);  }  // Invoke the next callback.  GRPC_CLOSURE_RUN(exec_ctx, calld->next_recv_message_ready, error);}

static void on_initial_md_ready(grpc_exec_ctx *exec_ctx, void *user_data,                                grpc_error *err) {  grpc_call_element *elem = (grpc_call_element *)user_data;  call_data *calld = (call_data *)elem->call_data;  if (err == GRPC_ERROR_NONE) {    if (calld->recv_initial_metadata->idx.named.path != NULL) {      calld->service_method = grpc_slice_ref_internal(          GRPC_MDVALUE(calld->recv_initial_metadata->idx.named.path->md));      calld->have_service_method = true;    } else {      err = grpc_error_add_child(          err, GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing :path header"));    }    if (calld->recv_initial_metadata->idx.named.lb_token != NULL) {      calld->initial_md_string = grpc_slice_ref_internal(          GRPC_MDVALUE(calld->recv_initial_metadata->idx.named.lb_token->md));      calld->have_initial_md_string = true;      grpc_metadata_batch_remove(          exec_ctx, calld->recv_initial_metadata,          calld->recv_initial_metadata->idx.named.lb_token);    }  } else {    GRPC_ERROR_REF(err);  }  calld->ops_recv_initial_metadata_ready->cb(      exec_ctx, calld->ops_recv_initial_metadata_ready->cb_arg, err);  GRPC_ERROR_UNREF(err);}

/* Asynchronous callback from the IOCP, or the background thread. */static void on_read(grpc_exec_ctx *exec_ctx, void *tcpp, grpc_error *error) {  grpc_tcp *tcp = tcpp;  grpc_closure *cb = tcp->read_cb;  grpc_winsocket *socket = tcp->socket;  grpc_slice sub;  grpc_winsocket_callback_info *info = &socket->read_info;  GRPC_ERROR_REF(error);  if (error == GRPC_ERROR_NONE) {    if (info->wsa_error != 0 && !tcp->shutting_down) {      char *utf8_message = gpr_format_message(info->wsa_error);      error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(utf8_message);      gpr_free(utf8_message);      grpc_slice_unref_internal(exec_ctx, tcp->read_slice);    } else {      if (info->bytes_transfered != 0 && !tcp->shutting_down) {        sub = grpc_slice_sub_no_ref(tcp->read_slice, 0, info->bytes_transfered);        grpc_slice_buffer_add(tcp->read_slices, sub);      } else {        grpc_slice_unref_internal(exec_ctx, tcp->read_slice);        error = tcp->shutting_down                    ? GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(                          "TCP stream shutting down", &tcp->shutdown_error, 1)                    : GRPC_ERROR_CREATE_FROM_STATIC_STRING("End of TCP stream");      }    }  }  tcp->read_cb = NULL;  TCP_UNREF(exec_ctx, tcp, "read");  GRPC_CLOSURE_SCHED(exec_ctx, cb, error);}

static void destroy_made_transport_stream_op(grpc_exec_ctx *exec_ctx, void *arg,                                             grpc_error *error) {  made_transport_stream_op *op = arg;  grpc_closure *c = op->inner_on_complete;  gpr_free(op);  GRPC_CLOSURE_RUN(exec_ctx, c, GRPC_ERROR_REF(error));}

// If the handshake failed or we're shutting down, clean up and invoke the// callback with the error.static void handshake_failed_locked(grpc_exec_ctx* exec_ctx,                                    http_connect_handshaker* handshaker,                                    grpc_error* error) {  if (error == GRPC_ERROR_NONE) {    // If we were shut down after an endpoint operation succeeded but    // before the endpoint callback was invoked, we need to generate our    // own error.    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Handshaker shutdown");  }  if (!handshaker->shutdown) {    // TODO(ctiller): It is currently necessary to shutdown endpoints    // before destroying them, even if we know that there are no    // pending read/write callbacks.  This should be fixed, at which    // point this can be removed.    grpc_endpoint_shutdown(exec_ctx, handshaker->args->endpoint,                           GRPC_ERROR_REF(error));    // Not shutting down, so the handshake failed.  Clean up before    // invoking the callback.    cleanup_args_for_failure_locked(exec_ctx, handshaker);    // Set shutdown to true so that subsequent calls to    // http_connect_handshaker_shutdown() do nothing.    handshaker->shutdown = true;  }  // Invoke callback.  grpc_closure_sched(exec_ctx, handshaker->on_handshake_done, error);}

// If the handshake failed or we're shutting down, clean up and invoke the// callback with the error.static void security_handshake_failed_locked(grpc_exec_ctx *exec_ctx,                                             security_handshaker *h,                                             grpc_error *error) {  if (error == GRPC_ERROR_NONE) {    // If we were shut down after the handshake succeeded but before an    // endpoint callback was invoked, we need to generate our own error.    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Handshaker shutdown");  }  const char *msg = grpc_error_string(error);  gpr_log(GPR_DEBUG, "Security handshake failed: %s", msg);  if (!h->shutdown) {    // TODO(ctiller): It is currently necessary to shutdown endpoints    // before destroying them, even if we know that there are no    // pending read/write callbacks.  This should be fixed, at which    // point this can be removed.    grpc_endpoint_shutdown(exec_ctx, h->args->endpoint, GRPC_ERROR_REF(error));    // Not shutting down, so the write failed.  Clean up before    // invoking the callback.    cleanup_args_for_failure_locked(exec_ctx, h);    // Set shutdown to true so that subsequent calls to    // security_handshaker_shutdown() do nothing.    h->shutdown = true;  }  // Invoke callback.  GRPC_CLOSURE_SCHED(exec_ctx, h->on_handshake_done, error);}

static void connected(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {  chttp2_connector *c = arg;  gpr_mu_lock(&c->mu);  GPR_ASSERT(c->connecting);  c->connecting = false;  if (error != GRPC_ERROR_NONE || c->shutdown) {    if (error == GRPC_ERROR_NONE) {      error = GRPC_ERROR_CREATE("connector shutdown");    } else {      error = GRPC_ERROR_REF(error);    }    memset(c->result, 0, sizeof(*c->result));    grpc_closure *notify = c->notify;    c->notify = NULL;    grpc_exec_ctx_sched(exec_ctx, notify, error, NULL);    if (c->endpoint != NULL) grpc_endpoint_shutdown(exec_ctx, c->endpoint);    gpr_mu_unlock(&c->mu);    chttp2_connector_unref(exec_ctx, arg);  } else {    GPR_ASSERT(c->endpoint != NULL);    if (!GRPC_SLICE_IS_EMPTY(c->args.initial_connect_string)) {      grpc_closure_init(&c->initial_string_sent, on_initial_connect_string_sent,                        c);      grpc_slice_buffer_init(&c->initial_string_buffer);      grpc_slice_buffer_add(&c->initial_string_buffer,                            c->args.initial_connect_string);      grpc_endpoint_write(exec_ctx, c->endpoint, &c->initial_string_buffer,                          &c->initial_string_sent);    } else {      start_handshake_locked(exec_ctx, c);    }    gpr_mu_unlock(&c->mu);  }}

static void shutdown_fd(grpc_exec_ctx *exec_ctx, void *args,                        grpc_error *error) {  struct shutdown_fd_args *shutdown_args = (struct shutdown_fd_args *)args;  gpr_mu_lock(shutdown_args->server_mu);  grpc_fd_shutdown(exec_ctx, shutdown_args->fd, GRPC_ERROR_REF(error));  gpr_mu_unlock(shutdown_args->server_mu);  gpr_free(shutdown_args);}

static void chttp2_connector_shutdown(grpc_exec_ctx *exec_ctx,                                      grpc_connector *con, grpc_error *why) {  chttp2_connector *c = (chttp2_connector *)con;  gpr_mu_lock(&c->mu);  c->shutdown = true;  if (c->handshake_mgr != NULL) {    grpc_handshake_manager_shutdown(exec_ctx, c->handshake_mgr,                                    GRPC_ERROR_REF(why));  }  // If handshaking is not yet in progress, shutdown the endpoint.  // Otherwise, the handshaker will do this for us.  if (!c->connecting && c->endpoint != NULL) {    grpc_endpoint_shutdown(exec_ctx, c->endpoint, GRPC_ERROR_REF(why));  }  gpr_mu_unlock(&c->mu);  GRPC_ERROR_UNREF(why);}

static void kill_pending_work_locked(grpc_exec_ctx *exec_ctx,                                     grpc_server *server, grpc_error *error) {  if (server->started) {    request_matcher_kill_requests(exec_ctx, server,                                  &server->unregistered_request_matcher,                                  GRPC_ERROR_REF(error));    request_matcher_zombify_all_pending_calls(        exec_ctx, &server->unregistered_request_matcher);    for (registered_method *rm = server->registered_methods; rm;         rm = rm->next) {      request_matcher_kill_requests(exec_ctx, server, &rm->request_matcher,                                    GRPC_ERROR_REF(error));      request_matcher_zombify_all_pending_calls(exec_ctx, &rm->request_matcher);    }  }  GRPC_ERROR_UNREF(error);}

void grpc_closure_list_fail_all(grpc_closure_list *list,                                grpc_error *forced_failure) {  for (grpc_closure *c = list->head; c != NULL; c = c->next_data.next) {    if (c->error_data.error == GRPC_ERROR_NONE) {      c->error_data.error = GRPC_ERROR_REF(forced_failure);    }  }  GRPC_ERROR_UNREF(forced_failure);}

static void cancel_check_call_host(grpc_exec_ctx *exec_ctx, void *arg,                                   grpc_error *error) {  grpc_call_element *elem = (grpc_call_element *)arg;  call_data *calld = (call_data *)elem->call_data;  channel_data *chand = (channel_data *)elem->channel_data;  grpc_channel_security_connector_cancel_check_call_host(      exec_ctx, chand->security_connector, &calld->closure,      GRPC_ERROR_REF(error));}

static void destroy_done(grpc_exec_ctx *exec_ctx, void *statep,                         grpc_error *error) {  server_secure_state *state = statep;  if (state->destroy_callback != NULL) {    state->destroy_callback->cb(exec_ctx, state->destroy_callback->cb_arg,                                GRPC_ERROR_REF(error));  }  grpc_server_security_connector_shutdown(exec_ctx, state->sc);  state_unref(state);}

static void fail_locked(grpc_exec_ctx *exec_ctx, call_data *calld,                        grpc_error *error) {  size_t i;  for (i = 0; i < calld->waiting_ops_count; i++) {    grpc_transport_stream_op_finish_with_failure(        exec_ctx, calld->waiting_ops[i], GRPC_ERROR_REF(error));  }  calld->waiting_ops_count = 0;  GRPC_ERROR_UNREF(error);}

static grpc_error *inproc_slice_byte_stream_pull(grpc_exec_ctx *exec_ctx,                                                 grpc_byte_stream *bs,                                                 grpc_slice *slice) {  inproc_slice_byte_stream *stream = (inproc_slice_byte_stream *)bs;  if (stream->shutdown_error != GRPC_ERROR_NONE) {    return GRPC_ERROR_REF(stream->shutdown_error);  }  *slice = grpc_slice_buffer_take_first(&stream->le->sb);  return GRPC_ERROR_NONE;}

static void fail_locked(grpc_exec_ctx *exec_ctx,                        grpc_subchannel_call_holder *holder,                        grpc_error *error) {  size_t i;  for (i = 0; i < holder->waiting_ops_count; i++) {    grpc_transport_stream_op_finish_with_failure(        exec_ctx, &holder->waiting_ops[i], GRPC_ERROR_REF(error));  }  holder->waiting_ops_count = 0;  GRPC_ERROR_UNREF(error);}

grpc_connectivity_state grpc_connectivity_state_check(    grpc_connectivity_state_tracker *tracker, grpc_error **error) {  if (grpc_connectivity_state_trace) {    gpr_log(GPR_DEBUG, "CONWATCH: %p %s: get %s", tracker, tracker->name,            grpc_connectivity_state_name(tracker->current_state));  }  if (error != NULL) {    *error = GRPC_ERROR_REF(tracker->current_error);  }  return tracker->current_state;}

static void on_peer_checked(grpc_exec_ctx *exec_ctx, void *arg,                            grpc_error *error) {  security_handshaker *h = arg;  gpr_mu_lock(&h->mu);  if (error != GRPC_ERROR_NONE || h->shutdown) {    security_handshake_failed_locked(exec_ctx, h, GRPC_ERROR_REF(error));    goto done;  }  // Create frame protector.  tsi_frame_protector *protector;  tsi_result result = tsi_handshaker_result_create_frame_protector(      h->handshaker_result, NULL, &protector);  if (result != TSI_OK) {    error = grpc_set_tsi_error_result(        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Frame protector creation failed"),        result);    security_handshake_failed_locked(exec_ctx, h, error);    goto done;  }  // Get unused bytes.  unsigned char *unused_bytes = NULL;  size_t unused_bytes_size = 0;  result = tsi_handshaker_result_get_unused_bytes(      h->handshaker_result, &unused_bytes, &unused_bytes_size);  // Create secure endpoint.  if (unused_bytes_size > 0) {    grpc_slice slice =        grpc_slice_from_copied_buffer((char *)unused_bytes, unused_bytes_size);    h->args->endpoint =        grpc_secure_endpoint_create(protector, h->args->endpoint, &slice, 1);    grpc_slice_unref_internal(exec_ctx, slice);  } else {    h->args->endpoint =        grpc_secure_endpoint_create(protector, h->args->endpoint, NULL, 0);  }  tsi_handshaker_result_destroy(h->handshaker_result);  h->handshaker_result = NULL;  // Clear out the read buffer before it gets passed to the transport.  grpc_slice_buffer_reset_and_unref_internal(exec_ctx, h->args->read_buffer);  // Add auth context to channel args.  grpc_arg auth_context_arg = grpc_auth_context_to_arg(h->auth_context);  grpc_channel_args *tmp_args = h->args->args;  h->args->args =      grpc_channel_args_copy_and_add(tmp_args, &auth_context_arg, 1);  grpc_channel_args_destroy(exec_ctx, tmp_args);  // Invoke callback.  GRPC_CLOSURE_SCHED(exec_ctx, h->on_handshake_done, GRPC_ERROR_NONE);  // Set shutdown to true so that subsequent calls to  // security_handshaker_shutdown() do nothing.  h->shutdown = true;done:  gpr_mu_unlock(&h->mu);  security_handshaker_unref(exec_ctx, h);}

static void ru_allocated_slices(grpc_exec_ctx *exec_ctx, void *arg,                                grpc_error *error) {  grpc_resource_user_slice_allocator *slice_allocator = arg;  if (error == GRPC_ERROR_NONE) {    for (size_t i = 0; i < slice_allocator->count; i++) {      grpc_slice_buffer_add_indexed(          slice_allocator->dest, ru_slice_create(slice_allocator->resource_user,                                                 slice_allocator->length));    }  }  grpc_closure_run(exec_ctx, &slice_allocator->on_done, GRPC_ERROR_REF(error));}

static void tcp_read_allocation_done(grpc_exec_ctx *exec_ctx, void *tcpp,                                     grpc_error *error) {  grpc_tcp *tcp = tcpp;  if (error != GRPC_ERROR_NONE) {    grpc_slice_buffer_reset_and_unref(tcp->incoming_buffer);    grpc_slice_buffer_reset_and_unref(&tcp->last_read_buffer);    call_read_cb(exec_ctx, tcp, GRPC_ERROR_REF(error));    TCP_UNREF(exec_ctx, tcp, "read");  } else {    tcp_do_read(exec_ctx, tcp);  }}