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

static void test_create_many_persistant_metadata(void) {  grpc_mdctx *ctx;  char buffer[GPR_LTOA_MIN_BUFSIZE];  long i;  grpc_mdelem **created = gpr_malloc(sizeof(grpc_mdelem *) * MANY);  grpc_mdelem *md;  LOG_TEST("test_create_many_persistant_metadata");  ctx = grpc_mdctx_create();  /* add phase */  for (i = 0; i < MANY; i++) {    gpr_ltoa(i, buffer);    created[i] = grpc_mdelem_from_strings(ctx, "a", buffer);  }  /* verify phase */  for (i = 0; i < MANY; i++) {    gpr_ltoa(i, buffer);    md = grpc_mdelem_from_strings(ctx, "a", buffer);    GPR_ASSERT(md == created[i]);    GRPC_MDELEM_UNREF(md);  }  /* cleanup phase */  for (i = 0; i < MANY; i++) {    GRPC_MDELEM_UNREF(created[i]);  }  grpc_mdctx_unref(ctx);  gpr_free(created);}

static void on_initial_header(grpc_exec_ctx *exec_ctx, void *tp,                              grpc_mdelem *md) {  grpc_chttp2_transport *t = tp;  grpc_chttp2_stream *s = t->incoming_stream;  GPR_TIMER_BEGIN("on_initial_header", 0);  GPR_ASSERT(s != NULL);  GRPC_CHTTP2_IF_TRACING(gpr_log(      GPR_INFO, "HTTP:%d:HDR:%s: %s: %s", s->id, t->is_client ? "CLI" : "SVR",      grpc_mdstr_as_c_string(md->key), grpc_mdstr_as_c_string(md->value)));  if (md->key == GRPC_MDSTR_GRPC_STATUS && md != GRPC_MDELEM_GRPC_STATUS_0) {    /* TODO(ctiller): check for a status like " 0" */    s->seen_error = true;  }  if (md->key == GRPC_MDSTR_GRPC_TIMEOUT) {    gpr_timespec *cached_timeout = grpc_mdelem_get_user_data(md, free_timeout);    if (!cached_timeout) {      /* not already parsed: parse it now, and store the result away */      cached_timeout = gpr_malloc(sizeof(gpr_timespec));      if (!grpc_http2_decode_timeout(grpc_mdstr_as_c_string(md->value),                                     cached_timeout)) {        gpr_log(GPR_ERROR, "Ignoring bad timeout value '%s'",                grpc_mdstr_as_c_string(md->value));        *cached_timeout = gpr_inf_future(GPR_TIMESPAN);      }      grpc_mdelem_set_user_data(md, free_timeout, cached_timeout);    }    grpc_chttp2_incoming_metadata_buffer_set_deadline(        &s->metadata_buffer[0],        gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC), *cached_timeout));    GRPC_MDELEM_UNREF(md);  } else {    const size_t new_size = s->metadata_buffer[0].size + GRPC_MDELEM_LENGTH(md);    const size_t metadata_size_limit =        t->settings[GRPC_ACKED_SETTINGS]                   [GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE];    if (new_size > metadata_size_limit) {      gpr_log(GPR_DEBUG,              "received initial metadata size exceeds limit (%" PRIuPTR              " vs. %" PRIuPTR ")",              new_size, metadata_size_limit);      grpc_chttp2_cancel_stream(          exec_ctx, t, s,          grpc_error_set_int(              GRPC_ERROR_CREATE("received initial metadata size exceeds limit"),              GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED));      grpc_chttp2_parsing_become_skip_parser(exec_ctx, t);      s->seen_error = true;      GRPC_MDELEM_UNREF(md);    } else {      grpc_chttp2_incoming_metadata_buffer_add(&s->metadata_buffer[0], md);    }  }  GPR_TIMER_END("on_initial_header", 0);}

