Merge pull request #4188 from ctiller/no-transport-metadata

Remove metadata contexts

12 files changed, 118 insertions, 175 deletions

diff --git a/test/core/bad_client/bad_client.c b/test/core/bad_client/bad_client.c
index ed46e7b009..e1a4b8ed90 100644
--- a/test/core/bad_client/bad_client.c
+++ b/test/core/bad_client/bad_client.c
@@ -64,14 +64,13 @@ static void done_write(grpc_exec_ctx *exec_ctx, void *arg, int success) {
   gpr_event_set(&a->done_write, (void *)1);
 }
 
-static void server_setup_transport(void *ts, grpc_transport *transport,
-                                   grpc_mdctx *mdctx) {
+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_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_server_setup_transport(&exec_ctx, a->server, transport, extra_filters,
-                              GPR_ARRAY_SIZE(extra_filters), mdctx,
+                              GPR_ARRAY_SIZE(extra_filters),
                               grpc_server_get_channel_args(a->server));
   grpc_exec_ctx_finish(&exec_ctx);
 }
@@ -84,7 +83,6 @@ void grpc_run_bad_client_test(grpc_bad_client_server_side_validator validator,
   gpr_thd_id id;
   char *hex;
   grpc_transport *transport;
-  grpc_mdctx *mdctx = grpc_mdctx_create();
   gpr_slice slice =
       gpr_slice_from_copied_buffer(client_payload, client_payload_length);
   gpr_slice_buffer outgoing;
@@ -113,9 +111,8 @@ void grpc_run_bad_client_test(grpc_bad_client_server_side_validator validator,
   a.validator = validator;
   grpc_server_register_completion_queue(a.server, a.cq, NULL);
   grpc_server_start(a.server);
-  transport =
-      grpc_create_chttp2_transport(&exec_ctx, NULL, sfd.server, mdctx, 0);
-  server_setup_transport(&a, transport, mdctx);
+  transport = grpc_create_chttp2_transport(&exec_ctx, NULL, sfd.server, 0);
+  server_setup_transport(&a, transport);
   grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL, 0);
   grpc_exec_ctx_finish(&exec_ctx);
 
diff --git a/test/core/channel/channel_stack_test.c b/test/core/channel/channel_stack_test.c
index 5e1ba11857..9dbb879300 100644
--- a/test/core/channel/channel_stack_test.c
+++ b/test/core/channel/channel_stack_test.c
@@ -93,13 +93,10 @@ static void test_create_channel_stack(void) {
   grpc_call_element *call_elem;
   grpc_arg arg;
   grpc_channel_args chan_args;
-  grpc_mdctx *metadata_context;
   int *channel_data;
   int *call_data;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  metadata_context = grpc_mdctx_create();
-
   arg.type = GRPC_ARG_INTEGER;
   arg.key = "test_key";
   arg.value.integer = 42;
@@ -109,7 +106,7 @@ static void test_create_channel_stack(void) {
 
   channel_stack = gpr_malloc(grpc_channel_stack_size(&filters, 1));
   grpc_channel_stack_init(&exec_ctx, &filters, 1, NULL, &chan_args,
-                          metadata_context, channel_stack);
+                          channel_stack);
   GPR_ASSERT(channel_stack->count == 1);
   channel_elem = grpc_channel_stack_element(channel_stack, 0);
   channel_data = (int *)channel_elem->channel_data;
@@ -133,13 +130,13 @@ static void test_create_channel_stack(void) {
   grpc_channel_stack_destroy(&exec_ctx, channel_stack);
   gpr_free(channel_stack);
 
-  grpc_mdctx_unref(metadata_context);
-
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
+  grpc_init();
   test_create_channel_stack();
+  grpc_shutdown();
   return 0;
 }
diff --git a/test/core/compression/compression_test.c b/test/core/compression/compression_test.c
index 633fbd97f4..35fadc00c0 100644
--- a/test/core/compression/compression_test.c
+++ b/test/core/compression/compression_test.c
@@ -35,6 +35,7 @@
 #include <string.h>
 
 #include <grpc/compression.h>
+#include <grpc/grpc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/useful.h>
 
@@ -71,7 +72,9 @@ static void test_compression_algorithm_parse(void) {
 }
 
 int main(int argc, char **argv) {
+  grpc_init();
   test_compression_algorithm_parse();
+  grpc_shutdown();
 
   return 0;
 }
diff --git a/test/core/compression/message_compress_test.c b/test/core/compression/message_compress_test.c
index 98da6a1eaa..dfaed8484e 100644
--- a/test/core/compression/message_compress_test.c
+++ b/test/core/compression/message_compress_test.c
@@ -36,10 +36,12 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "test/core/util/test_config.h"
-#include "src/core/support/murmur_hash.h"
+#include <grpc/grpc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/useful.h>
+
+#include "test/core/util/test_config.h"
+#include "src/core/support/murmur_hash.h"
 #include "test/core/util/slice_splitter.h"
 
 typedef enum { ONE_A = 0, ONE_KB_A, ONE_MB_A, TEST_VALUE_COUNT } test_value;
@@ -175,6 +177,7 @@ int main(int argc, char **argv) {
                                                     GRPC_SLICE_SPLIT_ONE_BYTE};
 
   grpc_test_init(argc, argv);
+  grpc_init();
 
   for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
     for (j = 0; j < GPR_ARRAY_SIZE(uncompressed_split_modes); j++) {
@@ -189,6 +192,7 @@ int main(int argc, char **argv) {
   }
 
   test_bad_data();
+  grpc_shutdown();
 
   return 0;
 }
diff --git a/test/core/end2end/fixtures/h2_sockpair+trace.c b/test/core/end2end/fixtures/h2_sockpair+trace.c
index 1f5051f0ab..ccc8631d94 100644
--- a/test/core/end2end/fixtures/h2_sockpair+trace.c
+++ b/test/core/end2end/fixtures/h2_sockpair+trace.c
@@ -57,14 +57,13 @@
 /* chttp2 transport that is immediately available (used for testing
    connected_channel without a client_channel */
 
-static void server_setup_transport(void *ts, grpc_transport *transport,
-                                   grpc_mdctx *mdctx) {
+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_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_server_setup_transport(&exec_ctx, f->server, transport, extra_filters,
-                              GPR_ARRAY_SIZE(extra_filters), mdctx,
+                              GPR_ARRAY_SIZE(extra_filters),
                               grpc_server_get_channel_args(f->server));
   grpc_exec_ctx_finish(&exec_ctx);
 }
@@ -75,17 +74,15 @@ typedef struct {
 } sp_client_setup;
 
 static void client_setup_transport(grpc_exec_ctx *exec_ctx, void *ts,
-                                   grpc_transport *transport,
-                                   grpc_mdctx *mdctx) {
+                                   grpc_transport *transport) {
   sp_client_setup *cs = ts;
 
   const grpc_channel_filter *filters[] = {&grpc_http_client_filter,
                                           &grpc_compress_filter,
                                           &grpc_connected_channel_filter};
   size_t nfilters = sizeof(filters) / sizeof(*filters);
-  grpc_channel *channel =
-      grpc_channel_create_from_filters(exec_ctx, "socketpair-target", filters,
-                                       nfilters, cs->client_args, mdctx, 1);
+  grpc_channel *channel = grpc_channel_create_from_filters(
+      exec_ctx, "socketpair-target", filters, nfilters, cs->client_args, 1);
 
   cs->f->client = channel;
 
@@ -112,13 +109,12 @@ static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_endpoint_pair *sfd = f->fixture_data;
   grpc_transport *transport;
-  grpc_mdctx *mdctx = grpc_mdctx_create();
   sp_client_setup cs;
   cs.client_args = client_args;
   cs.f = f;
-  transport = grpc_create_chttp2_transport(&exec_ctx, client_args, sfd->client,
-                                           mdctx, 1);
-  client_setup_transport(&exec_ctx, &cs, transport, mdctx);
+  transport =
+      grpc_create_chttp2_transport(&exec_ctx, client_args, sfd->client, 1);
+  client_setup_transport(&exec_ctx, &cs, transport);
   GPR_ASSERT(f->client);
   grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL, 0);
   grpc_exec_ctx_finish(&exec_ctx);
@@ -128,15 +124,14 @@ static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f,
                                           grpc_channel_args *server_args) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_endpoint_pair *sfd = f->fixture_data;
-  grpc_mdctx *mdctx = grpc_mdctx_create();
   grpc_transport *transport;
   GPR_ASSERT(!f->server);
   f->server = grpc_server_create_from_filters(NULL, 0, server_args);
   grpc_server_register_completion_queue(f->server, f->cq, NULL);
   grpc_server_start(f->server);
-  transport = grpc_create_chttp2_transport(&exec_ctx, server_args, sfd->server,
-                                           mdctx, 0);
-  server_setup_transport(f, transport, mdctx);
+  transport =
+      grpc_create_chttp2_transport(&exec_ctx, server_args, sfd->server, 0);
+  server_setup_transport(f, transport);
   grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL, 0);
   grpc_exec_ctx_finish(&exec_ctx);
 }