static void destroy_channel(grpc_exec_ctx *exec_ctx, grpc_channel *channel) {  size_t i;  grpc_channel_stack_destroy(exec_ctx, CHANNEL_STACK_FROM_CHANNEL(channel));  for (i = 0; i < NUM_CACHED_STATUS_ELEMS; i++) {    GRPC_MDELEM_UNREF(channel->grpc_status_elem[i]);  }  GRPC_MDSTR_UNREF(channel->grpc_status_string);  GRPC_MDSTR_UNREF(channel->grpc_compression_algorithm_string);  GRPC_MDSTR_UNREF(channel->grpc_encodings_accepted_by_peer_string);  GRPC_MDSTR_UNREF(channel->grpc_message_string);  GRPC_MDSTR_UNREF(channel->path_string);  GRPC_MDSTR_UNREF(channel->authority_string);  while (channel->registered_calls) {    registered_call *rc = channel->registered_calls;    channel->registered_calls = rc->next;    GRPC_MDELEM_UNREF(rc->path);    if (rc->authority) {      GRPC_MDELEM_UNREF(rc->authority);    }    gpr_free(rc);  }  if (channel->default_authority != NULL) {    GRPC_MDELEM_UNREF(channel->default_authority);  }  grpc_mdctx_unref(channel->metadata_context);  gpr_mu_destroy(&channel->registered_call_mu);  gpr_free(channel->target);  gpr_free(channel);}

void grpc_metadata_batch_destroy(grpc_metadata_batch *batch) {  grpc_linked_mdelem *l;  for (l = batch->list.head; l; l = l->next) {    GRPC_MDELEM_UNREF(l->md);  }  for (l = batch->garbage.head; l; l = l->next) {    GRPC_MDELEM_UNREF(l->md);  }}

static void test_spin_creating_the_same_thing(void) {  LOG_TEST("test_spin_creating_the_same_thing");  grpc_init();  GRPC_MDELEM_UNREF(grpc_mdelem_from_strings("a", "b"));  GRPC_MDELEM_UNREF(grpc_mdelem_from_strings("a", "b"));  GRPC_MDELEM_UNREF(grpc_mdelem_from_strings("a", "b"));  grpc_shutdown();}

static void on_trailing_header(grpc_exec_ctx *exec_ctx, void *tp,                               grpc_mdelem md) {  grpc_chttp2_transport *t = (grpc_chttp2_transport *)tp;  grpc_chttp2_stream *s = t->incoming_stream;  GPR_TIMER_BEGIN("on_trailing_header", 0);  GPR_ASSERT(s != NULL);  if (GRPC_TRACER_ON(grpc_http_trace)) {    char *key = grpc_slice_to_c_string(GRPC_MDKEY(md));    char *value =        grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);    gpr_log(GPR_INFO, "HTTP:%d:TRL:%s: %s: %s", s->id,            t->is_client ? "CLI" : "SVR", key, value);    gpr_free(key);    gpr_free(value);  }  if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_GRPC_STATUS) &&      !grpc_mdelem_eq(md, GRPC_MDELEM_GRPC_STATUS_0)) {    /* TODO(ctiller): check for a status like " 0" */    s->seen_error = true;  }  const size_t new_size = s->metadata_buffer[1].size + GRPC_MDELEM_LENGTH(md);  const size_t metadata_size_limit =      t->settings[GRPC_ACKED_SETTINGS]                 [GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE];  if (new_size > metadata_size_limit) {    gpr_log(GPR_DEBUG,            "received trailing metadata size exceeds limit (%" PRIuPTR            " vs. %" PRIuPTR ")",            new_size, metadata_size_limit);    grpc_chttp2_cancel_stream(        exec_ctx, t, s,        grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING(                               "received trailing metadata size exceeds limit"),                           GRPC_ERROR_INT_GRPC_STATUS,                           GRPC_STATUS_RESOURCE_EXHAUSTED));    grpc_chttp2_parsing_become_skip_parser(exec_ctx, t);    s->seen_error = true;    GRPC_MDELEM_UNREF(exec_ctx, md);  } else {    grpc_error *error = grpc_chttp2_incoming_metadata_buffer_add(        exec_ctx, &s->metadata_buffer[1], md);    if (error != GRPC_ERROR_NONE) {      grpc_chttp2_cancel_stream(exec_ctx, t, s, error);      grpc_chttp2_parsing_become_skip_parser(exec_ctx, t);      s->seen_error = true;      GRPC_MDELEM_UNREF(exec_ctx, md);    }  }  GPR_TIMER_END("on_trailing_header", 0);}

void grpc_chttp2_hptbl_destroy(grpc_chttp2_hptbl *tbl) {  size_t i;  for (i = 0; i < GRPC_CHTTP2_LAST_STATIC_ENTRY; i++) {    GRPC_MDELEM_UNREF(tbl->static_ents[i]);  }  for (i = 0; i < tbl->num_ents; i++) {    GRPC_MDELEM_UNREF(tbl->ents[(tbl->first_ent + i) % tbl->cap_entries]);  }  gpr_free(tbl->ents);}

/* Destructor for channel data */static void destroy_channel_elem(grpc_channel_element *elem) {  channel_data *channeld = elem->channel_data;  grpc_compression_algorithm algo_idx;  GRPC_MDSTR_UNREF(channeld->mdstr_request_compression_algorithm_key);  GRPC_MDSTR_UNREF(channeld->mdstr_outgoing_compression_algorithm_key);  GRPC_MDSTR_UNREF(channeld->mdstr_compression_capabilities_key);  for (algo_idx = 0; algo_idx < GRPC_COMPRESS_ALGORITHMS_COUNT; ++algo_idx) {    GRPC_MDELEM_UNREF(channeld->mdelem_compression_algorithms[algo_idx]);  }  GRPC_MDELEM_UNREF(channeld->mdelem_accept_encoding);}

static void test_many_additions(void) {  grpc_chttp2_hptbl tbl;  int i;  char *key;  char *value;  LOG_TEST("test_many_additions");  grpc_chttp2_hptbl_init(&tbl);  for (i = 0; i < 1000000; i++) {    grpc_mdelem *elem;    gpr_asprintf(&key, "K:%d", i);    gpr_asprintf(&value, "VALUE:%d", i);    elem = grpc_mdelem_from_strings(key, value);    GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem));    GRPC_MDELEM_UNREF(elem);    assert_index(&tbl, 1 + GRPC_CHTTP2_LAST_STATIC_ENTRY, key, value);    gpr_free(key);    gpr_free(value);    if (i) {      gpr_asprintf(&key, "K:%d", i - 1);      gpr_asprintf(&value, "VALUE:%d", i - 1);      assert_index(&tbl, 2 + GRPC_CHTTP2_LAST_STATIC_ENTRY, key, value);      gpr_free(key);      gpr_free(value);    }  }  grpc_chttp2_hptbl_destroy(&tbl);}

void grpc_credentials_mdelem_array_destroy(    grpc_exec_ctx *exec_ctx, grpc_credentials_mdelem_array *list) {  for (size_t i = 0; i < list->size; ++i) {    GRPC_MDELEM_UNREF(exec_ctx, list->md[i]);  }  gpr_free(list->md);}

static void destroy_call(grpc_exec_ctx *exec_ctx, void *call, int success) {  size_t i;  int ii;  grpc_call *c = call;  GPR_TIMER_BEGIN("destroy_call", 0);  for (i = 0; i < 2; i++) {    grpc_metadata_batch_destroy(        &c->metadata_batch[1 /* is_receiving */][i /* is_initial */]);  }  if (c->receiving_stream != NULL) {    grpc_byte_stream_destroy(c->receiving_stream);  }  grpc_call_stack_destroy(exec_ctx, CALL_STACK_FROM_CALL(c));  GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, c->channel, "call");  gpr_mu_destroy(&c->mu);  for (i = 0; i < STATUS_SOURCE_COUNT; i++) {    if (c->status[i].details) {      GRPC_MDSTR_UNREF(c->status[i].details);    }  }  for (ii = 0; ii < c->send_extra_metadata_count; ii++) {    GRPC_MDELEM_UNREF(c->send_extra_metadata[ii].md);  }  for (i = 0; i < GRPC_CONTEXT_COUNT; i++) {    if (c->context[i].destroy) {      c->context[i].destroy(c->context[i].value);    }  }  if (c->cq) {    GRPC_CQ_INTERNAL_UNREF(c->cq, "bind");  }  gpr_free(c);  GPR_TIMER_END("destroy_call", 0);}