diff --git a/test/core/end2end/fixtures/h2_sockpair.c b/test/core/end2end/fixtures/h2_sockpair.c
index b61fe98610..a6a84c9b1a 100644
--- a/test/core/end2end/fixtures/h2_sockpair.c
+++ b/test/core/end2end/fixtures/h2_sockpair.c
@@ -56,14 +56,13 @@
 /* chttp2 transport that is immediately available (used for testing
    connected_channel without a client_channel */
 
-static void server_setup_transport(void *ts, grpc_transport *transport,
-                                   grpc_mdctx *mdctx) {
+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_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_server_setup_transport(&exec_ctx, f->server, transport, extra_filters,
-                              GPR_ARRAY_SIZE(extra_filters), mdctx,
+                              GPR_ARRAY_SIZE(extra_filters),
                               grpc_server_get_channel_args(f->server));
   grpc_exec_ctx_finish(&exec_ctx);
 }
@@ -74,17 +73,15 @@ typedef struct {
 } sp_client_setup;
 
 static void client_setup_transport(grpc_exec_ctx *exec_ctx, void *ts,
-                                   grpc_transport *transport,
-                                   grpc_mdctx *mdctx) {
+                                   grpc_transport *transport) {
   sp_client_setup *cs = ts;
 
   const grpc_channel_filter *filters[] = {&grpc_http_client_filter,
                                           &grpc_compress_filter,
                                           &grpc_connected_channel_filter};
   size_t nfilters = sizeof(filters) / sizeof(*filters);
-  grpc_channel *channel =
-      grpc_channel_create_from_filters(exec_ctx, "socketpair-target", filters,
-                                       nfilters, cs->client_args, mdctx, 1);
+  grpc_channel *channel = grpc_channel_create_from_filters(
+      exec_ctx, "socketpair-target", filters, nfilters, cs->client_args, 1);
 
   cs->f->client = channel;
 
@@ -111,13 +108,12 @@ static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_endpoint_pair *sfd = f->fixture_data;
   grpc_transport *transport;
-  grpc_mdctx *mdctx = grpc_mdctx_create();
   sp_client_setup cs;
   cs.client_args = client_args;
   cs.f = f;
-  transport = grpc_create_chttp2_transport(&exec_ctx, client_args, sfd->client,
-                                           mdctx, 1);
-  client_setup_transport(&exec_ctx, &cs, transport, mdctx);
+  transport =
+      grpc_create_chttp2_transport(&exec_ctx, client_args, sfd->client, 1);
+  client_setup_transport(&exec_ctx, &cs, transport);
   GPR_ASSERT(f->client);
   grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL, 0);
   grpc_exec_ctx_finish(&exec_ctx);