static void test_algorithm_mesh(void) {  int i;  gpr_log(GPR_DEBUG, "test_algorithm_mesh");  for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {    const char *name;    grpc_compression_algorithm parsed;    grpc_slice mdstr;    grpc_mdelem mdelem;    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;    GPR_ASSERT(        grpc_compression_algorithm_name((grpc_compression_algorithm)i, &name));    GPR_ASSERT(grpc_compression_algorithm_parse(        grpc_slice_from_static_string(name), &parsed));    GPR_ASSERT((int)parsed == i);    mdstr = grpc_slice_from_copied_string(name);    GPR_ASSERT(grpc_slice_eq(mdstr, grpc_compression_algorithm_slice(parsed)));    GPR_ASSERT(parsed == grpc_compression_algorithm_from_slice(mdstr));    mdelem = grpc_compression_encoding_mdelem(parsed);    GPR_ASSERT(grpc_slice_eq(GRPC_MDVALUE(mdelem), mdstr));    GPR_ASSERT(grpc_slice_eq(GRPC_MDKEY(mdelem), GRPC_MDSTR_GRPC_ENCODING));    grpc_slice_unref_internal(&exec_ctx, mdstr);    GRPC_MDELEM_UNREF(&exec_ctx, mdelem);    grpc_exec_ctx_finish(&exec_ctx);  }  /* test failure */  GPR_ASSERT(GRPC_MDISNULL(      grpc_compression_encoding_mdelem(GRPC_COMPRESS_ALGORITHMS_COUNT)));}

static grpc_chttp2_hptbl_find_result find_simple(grpc_chttp2_hptbl *tbl,                                                 const char *key,                                                 const char *value) {  grpc_mdelem *md = grpc_mdelem_from_strings(key, value);  grpc_chttp2_hptbl_find_result r = grpc_chttp2_hptbl_find(tbl, md);  GRPC_MDELEM_UNREF(md);  return r;}

void grpc_chttp2_hpack_compressor_destroy(grpc_chttp2_hpack_compressor *c) {  int i;  for (i = 0; i < GRPC_CHTTP2_HPACKC_NUM_VALUES; i++) {    if (c->entries_keys[i]) GRPC_MDSTR_UNREF(c->entries_keys[i]);    if (c->entries_elems[i]) GRPC_MDELEM_UNREF(c->entries_elems[i]);  }  gpr_free(c->table_elem_size);}

static void destroy_channel(grpc_exec_ctx *exec_ctx, grpc_channel *channel) {  grpc_channel_stack_destroy(exec_ctx, CHANNEL_STACK_FROM_CHANNEL(channel));  while (channel->registered_calls) {    registered_call *rc = channel->registered_calls;    channel->registered_calls = rc->next;    GRPC_MDELEM_UNREF(rc->path);    if (rc->authority) {      GRPC_MDELEM_UNREF(rc->authority);    }    gpr_free(rc);  }  if (channel->default_authority != NULL) {    GRPC_MDELEM_UNREF(channel->default_authority);  }  gpr_mu_destroy(&channel->registered_call_mu);  gpr_free(channel->target);  gpr_free(channel);}

void grpc_chttp2_incoming_metadata_buffer_destroy(    grpc_chttp2_incoming_metadata_buffer *buffer) {  size_t i;  if (!buffer->published) {    for (i = 0; i < buffer->count; i++) {      GRPC_MDELEM_UNREF(buffer->elems[i].md);    }  }  gpr_free(buffer->elems);}

/* Evict one element from the table */static void evict1(grpc_chttp2_hptbl *tbl) {  grpc_mdelem *first_ent = tbl->ents[tbl->first_ent];  size_t elem_bytes = GPR_SLICE_LENGTH(first_ent->key->slice) +                      GPR_SLICE_LENGTH(first_ent->value->slice) +                      GRPC_CHTTP2_HPACK_ENTRY_OVERHEAD;  GPR_ASSERT(elem_bytes <= tbl->mem_used);  tbl->mem_used -= (uint32_t)elem_bytes;  tbl->first_ent = ((tbl->first_ent + 1) % tbl->cap_entries);  tbl->num_ents--;  GRPC_MDELEM_UNREF(first_ent);}

void grpc_chttp2_hpack_compressor_destroy(grpc_exec_ctx *exec_ctx,                                          grpc_chttp2_hpack_compressor *c) {  int i;  for (i = 0; i < GRPC_CHTTP2_HPACKC_NUM_VALUES; i++) {    if (c->entries_keys[i].refcount != &terminal_slice_refcount) {      grpc_slice_unref_internal(exec_ctx, c->entries_keys[i]);    }    GRPC_MDELEM_UNREF(exec_ctx, c->entries_elems[i]);  }  gpr_free(c->table_elem_size);}

static void onhdr(grpc_exec_ctx *exec_ctx, void *ud, grpc_mdelem md) {  const char *ekey, *evalue;  test_checker *chk = ud;  ekey = va_arg(chk->args, char *);  GPR_ASSERT(ekey);  evalue = va_arg(chk->args, char *);  GPR_ASSERT(evalue);  GPR_ASSERT(grpc_slice_str_cmp(GRPC_MDKEY(md), ekey) == 0);  GPR_ASSERT(grpc_slice_str_cmp(GRPC_MDVALUE(md), evalue) == 0);  GRPC_MDELEM_UNREF(exec_ctx, md);}

static void onhdr(void *ud, grpc_mdelem *md) {  const char *ekey, *evalue;  test_checker *chk = ud;  ekey = va_arg(chk->args, char *);  GPR_ASSERT(ekey);  evalue = va_arg(chk->args, char *);  GPR_ASSERT(evalue);  GPR_ASSERT(gpr_slice_str_cmp(md->key->slice, ekey) == 0);  GPR_ASSERT(gpr_slice_str_cmp(md->value->slice, evalue) == 0);  GRPC_MDELEM_UNREF(md);}

static void deadline_enc(grpc_chttp2_hpack_compressor *c, gpr_timespec deadline,                         framer_state *st) {  char timeout_str[GRPC_HTTP2_TIMEOUT_ENCODE_MIN_BUFSIZE];  grpc_mdelem *mdelem;  grpc_http2_encode_timeout(      gpr_time_sub(deadline, gpr_now(deadline.clock_type)), timeout_str);  mdelem = grpc_mdelem_from_metadata_strings(      GRPC_MDSTR_GRPC_TIMEOUT, grpc_mdstr_from_string(timeout_str));  hpack_enc(c, mdelem, st);  GRPC_MDELEM_UNREF(mdelem);}

static void deadline_enc(grpc_exec_ctx *exec_ctx,                         grpc_chttp2_hpack_compressor *c, gpr_timespec deadline,                         framer_state *st) {  char timeout_str[GRPC_HTTP2_TIMEOUT_ENCODE_MIN_BUFSIZE];  grpc_mdelem mdelem;  grpc_http2_encode_timeout(      gpr_time_sub(deadline, gpr_now(deadline.clock_type)), timeout_str);  mdelem = grpc_mdelem_from_slices(exec_ctx, GRPC_MDSTR_GRPC_TIMEOUT,                                   grpc_slice_from_copied_string(timeout_str));  hpack_enc(exec_ctx, c, mdelem, st);  GRPC_MDELEM_UNREF(exec_ctx, mdelem);}