@@ -127,15 +123,14 @@ static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f,
                                           grpc_channel_args *server_args) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_endpoint_pair *sfd = f->fixture_data;
-  grpc_mdctx *mdctx = grpc_mdctx_create();
   grpc_transport *transport;
   GPR_ASSERT(!f->server);
   f->server = grpc_server_create_from_filters(NULL, 0, server_args);
   grpc_server_register_completion_queue(f->server, f->cq, NULL);
   grpc_server_start(f->server);
-  transport = grpc_create_chttp2_transport(&exec_ctx, server_args, sfd->server,
-                                           mdctx, 0);
-  server_setup_transport(f, transport, mdctx);
+  transport =
+      grpc_create_chttp2_transport(&exec_ctx, server_args, sfd->server, 0);
+  server_setup_transport(f, transport);
   grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL, 0);
   grpc_exec_ctx_finish(&exec_ctx);
 }
diff --git a/test/core/end2end/fixtures/h2_sockpair_1byte.c b/test/core/end2end/fixtures/h2_sockpair_1byte.c
index 9f0fd2ea9a..4b8f9054ef 100644
--- a/test/core/end2end/fixtures/h2_sockpair_1byte.c
+++ b/test/core/end2end/fixtures/h2_sockpair_1byte.c
@@ -56,14 +56,13 @@
 /* chttp2 transport that is immediately available (used for testing
    connected_channel without a client_channel */
 
-static void server_setup_transport(void *ts, grpc_transport *transport,
-                                   grpc_mdctx *mdctx) {
+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_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_server_setup_transport(&exec_ctx, f->server, transport, extra_filters,
-                              GPR_ARRAY_SIZE(extra_filters), mdctx,
+                              GPR_ARRAY_SIZE(extra_filters),
                               grpc_server_get_channel_args(f->server));
   grpc_exec_ctx_finish(&exec_ctx);
 }
@@ -74,17 +73,15 @@ typedef struct {
 } sp_client_setup;
 
 static void client_setup_transport(grpc_exec_ctx *exec_ctx, void *ts,
-                                   grpc_transport *transport,
-                                   grpc_mdctx *mdctx) {
+                                   grpc_transport *transport) {
   sp_client_setup *cs = ts;
 
   const grpc_channel_filter *filters[] = {&grpc_http_client_filter,
                                           &grpc_compress_filter,
                                           &grpc_connected_channel_filter};
   size_t nfilters = sizeof(filters) / sizeof(*filters);
-  grpc_channel *channel =
-      grpc_channel_create_from_filters(exec_ctx, "socketpair-target", filters,
-                                       nfilters, cs->client_args, mdctx, 1);
+  grpc_channel *channel = grpc_channel_create_from_filters(
+      exec_ctx, "socketpair-target", filters, nfilters, cs->client_args, 1);
 
   cs->f->client = channel;
 
@@ -111,13 +108,12 @@ static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f,
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_endpoint_pair *sfd = f->fixture_data;
   grpc_transport *transport;
-  grpc_mdctx *mdctx = grpc_mdctx_create();
   sp_client_setup cs;
   cs.client_args = client_args;
   cs.f = f;
-  transport = grpc_create_chttp2_transport(&exec_ctx, client_args, sfd->client,
-                                           mdctx, 1);
-  client_setup_transport(&exec_ctx, &cs, transport, mdctx);
+  transport =
+      grpc_create_chttp2_transport(&exec_ctx, client_args, sfd->client, 1);
+  client_setup_transport(&exec_ctx, &cs, transport);
   GPR_ASSERT(f->client);
   grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL, 0);
   grpc_exec_ctx_finish(&exec_ctx);
@@ -127,15 +123,14 @@ static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f,
                                           grpc_channel_args *server_args) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_endpoint_pair *sfd = f->fixture_data;
-  grpc_mdctx *mdctx = grpc_mdctx_create();
   grpc_transport *transport;
   GPR_ASSERT(!f->server);
   f->server = grpc_server_create_from_filters(NULL, 0, server_args);
   grpc_server_register_completion_queue(f->server, f->cq, NULL);
   grpc_server_start(f->server);
-  transport = grpc_create_chttp2_transport(&exec_ctx, server_args, sfd->server,
-                                           mdctx, 0);
-  server_setup_transport(f, transport, mdctx);
+  transport =
+      grpc_create_chttp2_transport(&exec_ctx, server_args, sfd->server, 0);
+  server_setup_transport(f, transport);
   grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL, 0);
   grpc_exec_ctx_finish(&exec_ctx);
 }
diff --git a/test/core/end2end/fixtures/h2_uchannel.c b/test/core/end2end/fixtures/h2_uchannel.c
index d1f9d38b82..ee4a60c29a 100644
--- a/test/core/end2end/fixtures/h2_uchannel.c
+++ b/test/core/end2end/fixtures/h2_uchannel.c
@@ -66,8 +66,6 @@ typedef struct {
 
   grpc_endpoint *tcp;
 
-  grpc_mdctx *mdctx;
-
   grpc_closure connected;
 } connector;
 