static void test_create_metadata(void) {  grpc_mdelem *m1, *m2, *m3;  LOG_TEST("test_create_metadata");  grpc_init();  m1 = grpc_mdelem_from_strings("a", "b");  m2 = grpc_mdelem_from_strings("a", "b");  m3 = grpc_mdelem_from_strings("a", "c");  GPR_ASSERT(m1 == m2);  GPR_ASSERT(m3 != m1);  GPR_ASSERT(m3->key == m1->key);  GPR_ASSERT(m3->value != m1->value);  GPR_ASSERT(gpr_slice_str_cmp(m1->key->slice, "a") == 0);  GPR_ASSERT(gpr_slice_str_cmp(m1->value->slice, "b") == 0);  GPR_ASSERT(gpr_slice_str_cmp(m3->value->slice, "c") == 0);  GRPC_MDELEM_UNREF(m1);  GRPC_MDELEM_UNREF(m2);  GRPC_MDELEM_UNREF(m3);  grpc_shutdown();}

void grpc_metadata_batch_filter(grpc_metadata_batch *batch,                                grpc_mdelem *(*filter)(void *user_data,                                                       grpc_mdelem *elem),                                void *user_data) {  grpc_linked_mdelem *l;  grpc_linked_mdelem *next;  GPR_TIMER_BEGIN("grpc_metadata_batch_filter", 0);  assert_valid_list(&batch->list);  for (l = batch->list.head; l; l = next) {    grpc_mdelem *orig = l->md;    grpc_mdelem *filt = filter(user_data, orig);    next = l->next;    if (filt == NULL) {      if (l->prev) {        l->prev->next = l->next;      }      if (l->next) {        l->next->prev = l->prev;      }      if (batch->list.head == l) {        batch->list.head = l->next;      }      if (batch->list.tail == l) {        batch->list.tail = l->prev;      }      assert_valid_list(&batch->list);      GRPC_MDELEM_UNREF(l->md);    } else if (filt != orig) {      GRPC_MDELEM_UNREF(orig);      l->md = filt;    }  }  assert_valid_list(&batch->list);  GPR_TIMER_END("grpc_metadata_batch_filter", 0);}

static void destroy_channel(void *p, int ok) {    grpc_channel *channel = p;    size_t i;    grpc_channel_stack_destroy(CHANNEL_STACK_FROM_CHANNEL(channel));    for (i = 0; i < NUM_CACHED_STATUS_ELEMS; i++) {        GRPC_MDELEM_UNREF(channel->grpc_status_elem[i]);    }    GRPC_MDSTR_UNREF(channel->grpc_status_string);    GRPC_MDSTR_UNREF(channel->grpc_compression_level_string);    GRPC_MDSTR_UNREF(channel->grpc_message_string);    GRPC_MDSTR_UNREF(channel->path_string);    GRPC_MDSTR_UNREF(channel->authority_string);    while (channel->registered_calls) {        registered_call *rc = channel->registered_calls;        channel->registered_calls = rc->next;        GRPC_MDELEM_UNREF(rc->path);        GRPC_MDELEM_UNREF(rc->authority);        gpr_free(rc);    }    grpc_mdctx_unref(channel->metadata_context);    gpr_mu_destroy(&channel->registered_call_mu);    gpr_free(channel);}

static void test_create_many_ephemeral_metadata(void) {  char buffer[GPR_LTOA_MIN_BUFSIZE];  long i;  LOG_TEST("test_create_many_ephemeral_metadata");  grpc_init();  /* add, and immediately delete a bunch of different elements */  for (i = 0; i < MANY; i++) {    gpr_ltoa(i, buffer);    GRPC_MDELEM_UNREF(grpc_mdelem_from_strings("a", buffer));  }  grpc_shutdown();}

/* Destructor for channel data */static void destroy_channel_elem(grpc_channel_element *elem) {  /* grab pointers to our data from the channel element */  channel_data *channeld = elem->channel_data;  GRPC_MDELEM_UNREF(channeld->te_trailers);  GRPC_MDELEM_UNREF(channeld->status_ok);  GRPC_MDELEM_UNREF(channeld->status_not_found);  GRPC_MDELEM_UNREF(channeld->method_post);  GRPC_MDELEM_UNREF(channeld->http_scheme);  GRPC_MDELEM_UNREF(channeld->https_scheme);  GRPC_MDELEM_UNREF(channeld->grpc_scheme);  GRPC_MDELEM_UNREF(channeld->content_type);  GRPC_MDSTR_UNREF(channeld->path_key);  GRPC_MDSTR_UNREF(channeld->authority_key);  GRPC_MDSTR_UNREF(channeld->host_key);}