@@ -79,7 +77,6 @@ static void connector_ref(grpc_connector *con) {
 static void connector_unref(grpc_exec_ctx *exec_ctx, grpc_connector *con) {
   connector *c = (connector *)con;
   if (gpr_unref(&c->refs)) {
-    grpc_mdctx_unref(c->mdctx);
     gpr_free(c);
   }
 }
@@ -89,8 +86,8 @@ static void connected(grpc_exec_ctx *exec_ctx, void *arg, int success) {
   grpc_closure *notify;
   grpc_endpoint *tcp = c->tcp;
   if (tcp != NULL) {
-    c->result->transport = grpc_create_chttp2_transport(
-        exec_ctx, c->args.channel_args, tcp, c->mdctx, 1);
+    c->result->transport =
+        grpc_create_chttp2_transport(exec_ctx, c->args.channel_args, tcp, 1);
     grpc_chttp2_transport_start_reading(exec_ctx, c->result->transport, NULL,
                                         0);
     GPR_ASSERT(c->result->transport);
@@ -130,7 +127,6 @@ static const grpc_connector_vtable connector_vtable = {
 typedef struct {
   grpc_subchannel_factory base;
   gpr_refcount refs;
-  grpc_mdctx *mdctx;
   grpc_channel_args *merge_args;
   grpc_channel *master;
   grpc_subchannel **sniffed_subchannel;
@@ -147,7 +143,6 @@ static void subchannel_factory_unref(grpc_exec_ctx *exec_ctx,
   if (gpr_unref(&f->refs)) {
     GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, f->master, "subchannel_factory");
     grpc_channel_args_destroy(f->merge_args);
-    grpc_mdctx_unref(f->mdctx);
     gpr_free(f);
   }
 }
@@ -162,10 +157,7 @@ static grpc_subchannel *subchannel_factory_create_subchannel(
   grpc_subchannel *s;
   memset(c, 0, sizeof(*c));
   c->base.vtable = &connector_vtable;
-  c->mdctx = f->mdctx;
-  grpc_mdctx_ref(c->mdctx);
   gpr_ref_init(&c->refs, 1);
-  args->mdctx = f->mdctx;
   args->args = final_args;
   args->master = f->master;
   s = grpc_subchannel_create(&c->base, args);
@@ -188,22 +180,19 @@ grpc_channel *channel_create(const char *target, const grpc_channel_args *args,
   const grpc_channel_filter *filters[MAX_FILTERS];
   grpc_resolver *resolver;
   subchannel_factory *f;
-  grpc_mdctx *mdctx = grpc_mdctx_create();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   size_t n = 0;
 
   filters[n++] = &grpc_client_channel_filter;
   GPR_ASSERT(n <= MAX_FILTERS);
 
-  channel = grpc_channel_create_from_filters(&exec_ctx, target, filters, n,
-                                             args, mdctx, 1);
+  channel =
+      grpc_channel_create_from_filters(&exec_ctx, target, filters, n, args, 1);
 
   f = gpr_malloc(sizeof(*f));
   f->sniffed_subchannel = sniffed_subchannel;
   f->base.vtable = &test_subchannel_factory_vtable;
   gpr_ref_init(&f->refs, 1);
-  grpc_mdctx_ref(mdctx);
-  f->mdctx = mdctx;
   f->merge_args = grpc_channel_args_copy(args);
   f->master = channel;
   GRPC_CHANNEL_INTERNAL_REF(f->master, "test_subchannel_factory");
diff --git a/test/core/transport/chttp2/hpack_encoder_test.c b/test/core/transport/chttp2/hpack_encoder_test.c
index 6553e0da20..64ea1e3f14 100644
--- a/test/core/transport/chttp2/hpack_encoder_test.c
+++ b/test/core/transport/chttp2/hpack_encoder_test.c
@@ -46,7 +46,6 @@
 
 #define TEST(x) run_test(x, #x)
 
-grpc_mdctx *g_mdctx;
 grpc_chttp2_hpack_compressor g_compressor;
 int g_failure = 0;
 
@@ -76,7 +75,7 @@ static void verify(size_t window_available, int eof, size_t expect_window_used,
       e[i - 1].next = &e[i];
       e[i].prev = &e[i - 1];
     }
-    e[i].md = grpc_mdelem_from_strings(g_mdctx, key, value);
+    e[i].md = grpc_mdelem_from_strings(key, value);
   }
   e[0].prev = NULL;
   e[nheaders - 1].next = NULL;
@@ -181,18 +180,18 @@ static void test_decode_table_overflow(void) {
 
 static void run_test(void (*test)(), const char *name) {
   gpr_log(GPR_INFO, "RUN TEST: %s", name);
-  g_mdctx = grpc_mdctx_create_with_seed(0);
-  grpc_chttp2_hpack_compressor_init(&g_compressor, g_mdctx);
+  grpc_chttp2_hpack_compressor_init(&g_compressor);
   test();
   grpc_chttp2_hpack_compressor_destroy(&g_compressor);
-  grpc_mdctx_unref(g_mdctx);
 }
 
 int main(int argc, char **argv) {
   size_t i;
   grpc_test_init(argc, argv);
+  grpc_init();
   TEST(test_basic_headers);
   TEST(test_decode_table_overflow);
+  grpc_shutdown();
   for (i = 0; i < num_to_delete; i++) {
     gpr_free(to_delete[i]);
   }
diff --git a/test/core/transport/chttp2/hpack_parser_test.c b/test/core/transport/chttp2/hpack_parser_test.c
index c6b35fba79..4456e197af 100644
--- a/test/core/transport/chttp2/hpack_parser_test.c
+++ b/test/core/transport/chttp2/hpack_parser_test.c
@@ -35,6 +35,7 @@
 
 #include <stdarg.h>
 
+#include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/slice.h>
@@ -90,9 +91,8 @@ static void test_vector(grpc_chttp2_hpack_parser *parser,
 
 static void test_vectors(grpc_slice_split_mode mode) {
   grpc_chttp2_hpack_parser parser;
-  grpc_mdctx *mdctx = grpc_mdctx_create();
 
-  grpc_chttp2_hpack_parser_init(&parser, mdctx);
+  grpc_chttp2_hpack_parser_init(&parser);
   /* D.2.1 */
   test_vector(&parser, mode,
               "400a 6375 7374 6f6d 2d6b 6579 0d63 7573"
@@ -110,7 +110,7 @@ static void test_vectors(grpc_slice_split_mode mode) {
   test_vector(&parser, mode, "82", ":method", "GET", NULL);
   grpc_chttp2_hpack_parser_destroy(&parser);
 
-  grpc_chttp2_hpack_parser_init(&parser, mdctx);
+  grpc_chttp2_hpack_parser_init(&parser);
   /* D.3.1 */
   test_vector(&parser, mode,
               "8286 8441 0f77 7777 2e65 7861 6d70 6c65"
@@ -130,7 +130,7 @@ static void test_vectors(grpc_slice_split_mode mode) {
               NULL);
   grpc_chttp2_hpack_parser_destroy(&parser);
 
-  grpc_chttp2_hpack_parser_init(&parser, mdctx);
+  grpc_chttp2_hpack_parser_init(&parser);
   /* D.4.1 */
   test_vector(&parser, mode,
               "8286 8441 8cf1 e3c2 e5f2 3a6b a0ab 90f4"
@@ -150,7 +150,7 @@ static void test_vectors(grpc_slice_split_mode mode) {
               NULL);
   grpc_chttp2_hpack_parser_destroy(&parser);
 
-  grpc_chttp2_hpack_parser_init(&parser, mdctx);
+  grpc_chttp2_hpack_parser_init(&parser);
   grpc_chttp2_hptbl_set_max_bytes(&parser.table, 256);
   grpc_chttp2_hptbl_set_current_table_size(&parser.table, 256);
   /* D.5.1 */
@@ -184,7 +184,7 @@ static void test_vectors(grpc_slice_split_mode mode) {
               "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1", NULL);
   grpc_chttp2_hpack_parser_destroy(&parser);
 
-  grpc_chttp2_hpack_parser_init(&parser, mdctx);
+  grpc_chttp2_hpack_parser_init(&parser);
   grpc_chttp2_hptbl_set_max_bytes(&parser.table, 256);
   grpc_chttp2_hptbl_set_current_table_size(&parser.table, 256);
   /* D.6.1 */
@@ -214,12 +214,13 @@ static void test_vectors(grpc_slice_split_mode mode) {
               "set-cookie",
               "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1", NULL);
   grpc_chttp2_hpack_parser_destroy(&parser);
-  grpc_mdctx_unref(mdctx);
 }
 
 int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
+  grpc_init();
   test_vectors(GRPC_SLICE_SPLIT_MERGE_ALL);
   test_vectors(GRPC_SLICE_SPLIT_ONE_BYTE);
+  grpc_shutdown();
   return 0;
 }
diff --git a/test/core/transport/chttp2/hpack_table_test.c b/test/core/transport/chttp2/hpack_table_test.c
index 5eb52d6d9a..50496a305d 100644
--- a/test/core/transport/chttp2/hpack_table_test.c
+++ b/test/core/transport/chttp2/hpack_table_test.c
@@ -36,10 +36,12 @@
 #include <string.h>
 #include <stdio.h>
 
-#include "src/core/support/string.h"
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
+#include <grpc/grpc.h>
+
+#include "src/core/support/string.h"
 #include "test/core/util/test_config.h"
 
 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
@@ -58,10 +60,8 @@ static void assert_index(const grpc_chttp2_hptbl *tbl, gpr_uint32 idx,
 
 static void test_static_lookup(void) {
   grpc_chttp2_hptbl tbl;
-  grpc_mdctx *mdctx;
 
-  mdctx = grpc_mdctx_create();
-  grpc_chttp2_hptbl_init(&tbl, mdctx);
+  grpc_chttp2_hptbl_init(&tbl);
 
   LOG_TEST("test_static_lookup");
   assert_index(&tbl, 1, ":authority", "");
@@ -127,7 +127,6 @@ static void test_static_lookup(void) {
   assert_index(&tbl, 61, "www-authenticate", "");
 
   grpc_chttp2_hptbl_destroy(&tbl);
-  grpc_mdctx_unref(mdctx);
 }
 
 static void test_many_additions(void) {
@@ -135,18 +134,16 @@ static void test_many_additions(void) {
   int i;
   char *key;
   char *value;
-  grpc_mdctx *mdctx;
 
   LOG_TEST("test_many_additions");
 
-  mdctx = grpc_mdctx_create();
-  grpc_chttp2_hptbl_init(&tbl, mdctx);
+  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(mdctx, key, value);
+    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);
@@ -162,13 +159,12 @@ static void test_many_additions(void) {
   }
 
   grpc_chttp2_hptbl_destroy(&tbl);
-  grpc_mdctx_unref(mdctx);
 }
 
 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(tbl->mdctx, key, 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;
@@ -178,21 +174,19 @@ static void test_find(void) {
   grpc_chttp2_hptbl tbl;
   gpr_uint32 i;
   char buffer[32];
-  grpc_mdctx *mdctx;
   grpc_mdelem *elem;
   grpc_chttp2_hptbl_find_result r;
 
   LOG_TEST("test_find");
 
-  mdctx = grpc_mdctx_create();
-  grpc_chttp2_hptbl_init(&tbl, mdctx);
-  elem = grpc_mdelem_from_strings(mdctx, "abc", "xyz");
+  grpc_chttp2_hptbl_init(&tbl);
+  elem = grpc_mdelem_from_strings("abc", "xyz");
   GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem));
   GRPC_MDELEM_UNREF(elem);
-  elem = grpc_mdelem_from_strings(mdctx, "abc", "123");
+  elem = grpc_mdelem_from_strings("abc", "123");
   GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem));
   GRPC_MDELEM_UNREF(elem);
-  elem = grpc_mdelem_from_strings(mdctx, "x", "1");
+  elem = grpc_mdelem_from_strings("x", "1");
   GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem));
   GRPC_MDELEM_UNREF(elem);
 
@@ -243,7 +237,7 @@ static void test_find(void) {
   /* overflow the string buffer, check find still works */
   for (i = 0; i < 10000; i++) {
     gpr_ltoa(i, buffer);
-    elem = grpc_mdelem_from_strings(mdctx, "test", buffer);
+    elem = grpc_mdelem_from_strings("test", buffer);
     GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem));
     GRPC_MDELEM_UNREF(elem);
   }
@@ -274,13 +268,14 @@ static void test_find(void) {
   GPR_ASSERT(r.has_value == 0);
 
   grpc_chttp2_hptbl_destroy(&tbl);
-  grpc_mdctx_unref(mdctx);
 }
 
 int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
+  grpc_init();
   test_static_lookup();
   test_many_additions();
   test_find();
+  grpc_shutdown();
   return 0;
 }
diff --git a/test/core/transport/metadata_test.c b/test/core/transport/metadata_test.c
index 080e86cb63..9c1eae9552 100644
--- a/test/core/transport/metadata_test.c
+++ b/test/core/transport/metadata_test.c
@@ -35,11 +35,13 @@
 
 #include <stdio.h>
 
-#include "src/core/support/string.h"
-#include "src/core/transport/chttp2/bin_encoder.h"
+#include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
+
+#include "src/core/support/string.h"
+#include "src/core/transport/chttp2/bin_encoder.h"
 #include "test/core/util/test_config.h"
 
 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
@@ -48,44 +50,39 @@
 #define MANY 10000
 
 static void test_no_op(void) {
-  grpc_mdctx *ctx;
-
   LOG_TEST("test_no_op");
-
-  ctx = grpc_mdctx_create();
-  grpc_mdctx_unref(ctx);
+  grpc_init();
+  grpc_shutdown();
 }
 
 static void test_create_string(void) {
-  grpc_mdctx *ctx;
   grpc_mdstr *s1, *s2, *s3;
 
   LOG_TEST("test_create_string");
 
-  ctx = grpc_mdctx_create();
-  s1 = grpc_mdstr_from_string(ctx, "hello");
-  s2 = grpc_mdstr_from_string(ctx, "hello");
-  s3 = grpc_mdstr_from_string(ctx, "very much not hello");
+  grpc_init();
+  s1 = grpc_mdstr_from_string("hello");
+  s2 = grpc_mdstr_from_string("hello");
+  s3 = grpc_mdstr_from_string("very much not hello");
   GPR_ASSERT(s1 == s2);
   GPR_ASSERT(s3 != s1);
   GPR_ASSERT(gpr_slice_str_cmp(s1->slice, "hello") == 0);
   GPR_ASSERT(gpr_slice_str_cmp(s3->slice, "very much not hello") == 0);
   GRPC_MDSTR_UNREF(s1);
   GRPC_MDSTR_UNREF(s2);
-  grpc_mdctx_unref(ctx);
   GRPC_MDSTR_UNREF(s3);
+  grpc_shutdown();
 }
 
 static void test_create_metadata(void) {
-  grpc_mdctx *ctx;
   grpc_mdelem *m1, *m2, *m3;
 
   LOG_TEST("test_create_metadata");
 
-  ctx = grpc_mdctx_create();
-  m1 = grpc_mdelem_from_strings(ctx, "a", "b");
-  m2 = grpc_mdelem_from_strings(ctx, "a", "b");
-  m3 = grpc_mdelem_from_strings(ctx, "a", "c");
+  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);
@@ -96,32 +93,25 @@ static void test_create_metadata(void) {
   GRPC_MDELEM_UNREF(m1);
   GRPC_MDELEM_UNREF(m2);
   GRPC_MDELEM_UNREF(m3);
-  grpc_mdctx_unref(ctx);
+  grpc_shutdown();
 }
 
 static void test_create_many_ephemeral_metadata(void) {
-  grpc_mdctx *ctx;
   char buffer[GPR_LTOA_MIN_BUFSIZE];
   long i;
-  size_t mdtab_capacity_before;
 
   LOG_TEST("test_create_many_ephemeral_metadata");
 
-  ctx = grpc_mdctx_create();
-  mdtab_capacity_before = grpc_mdctx_get_mdtab_capacity_test_only(ctx);
+  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(ctx, "a", buffer));
+    GRPC_MDELEM_UNREF(grpc_mdelem_from_strings("a", buffer));
   }
-  /* capacity should not grow */
-  GPR_ASSERT(mdtab_capacity_before ==
-             grpc_mdctx_get_mdtab_capacity_test_only(ctx));
-  grpc_mdctx_unref(ctx);
+  grpc_shutdown();
 }
 
 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);
@@ -129,16 +119,16 @@ static void test_create_many_persistant_metadata(void) {
 
   LOG_TEST("test_create_many_persistant_metadata");
 
-  ctx = grpc_mdctx_create();
+  grpc_init();
   /* add phase */
   for (i = 0; i < MANY; i++) {
     gpr_ltoa(i, buffer);
-    created[i] = grpc_mdelem_from_strings(ctx, "a", buffer);
+    created[i] = grpc_mdelem_from_strings("a", buffer);
   }
   /* verify phase */
   for (i = 0; i < MANY; i++) {
     gpr_ltoa(i, buffer);
-    md = grpc_mdelem_from_strings(ctx, "a", buffer);
+    md = grpc_mdelem_from_strings("a", buffer);
     GPR_ASSERT(md == created[i]);
     GRPC_MDELEM_UNREF(md);
   }
@@ -146,37 +136,22 @@ static void test_create_many_persistant_metadata(void) {
   for (i = 0; i < MANY; i++) {
     GRPC_MDELEM_UNREF(created[i]);
   }
-  grpc_mdctx_unref(ctx);
+  grpc_shutdown();
 
   gpr_free(created);
 }
 
 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);
+  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 test_things_stick_around(void) {
-  grpc_mdctx *ctx;
   size_t i, j;
   char *buffer;
   size_t nstrs = 1000;
@@ -186,11 +161,11 @@ static void test_things_stick_around(void) {
 
   LOG_TEST("test_things_stick_around");
 
-  ctx = grpc_mdctx_create();
+  grpc_init();
 
   for (i = 0; i < nstrs; i++) {
     gpr_asprintf(&buffer, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%dx", i);
-    strs[i] = grpc_mdstr_from_string(ctx, buffer);
+    strs[i] = grpc_mdstr_from_string(buffer);
     shuf[i] = i;
     gpr_free(buffer);
   }
@@ -212,60 +187,58 @@ static void test_things_stick_around(void) {
     GRPC_MDSTR_UNREF(strs[shuf[i]]);
     for (j = i + 1; j < nstrs; j++) {
       gpr_asprintf(&buffer, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%dx", shuf[j]);
-      test = grpc_mdstr_from_string(ctx, buffer);
+      test = grpc_mdstr_from_string(buffer);
       GPR_ASSERT(test == strs[shuf[j]]);
       GRPC_MDSTR_UNREF(test);
       gpr_free(buffer);
     }
   }
 
-  grpc_mdctx_unref(ctx);
+  grpc_shutdown();
   gpr_free(strs);
   gpr_free(shuf);
 }
 
 static void test_slices_work(void) {
   /* ensure no memory leaks when switching representation from mdstr to slice */
-  grpc_mdctx *ctx;
   grpc_mdstr *str;
   gpr_slice slice;
 
   LOG_TEST("test_slices_work");
 
-  ctx = grpc_mdctx_create();
+  grpc_init();
 
   str = grpc_mdstr_from_string(
-      ctx, "123456789012345678901234567890123456789012345678901234567890");
+      "123456789012345678901234567890123456789012345678901234567890");
   slice = gpr_slice_ref(str->slice);
   GRPC_MDSTR_UNREF(str);
   gpr_slice_unref(slice);
 
   str = grpc_mdstr_from_string(
-      ctx, "123456789012345678901234567890123456789012345678901234567890");
+      "123456789012345678901234567890123456789012345678901234567890");
   slice = gpr_slice_ref(str->slice);
   gpr_slice_unref(slice);
   GRPC_MDSTR_UNREF(str);
 
-  grpc_mdctx_unref(ctx);
+  grpc_shutdown();
 }
 
 static void test_base64_and_huffman_works(void) {
-  grpc_mdctx *ctx;
   grpc_mdstr *str;
   gpr_slice slice1;
   gpr_slice slice2;
 
   LOG_TEST("test_base64_and_huffman_works");
 
-  ctx = grpc_mdctx_create();
-  str = grpc_mdstr_from_string(ctx, "abcdefg");
+  grpc_init();
+  str = grpc_mdstr_from_string("abcdefg");
   slice1 = grpc_mdstr_as_base64_encoded_and_huffman_compressed(str);
   slice2 = grpc_chttp2_base64_encode_and_huffman_compress(str->slice);
   GPR_ASSERT(0 == gpr_slice_cmp(slice1, slice2));
 
   gpr_slice_unref(slice2);
   GRPC_MDSTR_UNREF(str);
-  grpc_mdctx_unref(ctx);
+  grpc_shutdown();
 }
 
 int main(int argc, char **argv) {