static void test_spin_creating_the_same_thing(void) {  grpc_mdctx *ctx;  LOG_TEST("test_spin_creating_the_same_thing");  ctx = grpc_mdctx_create();  GPR_ASSERT(grpc_mdctx_get_mdtab_count_test_only(ctx) == 0);  GPR_ASSERT(grpc_mdctx_get_mdtab_free_test_only(ctx) == 0);  GRPC_MDELEM_UNREF(grpc_mdelem_from_strings(ctx, "a", "b"));  GPR_ASSERT(grpc_mdctx_get_mdtab_count_test_only(ctx) == 1);  GPR_ASSERT(grpc_mdctx_get_mdtab_free_test_only(ctx) == 1);  GRPC_MDELEM_UNREF(grpc_mdelem_from_strings(ctx, "a", "b"));  GPR_ASSERT(grpc_mdctx_get_mdtab_count_test_only(ctx) == 1);  GPR_ASSERT(grpc_mdctx_get_mdtab_free_test_only(ctx) == 1);  GRPC_MDELEM_UNREF(grpc_mdelem_from_strings(ctx, "a", "b"));  GPR_ASSERT(grpc_mdctx_get_mdtab_count_test_only(ctx) == 1);  GPR_ASSERT(grpc_mdctx_get_mdtab_free_test_only(ctx) == 1);  grpc_mdctx_unref(ctx);}

/* Destructor for channel data */static void destroy_channel_elem(grpc_channel_element *elem) {  /* grab pointers to our data from the channel element */  channel_data *channeld = elem->channel_data;  GRPC_MDELEM_UNREF(channeld->te_trailers);  GRPC_MDELEM_UNREF(channeld->method);  GRPC_MDELEM_UNREF(channeld->scheme);  GRPC_MDELEM_UNREF(channeld->content_type);  GRPC_MDELEM_UNREF(channeld->status);  GRPC_MDELEM_UNREF(channeld->user_agent);}

static void on_trailing_header(void *tp, grpc_mdelem *md) {  grpc_chttp2_transport_parsing *transport_parsing = tp;  grpc_chttp2_stream_parsing *stream_parsing =      transport_parsing->incoming_stream;  GPR_TIMER_BEGIN("on_trailing_header", 0);  GPR_ASSERT(stream_parsing);  GRPC_CHTTP2_IF_TRACING(gpr_log(      GPR_INFO, "HTTP:%d:TRL:%s: %s: %s", stream_parsing->id,      transport_parsing->is_client ? "CLI" : "SVR",      grpc_mdstr_as_c_string(md->key), grpc_mdstr_as_c_string(md->value)));  if (md->key == GRPC_MDSTR_GRPC_STATUS && md != GRPC_MDELEM_GRPC_STATUS_0) {    /* TODO(ctiller): check for a status like " 0" */    stream_parsing->seen_error = true;  }  const size_t new_size =      stream_parsing->metadata_buffer[1].size + GRPC_MDELEM_LENGTH(md);  grpc_chttp2_transport_global *transport_global =      &TRANSPORT_FROM_PARSING(transport_parsing)->global;  const size_t metadata_size_limit =      transport_global->settings[GRPC_LOCAL_SETTINGS]                                [GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE];  if (new_size > metadata_size_limit) {    if (!stream_parsing->exceeded_metadata_size) {      gpr_log(GPR_DEBUG,              "received trailing metadata size exceeds limit (%" PRIuPTR              " vs. %" PRIuPTR ")",              new_size, metadata_size_limit);      stream_parsing->seen_error = true;      stream_parsing->exceeded_metadata_size = true;    }    GRPC_MDELEM_UNREF(md);  } else {    grpc_chttp2_incoming_metadata_buffer_add(        &stream_parsing->metadata_buffer[1], md);  }  grpc_chttp2_list_add_parsing_seen_stream(transport_parsing, stream_parsing);  GPR_TIMER_END("on_trailing_header", 0);}