Revert "All instances of exec_ctx being passed around in src/core removed"

14 files changed, 410 insertions, 356 deletions

diff --git a/test/core/transport/bdp_estimator_test.cc b/test/core/transport/bdp_estimator_test.cc
index 445823b628..d1272607f2 100644
--- a/test/core/transport/bdp_estimator_test.cc
+++ b/test/core/transport/bdp_estimator_test.cc
@@ -58,7 +58,7 @@ namespace {
 void AddSamples(BdpEstimator* estimator, int64_t* samples, size_t n) {
   estimator->AddIncomingBytes(1234567);
   inc_time();
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   estimator->SchedulePing();
   estimator->StartPing();
   for (size_t i = 0; i < n; i++) {
@@ -66,8 +66,9 @@ void AddSamples(BdpEstimator* estimator, int64_t* samples, size_t n) {
   }
   gpr_sleep_until(gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
                                gpr_time_from_millis(1, GPR_TIMESPAN)));
-  grpc_core::ExecCtx::Get()->InvalidateNow();
-  estimator->CompletePing();
+  grpc_exec_ctx_invalidate_now(&exec_ctx);
+  estimator->CompletePing(&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 void AddSample(BdpEstimator* estimator, int64_t sample) {
diff --git a/test/core/transport/byte_stream_test.cc b/test/core/transport/byte_stream_test.cc
index 2aab6e9262..0e34fd7651 100644
--- a/test/core/transport/byte_stream_test.cc
+++ b/test/core/transport/byte_stream_test.cc
@@ -18,7 +18,6 @@
 
 #include "src/core/lib/transport/byte_stream.h"
 
-#include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/useful.h>
@@ -31,13 +30,14 @@
 // grpc_slice_buffer_stream tests
 //
 
-static void not_called_closure(void* arg, grpc_error* error) {
+static void not_called_closure(grpc_exec_ctx* exec_ctx, void* arg,
+                               grpc_error* error) {
   GPR_ASSERT(false);
 }
 
 static void test_slice_buffer_stream_basic(void) {
   gpr_log(GPR_DEBUG, "test_slice_buffer_stream_basic");
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   // Create and populate slice buffer.
   grpc_slice_buffer buffer;
   grpc_slice_buffer_init(&buffer);
@@ -57,21 +57,23 @@ static void test_slice_buffer_stream_basic(void) {
                     grpc_schedule_on_exec_ctx);
   // Read each slice.  Note that next() always returns synchronously.
   for (size_t i = 0; i < GPR_ARRAY_SIZE(input); ++i) {
-    GPR_ASSERT(grpc_byte_stream_next(&stream.base, ~(size_t)0, &closure));
+    GPR_ASSERT(
+        grpc_byte_stream_next(&exec_ctx, &stream.base, ~(size_t)0, &closure));
     grpc_slice output;
-    grpc_error* error = grpc_byte_stream_pull(&stream.base, &output);
+    grpc_error* error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
     GPR_ASSERT(error == GRPC_ERROR_NONE);
     GPR_ASSERT(grpc_slice_eq(input[i], output));
-    grpc_slice_unref_internal(output);
+    grpc_slice_unref_internal(&exec_ctx, output);
   }
   // Clean up.
-  grpc_byte_stream_destroy(&stream.base);
-  grpc_slice_buffer_destroy_internal(&buffer);
+  grpc_byte_stream_destroy(&exec_ctx, &stream.base);
+  grpc_slice_buffer_destroy_internal(&exec_ctx, &buffer);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_slice_buffer_stream_shutdown(void) {
   gpr_log(GPR_DEBUG, "test_slice_buffer_stream_shutdown");
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   // Create and populate slice buffer.
   grpc_slice_buffer buffer;
   grpc_slice_buffer_init(&buffer);
@@ -90,25 +92,29 @@ static void test_slice_buffer_stream_shutdown(void) {
   GRPC_CLOSURE_INIT(&closure, not_called_closure, nullptr,
                     grpc_schedule_on_exec_ctx);
   // Read the first slice.
-  GPR_ASSERT(grpc_byte_stream_next(&stream.base, ~(size_t)0, &closure));
+  GPR_ASSERT(
+      grpc_byte_stream_next(&exec_ctx, &stream.base, ~(size_t)0, &closure));
   grpc_slice output;
-  grpc_error* error = grpc_byte_stream_pull(&stream.base, &output);
+  grpc_error* error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(grpc_slice_eq(input[0], output));
-  grpc_slice_unref_internal(output);
+  grpc_slice_unref_internal(&exec_ctx, output);
   // Now shutdown.
   grpc_error* shutdown_error =
       GRPC_ERROR_CREATE_FROM_STATIC_STRING("shutdown error");
-  grpc_byte_stream_shutdown(&stream.base, GRPC_ERROR_REF(shutdown_error));
+  grpc_byte_stream_shutdown(&exec_ctx, &stream.base,
+                            GRPC_ERROR_REF(shutdown_error));
   // After shutdown, the next pull() should return the error.
-  GPR_ASSERT(grpc_byte_stream_next(&stream.base, ~(size_t)0, &closure));
-  error = grpc_byte_stream_pull(&stream.base, &output);
+  GPR_ASSERT(
+      grpc_byte_stream_next(&exec_ctx, &stream.base, ~(size_t)0, &closure));
+  error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
   GPR_ASSERT(error == shutdown_error);
   GRPC_ERROR_UNREF(error);
   GRPC_ERROR_UNREF(shutdown_error);
   // Clean up.
-  grpc_byte_stream_destroy(&stream.base);
-  grpc_slice_buffer_destroy_internal(&buffer);
+  grpc_byte_stream_destroy(&exec_ctx, &stream.base);
+  grpc_slice_buffer_destroy_internal(&exec_ctx, &buffer);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 //
@@ -117,7 +123,7 @@ static void test_slice_buffer_stream_shutdown(void) {
 
 static void test_caching_byte_stream_basic(void) {
   gpr_log(GPR_DEBUG, "test_caching_byte_stream_basic");
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   // Create and populate slice buffer byte stream.
   grpc_slice_buffer buffer;
   grpc_slice_buffer_init(&buffer);
@@ -141,22 +147,24 @@ static void test_caching_byte_stream_basic(void) {
   // Read each slice.  Note that next() always returns synchronously,
   // because the underlying byte stream always does.
   for (size_t i = 0; i < GPR_ARRAY_SIZE(input); ++i) {
-    GPR_ASSERT(grpc_byte_stream_next(&stream.base, ~(size_t)0, &closure));
+    GPR_ASSERT(
+        grpc_byte_stream_next(&exec_ctx, &stream.base, ~(size_t)0, &closure));
     grpc_slice output;
-    grpc_error* error = grpc_byte_stream_pull(&stream.base, &output);
+    grpc_error* error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
     GPR_ASSERT(error == GRPC_ERROR_NONE);
     GPR_ASSERT(grpc_slice_eq(input[i], output));
-    grpc_slice_unref_internal(output);
+    grpc_slice_unref_internal(&exec_ctx, output);
   }
   // Clean up.
-  grpc_byte_stream_destroy(&stream.base);
-  grpc_byte_stream_cache_destroy(&cache);
-  grpc_slice_buffer_destroy_internal(&buffer);
+  grpc_byte_stream_destroy(&exec_ctx, &stream.base);
+  grpc_byte_stream_cache_destroy(&exec_ctx, &cache);
+  grpc_slice_buffer_destroy_internal(&exec_ctx, &buffer);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_caching_byte_stream_reset(void) {
   gpr_log(GPR_DEBUG, "test_caching_byte_stream_reset");
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   // Create and populate slice buffer byte stream.
   grpc_slice_buffer buffer;
   grpc_slice_buffer_init(&buffer);
@@ -178,31 +186,34 @@ static void test_caching_byte_stream_reset(void) {
   GRPC_CLOSURE_INIT(&closure, not_called_closure, nullptr,
                     grpc_schedule_on_exec_ctx);
   // Read one slice.
-  GPR_ASSERT(grpc_byte_stream_next(&stream.base, ~(size_t)0, &closure));
+  GPR_ASSERT(
+      grpc_byte_stream_next(&exec_ctx, &stream.base, ~(size_t)0, &closure));
   grpc_slice output;
-  grpc_error* error = grpc_byte_stream_pull(&stream.base, &output);
+  grpc_error* error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(grpc_slice_eq(input[0], output));
-  grpc_slice_unref_internal(output);
+  grpc_slice_unref_internal(&exec_ctx, output);
   // Reset the caching stream.  The reads should start over from the
   // first slice.
   grpc_caching_byte_stream_reset(&stream);
   for (size_t i = 0; i < GPR_ARRAY_SIZE(input); ++i) {
-    GPR_ASSERT(grpc_byte_stream_next(&stream.base, ~(size_t)0, &closure));
-    error = grpc_byte_stream_pull(&stream.base, &output);
+    GPR_ASSERT(
+        grpc_byte_stream_next(&exec_ctx, &stream.base, ~(size_t)0, &closure));
+    error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
     GPR_ASSERT(error == GRPC_ERROR_NONE);
     GPR_ASSERT(grpc_slice_eq(input[i], output));
-    grpc_slice_unref_internal(output);
+    grpc_slice_unref_internal(&exec_ctx, output);
   }
   // Clean up.
-  grpc_byte_stream_destroy(&stream.base);
-  grpc_byte_stream_cache_destroy(&cache);
-  grpc_slice_buffer_destroy_internal(&buffer);
+  grpc_byte_stream_destroy(&exec_ctx, &stream.base);
+  grpc_byte_stream_cache_destroy(&exec_ctx, &cache);
+  grpc_slice_buffer_destroy_internal(&exec_ctx, &buffer);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_caching_byte_stream_shared_cache(void) {
   gpr_log(GPR_DEBUG, "test_caching_byte_stream_shared_cache");
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   // Create and populate slice buffer byte stream.
   grpc_slice_buffer buffer;
   grpc_slice_buffer_init(&buffer);
@@ -226,41 +237,43 @@ static void test_caching_byte_stream_shared_cache(void) {
   GRPC_CLOSURE_INIT(&closure, not_called_closure, nullptr,
                     grpc_schedule_on_exec_ctx);
   // Read one slice from stream1.
-  GPR_ASSERT(grpc_byte_stream_next(&stream1.base, ~(size_t)0, &closure));
+  GPR_ASSERT(
+      grpc_byte_stream_next(&exec_ctx, &stream1.base, ~(size_t)0, &closure));
   grpc_slice output;
-  grpc_error* error = grpc_byte_stream_pull(&stream1.base, &output);
+  grpc_error* error = grpc_byte_stream_pull(&exec_ctx, &stream1.base, &output);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(grpc_slice_eq(input[0], output));
-  grpc_slice_unref_internal(output);
+  grpc_slice_unref_internal(&exec_ctx, output);
   // Read all slices from stream2.
   for (size_t i = 0; i < GPR_ARRAY_SIZE(input); ++i) {
-    GPR_ASSERT(grpc_byte_stream_next(&stream2.base, ~(size_t)0, &closure));
-    error = grpc_byte_stream_pull(&stream2.base, &output);
+    GPR_ASSERT(
+        grpc_byte_stream_next(&exec_ctx, &stream2.base, ~(size_t)0, &closure));
+    error = grpc_byte_stream_pull(&exec_ctx, &stream2.base, &output);
     GPR_ASSERT(error == GRPC_ERROR_NONE);
     GPR_ASSERT(grpc_slice_eq(input[i], output));
-    grpc_slice_unref_internal(output);
+    grpc_slice_unref_internal(&exec_ctx, output);
   }
   // Now read the second slice from stream1.
-  GPR_ASSERT(grpc_byte_stream_next(&stream1.base, ~(size_t)0, &closure));
-  error = grpc_byte_stream_pull(&stream1.base, &output);
+  GPR_ASSERT(
+      grpc_byte_stream_next(&exec_ctx, &stream1.base, ~(size_t)0, &closure));
+  error = grpc_byte_stream_pull(&exec_ctx, &stream1.base, &output);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(grpc_slice_eq(input[1], output));
-  grpc_slice_unref_internal(output);
+  grpc_slice_unref_internal(&exec_ctx, output);
   // Clean up.
-  grpc_byte_stream_destroy(&stream1.base);
-  grpc_byte_stream_destroy(&stream2.base);
-  grpc_byte_stream_cache_destroy(&cache);
-  grpc_slice_buffer_destroy_internal(&buffer);
+  grpc_byte_stream_destroy(&exec_ctx, &stream1.base);
+  grpc_byte_stream_destroy(&exec_ctx, &stream2.base);
+  grpc_byte_stream_cache_destroy(&exec_ctx, &cache);
+  grpc_slice_buffer_destroy_internal(&exec_ctx, &buffer);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 int main(int argc, char** argv) {
-  grpc_init();
   grpc_test_init(argc, argv);
   test_slice_buffer_stream_basic();
   test_slice_buffer_stream_shutdown();
   test_caching_byte_stream_basic();
   test_caching_byte_stream_reset();
   test_caching_byte_stream_shared_cache();
-  grpc_shutdown();
   return 0;
 }
diff --git a/test/core/transport/chttp2/bin_decoder_test.cc b/test/core/transport/chttp2/bin_decoder_test.cc
index 6d70a4261b..a29ec8a13f 100644
--- a/test/core/transport/chttp2/bin_decoder_test.cc
+++ b/test/core/transport/chttp2/bin_decoder_test.cc
@@ -20,7 +20,6 @@
 
 #include <string.h>
 
-#include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include "src/core/ext/transport/chttp2/transport/bin_encoder.h"
@@ -30,8 +29,8 @@
 
 static int all_ok = 1;
 
-static void expect_slice_eq(grpc_slice expected, grpc_slice slice,
-                            const char* debug, int line) {
+static void expect_slice_eq(grpc_exec_ctx* exec_ctx, grpc_slice expected,
+                            grpc_slice slice, const char* debug, int line) {
   if (!grpc_slice_eq(slice, expected)) {
     char* hs = grpc_dump_slice(slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
     char* he = grpc_dump_slice(expected, GPR_DUMP_HEX | GPR_DUMP_ASCII);
@@ -41,97 +40,104 @@ static void expect_slice_eq(grpc_slice expected, grpc_slice slice,
     gpr_free(he);
     all_ok = 0;
   }
-  grpc_slice_unref_internal(expected);
-  grpc_slice_unref_internal(slice);
+  grpc_slice_unref_internal(exec_ctx, expected);
+  grpc_slice_unref_internal(exec_ctx, slice);
 }
 
-static grpc_slice base64_encode(const char* s) {
+static grpc_slice base64_encode(grpc_exec_ctx* exec_ctx, const char* s) {
   grpc_slice ss = grpc_slice_from_copied_string(s);
   grpc_slice out = grpc_chttp2_base64_encode(ss);
-  grpc_slice_unref_internal(ss);
+  grpc_slice_unref_internal(exec_ctx, ss);
   return out;
 }
 
-static grpc_slice base64_decode(const char* s) {
+static grpc_slice base64_decode(grpc_exec_ctx* exec_ctx, const char* s) {
   grpc_slice ss = grpc_slice_from_copied_string(s);
-  grpc_slice out = grpc_chttp2_base64_decode(ss);
-  grpc_slice_unref_internal(ss);
+  grpc_slice out = grpc_chttp2_base64_decode(exec_ctx, ss);
+  grpc_slice_unref_internal(exec_ctx, ss);
   return out;
 }
 
-static grpc_slice base64_decode_with_length(const char* s,
+static grpc_slice base64_decode_with_length(grpc_exec_ctx* exec_ctx,
+                                            const char* s,
                                             size_t output_length) {
   grpc_slice ss = grpc_slice_from_copied_string(s);
-  grpc_slice out = grpc_chttp2_base64_decode_with_length(ss, output_length);
-  grpc_slice_unref_internal(ss);
+  grpc_slice out =
+      grpc_chttp2_base64_decode_with_length(exec_ctx, ss, output_length);
+  grpc_slice_unref_internal(exec_ctx, ss);
   return out;
 }
 
-#define EXPECT_SLICE_EQ(expected, slice)                                    \
-  expect_slice_eq(                                                          \
-      grpc_slice_from_copied_buffer(expected, sizeof(expected) - 1), slice, \
-      #slice, __LINE__);
+#define EXPECT_SLICE_EQ(exec_ctx, expected, slice)                             \
+  expect_slice_eq(                                                             \
+      exec_ctx, grpc_slice_from_copied_buffer(expected, sizeof(expected) - 1), \
+      slice, #slice, __LINE__);
 
-#define ENCODE_AND_DECODE(s) \
-  EXPECT_SLICE_EQ(           \
-      s, grpc_chttp2_base64_decode_with_length(base64_encode(s), strlen(s)));
+#define ENCODE_AND_DECODE(exec_ctx, s)                   \
+  EXPECT_SLICE_EQ(exec_ctx, s,                           \
+                  grpc_chttp2_base64_decode_with_length( \
+                      exec_ctx, base64_encode(exec_ctx, s), strlen(s)));
 
 int main(int argc, char** argv) {
-  grpc_init();
-  {
-    grpc_core::ExecCtx exec_ctx;
-
-    /* ENCODE_AND_DECODE tests grpc_chttp2_base64_decode_with_length(), which
-       takes encoded base64 strings without pad chars, but output length is
-       required. */
-    /* Base64 test vectors from RFC 4648 */
-    ENCODE_AND_DECODE("");
-    ENCODE_AND_DECODE("f");
-    ENCODE_AND_DECODE("foo");
-    ENCODE_AND_DECODE("fo");
-    ENCODE_AND_DECODE("foob");
-    ENCODE_AND_DECODE("fooba");
-    ENCODE_AND_DECODE("foobar");
-
-    ENCODE_AND_DECODE("\xc0\xc1\xc2\xc3\xc4\xc5");
-
-    /* Base64 test vectors from RFC 4648, with pad chars */
-    /* BASE64("") = "" */
-    EXPECT_SLICE_EQ("", base64_decode(""));
-    /* BASE64("f") = "Zg==" */
-    EXPECT_SLICE_EQ("f", base64_decode("Zg=="));
-    /* BASE64("fo") = "Zm8=" */
-    EXPECT_SLICE_EQ("fo", base64_decode("Zm8="));
-    /* BASE64("foo") = "Zm9v" */
-    EXPECT_SLICE_EQ("foo", base64_decode("Zm9v"));
-    /* BASE64("foob") = "Zm9vYg==" */
-    EXPECT_SLICE_EQ("foob", base64_decode("Zm9vYg=="));
-    /* BASE64("fooba") = "Zm9vYmE=" */
-    EXPECT_SLICE_EQ("fooba", base64_decode("Zm9vYmE="));
-    /* BASE64("foobar") = "Zm9vYmFy" */
-    EXPECT_SLICE_EQ("foobar", base64_decode("Zm9vYmFy"));
-
-    EXPECT_SLICE_EQ("\xc0\xc1\xc2\xc3\xc4\xc5", base64_decode("wMHCw8TF"));
-
-    // Test illegal input length in grpc_chttp2_base64_decode
-    EXPECT_SLICE_EQ("", base64_decode("a"));
-    EXPECT_SLICE_EQ("", base64_decode("ab"));
-    EXPECT_SLICE_EQ("", base64_decode("abc"));
-
-    // Test illegal charactors in grpc_chttp2_base64_decode
-    EXPECT_SLICE_EQ("", base64_decode("Zm:v"));
-    EXPECT_SLICE_EQ("", base64_decode("Zm=v"));
-
-    // Test output_length longer than max possible output length in
-    // grpc_chttp2_base64_decode_with_length
-    EXPECT_SLICE_EQ("", base64_decode_with_length("Zg", 2));
-    EXPECT_SLICE_EQ("", base64_decode_with_length("Zm8", 3));
-    EXPECT_SLICE_EQ("", base64_decode_with_length("Zm9v", 4));
-
-    // Test illegal charactors in grpc_chttp2_base64_decode_with_length
-    EXPECT_SLICE_EQ("", base64_decode_with_length("Zm:v", 3));
-    EXPECT_SLICE_EQ("", base64_decode_with_length("Zm=v", 3));
-  }
-  grpc_shutdown();
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+
+  /* ENCODE_AND_DECODE tests grpc_chttp2_base64_decode_with_length(), which
+     takes encoded base64 strings without pad chars, but output length is
+     required. */
+  /* Base64 test vectors from RFC 4648 */
+  ENCODE_AND_DECODE(&exec_ctx, "");
+  ENCODE_AND_DECODE(&exec_ctx, "f");
+  ENCODE_AND_DECODE(&exec_ctx, "foo");
+  ENCODE_AND_DECODE(&exec_ctx, "fo");
+  ENCODE_AND_DECODE(&exec_ctx, "foob");
+  ENCODE_AND_DECODE(&exec_ctx, "fooba");
+  ENCODE_AND_DECODE(&exec_ctx, "foobar");
+
+  ENCODE_AND_DECODE(&exec_ctx, "\xc0\xc1\xc2\xc3\xc4\xc5");
+
+  /* Base64 test vectors from RFC 4648, with pad chars */
+  /* BASE64("") = "" */
+  EXPECT_SLICE_EQ(&exec_ctx, "", base64_decode(&exec_ctx, ""));
+  /* BASE64("f") = "Zg==" */
+  EXPECT_SLICE_EQ(&exec_ctx, "f", base64_decode(&exec_ctx, "Zg=="));
+  /* BASE64("fo") = "Zm8=" */
+  EXPECT_SLICE_EQ(&exec_ctx, "fo", base64_decode(&exec_ctx, "Zm8="));
+  /* BASE64("foo") = "Zm9v" */
+  EXPECT_SLICE_EQ(&exec_ctx, "foo", base64_decode(&exec_ctx, "Zm9v"));
+  /* BASE64("foob") = "Zm9vYg==" */
+  EXPECT_SLICE_EQ(&exec_ctx, "foob", base64_decode(&exec_ctx, "Zm9vYg=="));
+  /* BASE64("fooba") = "Zm9vYmE=" */
+  EXPECT_SLICE_EQ(&exec_ctx, "fooba", base64_decode(&exec_ctx, "Zm9vYmE="));
+  /* BASE64("foobar") = "Zm9vYmFy" */
+  EXPECT_SLICE_EQ(&exec_ctx, "foobar", base64_decode(&exec_ctx, "Zm9vYmFy"));
+
+  EXPECT_SLICE_EQ(&exec_ctx, "\xc0\xc1\xc2\xc3\xc4\xc5",
+                  base64_decode(&exec_ctx, "wMHCw8TF"));
+
+  // Test illegal input length in grpc_chttp2_base64_decode
+  EXPECT_SLICE_EQ(&exec_ctx, "", base64_decode(&exec_ctx, "a"));
+  EXPECT_SLICE_EQ(&exec_ctx, "", base64_decode(&exec_ctx, "ab"));
+  EXPECT_SLICE_EQ(&exec_ctx, "", base64_decode(&exec_ctx, "abc"));
+
+  // Test illegal charactors in grpc_chttp2_base64_decode
+  EXPECT_SLICE_EQ(&exec_ctx, "", base64_decode(&exec_ctx, "Zm:v"));
+  EXPECT_SLICE_EQ(&exec_ctx, "", base64_decode(&exec_ctx, "Zm=v"));
+
+  // Test output_length longer than max possible output length in
+  // grpc_chttp2_base64_decode_with_length
+  EXPECT_SLICE_EQ(&exec_ctx, "", base64_decode_with_length(&exec_ctx, "Zg", 2));
+  EXPECT_SLICE_EQ(&exec_ctx, "",
+                  base64_decode_with_length(&exec_ctx, "Zm8", 3));
+  EXPECT_SLICE_EQ(&exec_ctx, "",
+                  base64_decode_with_length(&exec_ctx, "Zm9v", 4));
+
+  // Test illegal charactors in grpc_chttp2_base64_decode_with_length
+  EXPECT_SLICE_EQ(&exec_ctx, "",
+                  base64_decode_with_length(&exec_ctx, "Zm:v", 3));
+  EXPECT_SLICE_EQ(&exec_ctx, "",
+                  base64_decode_with_length(&exec_ctx, "Zm=v", 3));
+
+  grpc_exec_ctx_finish(&exec_ctx);
+
   return all_ok ? 0 : 1;
 }
diff --git a/test/core/transport/chttp2/bin_encoder_test.cc b/test/core/transport/chttp2/bin_encoder_test.cc
index 44f5de8a50..78b8808c41 100644
--- a/test/core/transport/chttp2/bin_encoder_test.cc
+++ b/test/core/transport/chttp2/bin_encoder_test.cc
@@ -99,8 +99,6 @@ static void expect_binary_header(const char* hdr, int binary) {
 }
 
 int main(int argc, char** argv) {
-  grpc_init();
-
   /* Base64 test vectors from RFC 4648, with padding removed */
   /* BASE64("") = "" */
   EXPECT_SLICE_EQ("", B64(""));
@@ -171,6 +169,5 @@ int main(int argc, char** argv) {
   expect_binary_header("foo-bar", 0);
   expect_binary_header("-bin", 0);
 
-  grpc_shutdown();
   return all_ok ? 0 : 1;
 }
diff --git a/test/core/transport/chttp2/hpack_encoder_test.cc b/test/core/transport/chttp2/hpack_encoder_test.cc
index d2dbd4a798..2d18b72504 100644
--- a/test/core/transport/chttp2/hpack_encoder_test.cc
+++ b/test/core/transport/chttp2/hpack_encoder_test.cc
@@ -51,8 +51,8 @@ typedef struct {
 
 /* verify that the output generated by encoding the stream matches the
    hexstring passed in */
-static void verify(const verify_params params, const char* expected,
-                   size_t nheaders, ...) {
+static void verify(grpc_exec_ctx* exec_ctx, const verify_params params,
+                   const char* expected, size_t nheaders, ...) {
   grpc_slice_buffer output;
   grpc_slice merged;
   grpc_slice expect = parse_hexstring(expected);
@@ -77,7 +77,8 @@ static void verify(const verify_params params, const char* expected,
       value_slice = grpc_slice_intern(value_slice);
     }
     e[i].md = grpc_mdelem_from_slices(
-        grpc_slice_intern(grpc_slice_from_static_string(key)), value_slice);
+        exec_ctx, grpc_slice_intern(grpc_slice_from_static_string(key)),
+        value_slice);
   }
   e[0].prev = nullptr;
   e[nheaders - 1].next = nullptr;
@@ -105,10 +106,11 @@ static void verify(const verify_params params, const char* expected,
       16384,                           /* max_frame_size */
       &stats                           /* stats */
   };
-  grpc_chttp2_encode_header(&g_compressor, nullptr, 0, &b, &hopt, &output);
+  grpc_chttp2_encode_header(exec_ctx, &g_compressor, nullptr, 0, &b, &hopt,
+                            &output);
   merged = grpc_slice_merge(output.slices, output.count);
-  grpc_slice_buffer_destroy_internal(&output);
-  grpc_metadata_batch_destroy(&b);
+  grpc_slice_buffer_destroy_internal(exec_ctx, &output);
+  grpc_metadata_batch_destroy(exec_ctx, &b);
 
   if (!grpc_slice_eq(merged, expect)) {
     char* expect_str = grpc_dump_slice(expect, GPR_DUMP_HEX | GPR_DUMP_ASCII);
@@ -121,11 +123,11 @@ static void verify(const verify_params params, const char* expected,
     g_failure = 1;
   }
 
-  grpc_slice_unref_internal(merged);
-  grpc_slice_unref_internal(expect);
+  grpc_slice_unref_internal(exec_ctx, merged);
+  grpc_slice_unref_internal(exec_ctx, expect);
 }
 
-static void test_basic_headers() {
+static void test_basic_headers(grpc_exec_ctx* exec_ctx) {
   int i;
 
   verify_params params = {
@@ -133,22 +135,24 @@ static void test_basic_headers() {
       false,
       false,
   };
-  verify(params, "000005 0104 deadbeef 40 0161 0161", 1, "a", "a");
-  verify(params, "000001 0104 deadbeef be", 1, "a", "a");
-  verify(params, "000001 0104 deadbeef be", 1, "a", "a");
-  verify(params, "000006 0104 deadbeef be 40 0162 0163", 2, "a", "a", "b", "c");
-  verify(params, "000002 0104 deadbeef bf be", 2, "a", "a", "b", "c");
-  verify(params, "000004 0104 deadbeef 7f 00 0164", 1, "a", "d");
+  verify(exec_ctx, params, "000005 0104 deadbeef 40 0161 0161", 1, "a", "a");
+  verify(exec_ctx, params, "000001 0104 deadbeef be", 1, "a", "a");
+  verify(exec_ctx, params, "000001 0104 deadbeef be", 1, "a", "a");
+  verify(exec_ctx, params, "000006 0104 deadbeef be 40 0162 0163", 2, "a", "a",
+         "b", "c");
+  verify(exec_ctx, params, "000002 0104 deadbeef bf be", 2, "a", "a", "b", "c");
+  verify(exec_ctx, params, "000004 0104 deadbeef 7f 00 0164", 1, "a", "d");
 
   /* flush out what's there to make a few values look very popular */
   for (i = 0; i < 350; i++) {
-    verify(params, "000003 0104 deadbeef c0 bf be", 3, "a", "a", "b", "c", "a",
-           "d");
+    verify(exec_ctx, params, "000003 0104 deadbeef c0 bf be", 3, "a", "a", "b",
+           "c", "a", "d");
   }
 
-  verify(params, "000006 0104 deadbeef c0 00 016b 0176", 2, "a", "a", "k", "v");
+  verify(exec_ctx, params, "000006 0104 deadbeef c0 00 016b 0176", 2, "a", "a",
+         "k", "v");
   /* this could be 000004 0104 deadbeef 0f 30 0176 also */
-  verify(params, "000004 0104 deadbeef 0f 2f 0176", 1, "a", "v");
+  verify(exec_ctx, params, "000004 0104 deadbeef 0f 2f 0176", 1, "a", "v");
 }
 
 static void encode_int_to_str(int i, char* p) {
@@ -159,7 +163,7 @@ static void encode_int_to_str(int i, char* p) {
   p[2] = 0;
 }
 
-static void test_decode_table_overflow() {
+static void test_decode_table_overflow(grpc_exec_ctx* exec_ctx) {
   int i;
   char key[3], value[3];
   char* expect;
@@ -188,24 +192,26 @@ static void test_decode_table_overflow() {
     }
 
     if (i > 0) {
-      verify(params, expect, 2, "aa", "ba", key, value);
+      verify(exec_ctx, params, expect, 2, "aa", "ba", key, value);
     } else {
-      verify(params, expect, 1, key, value);
+      verify(exec_ctx, params, expect, 1, key, value);
     }
     gpr_free(expect);
   }
 
   /* if the above passes, then we must have just knocked this pair out of the
      decoder stack, and so we'll be forced to re-encode it */
-  verify(params, "000007 0104 deadbeef 40 026161 026261", 1, "aa", "ba");
+  verify(exec_ctx, params, "000007 0104 deadbeef 40 026161 026261", 1, "aa",
+         "ba");
 }
 
-static void verify_table_size_change_match_elem_size(const char* key,
+static void verify_table_size_change_match_elem_size(grpc_exec_ctx* exec_ctx,
+                                                     const char* key,
                                                      const char* value,
                                                      bool use_true_binary) {
   grpc_slice_buffer output;
   grpc_mdelem elem = grpc_mdelem_from_slices(
-      grpc_slice_intern(grpc_slice_from_static_string(key)),
+      exec_ctx, grpc_slice_intern(grpc_slice_from_static_string(key)),
       grpc_slice_intern(grpc_slice_from_static_string(value)));
   size_t elem_size = grpc_mdelem_get_size_in_hpack_table(elem, use_true_binary);
   size_t initial_table_size = g_compressor.table_size;
@@ -229,38 +235,41 @@ static void verify_table_size_change_match_elem_size(const char* key,
       use_true_binary, /* use_true_binary_metadata */
       16384,           /* max_frame_size */
       &stats /* stats */};
-  grpc_chttp2_encode_header(&g_compressor, nullptr, 0, &b, &hopt, &output);
-  grpc_slice_buffer_destroy_internal(&output);
-  grpc_metadata_batch_destroy(&b);
+  grpc_chttp2_encode_header(exec_ctx, &g_compressor, nullptr, 0, &b, &hopt,
+                            &output);
+  grpc_slice_buffer_destroy_internal(exec_ctx, &output);
+  grpc_metadata_batch_destroy(exec_ctx, &b);
 
   GPR_ASSERT(g_compressor.table_size == elem_size + initial_table_size);
   gpr_free(e);
 }
 
-static void test_encode_header_size() {
-  verify_table_size_change_match_elem_size("hello", "world", false);
-  verify_table_size_change_match_elem_size("hello-bin", "world", false);
-  verify_table_size_change_match_elem_size("true-binary-bin",
+static void test_encode_header_size(grpc_exec_ctx* exec_ctx) {
+  verify_table_size_change_match_elem_size(exec_ctx, "hello", "world", false);
+  verify_table_size_change_match_elem_size(exec_ctx, "hello-bin", "world",
+                                           false);
+  verify_table_size_change_match_elem_size(exec_ctx, "true-binary-bin",
                                            "I_am_true_binary_value", true);
 }
 
-static void test_interned_key_indexed() {
+static void test_interned_key_indexed(grpc_exec_ctx* exec_ctx) {
   int i;
   verify_params params = {false, false, true};
-  verify(params, "000009 0104 deadbeef 40 0161 0162 0f2f 0163", 2, "a", "b",
-         "a", "c");
+  verify(exec_ctx, params, "000009 0104 deadbeef 40 0161 0162 0f2f 0163", 2,
+         "a", "b", "a", "c");
   for (i = 0; i < 10; i++) {
-    verify(params, "000008 0104 deadbeef 0f2f 0162 0f2f 0163", 2, "a", "b", "a",
-           "c");
+    verify(exec_ctx, params, "000008 0104 deadbeef 0f2f 0162 0f2f 0163", 2, "a",
+           "b", "a", "c");
   }
 }
 
-static void run_test(void (*test)(), const char* name) {
+static void run_test(void (*test)(grpc_exec_ctx* exec_ctx), const char* name) {
   gpr_log(GPR_INFO, "RUN TEST: %s", name);
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_chttp2_hpack_compressor_init(&g_compressor);
-  test();
-  grpc_chttp2_hpack_compressor_destroy(&g_compressor);
+  test(&exec_ctx);
+  grpc_chttp2_hpack_compressor_destroy(&exec_ctx, &g_compressor);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 int main(int argc, char** argv) {
diff --git a/test/core/transport/chttp2/hpack_parser_fuzzer_test.cc b/test/core/transport/chttp2/hpack_parser_fuzzer_test.cc
index 9a195daee0..942f25e0b7 100644
--- a/test/core/transport/chttp2/hpack_parser_fuzzer_test.cc
+++ b/test/core/transport/chttp2/hpack_parser_fuzzer_test.cc
@@ -29,7 +29,9 @@
 bool squelch = true;
 bool leak_check = true;
 
-static void onhdr(void* ud, grpc_mdelem md) { GRPC_MDELEM_UNREF(md); }
+static void onhdr(grpc_exec_ctx* exec_ctx, void* ud, grpc_mdelem md) {
+  GRPC_MDELEM_UNREF(exec_ctx, md);
+}
 static void dont_log(gpr_log_func_args* args) {}
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
@@ -37,14 +39,13 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   if (squelch) gpr_set_log_function(dont_log);
   grpc_init();
   grpc_chttp2_hpack_parser parser;
-  {
-    grpc_core::ExecCtx exec_ctx;
-    grpc_chttp2_hpack_parser_init(&parser);
-    parser.on_header = onhdr;
-    GRPC_ERROR_UNREF(grpc_chttp2_hpack_parser_parse(
-        &parser, grpc_slice_from_static_buffer(data, size)));
-    grpc_chttp2_hpack_parser_destroy(&parser);
-  }
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_chttp2_hpack_parser_init(&exec_ctx, &parser);
+  parser.on_header = onhdr;
+  GRPC_ERROR_UNREF(grpc_chttp2_hpack_parser_parse(
+      &exec_ctx, &parser, grpc_slice_from_static_buffer(data, size)));
+  grpc_chttp2_hpack_parser_destroy(&exec_ctx, &parser);
+  grpc_exec_ctx_finish(&exec_ctx);
   grpc_shutdown();
   return 0;
 }
diff --git a/test/core/transport/chttp2/hpack_parser_test.cc b/test/core/transport/chttp2/hpack_parser_test.cc
index 9d3456a873..82fb20aced 100644
--- a/test/core/transport/chttp2/hpack_parser_test.cc
+++ b/test/core/transport/chttp2/hpack_parser_test.cc
@@ -32,7 +32,7 @@ typedef struct {
   va_list args;
 } test_checker;
 
-static void onhdr(void* ud, grpc_mdelem md) {
+static void onhdr(grpc_exec_ctx* exec_ctx, void* ud, grpc_mdelem md) {
   const char *ekey, *evalue;
   test_checker* chk = static_cast<test_checker*>(ud);
   ekey = va_arg(chk->args, char*);
@@ -41,7 +41,7 @@ static void onhdr(void* ud, grpc_mdelem md) {
   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(md);
+  GRPC_MDELEM_UNREF(exec_ctx, md);
 }
 
 static void test_vector(grpc_chttp2_hpack_parser* parser,
@@ -62,9 +62,10 @@ static void test_vector(grpc_chttp2_hpack_parser* parser,
   grpc_slice_unref(input);
 
   for (i = 0; i < nslices; i++) {
-    grpc_core::ExecCtx exec_ctx;
-    GPR_ASSERT(grpc_chttp2_hpack_parser_parse(parser, slices[i]) ==
+    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+    GPR_ASSERT(grpc_chttp2_hpack_parser_parse(&exec_ctx, parser, slices[i]) ==
                GRPC_ERROR_NONE);
+    grpc_exec_ctx_finish(&exec_ctx);
   }
 
   for (i = 0; i < nslices; i++) {
@@ -79,9 +80,9 @@ static void test_vector(grpc_chttp2_hpack_parser* parser,
 
 static void test_vectors(grpc_slice_split_mode mode) {
   grpc_chttp2_hpack_parser parser;
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  grpc_chttp2_hpack_parser_init(&parser);
+  grpc_chttp2_hpack_parser_init(&exec_ctx, &parser);
   /* D.2.1 */
   test_vector(&parser, mode,
               "400a 6375 7374 6f6d 2d6b 6579 0d63 7573"
@@ -97,9 +98,9 @@ static void test_vectors(grpc_slice_split_mode mode) {
               "password", "secret", NULL);
   /* D.2.4 */
   test_vector(&parser, mode, "82", ":method", "GET", NULL);
-  grpc_chttp2_hpack_parser_destroy(&parser);
+  grpc_chttp2_hpack_parser_destroy(&exec_ctx, &parser);
 
-  grpc_chttp2_hpack_parser_init(&parser);
+  grpc_chttp2_hpack_parser_init(&exec_ctx, &parser);
   /* D.3.1 */
   test_vector(&parser, mode,
               "8286 8441 0f77 7777 2e65 7861 6d70 6c65"
@@ -117,9 +118,9 @@ static void test_vectors(grpc_slice_split_mode mode) {
               ":method", "GET", ":scheme", "https", ":path", "/index.html",
               ":authority", "www.example.com", "custom-key", "custom-value",
               NULL);
-  grpc_chttp2_hpack_parser_destroy(&parser);
+  grpc_chttp2_hpack_parser_destroy(&exec_ctx, &parser);
 
-  grpc_chttp2_hpack_parser_init(&parser);
+  grpc_chttp2_hpack_parser_init(&exec_ctx, &parser);
   /* D.4.1 */
   test_vector(&parser, mode,
               "8286 8441 8cf1 e3c2 e5f2 3a6b a0ab 90f4"
@@ -137,11 +138,11 @@ static void test_vectors(grpc_slice_split_mode mode) {
               ":method", "GET", ":scheme", "https", ":path", "/index.html",
               ":authority", "www.example.com", "custom-key", "custom-value",
               NULL);
-  grpc_chttp2_hpack_parser_destroy(&parser);
+  grpc_chttp2_hpack_parser_destroy(&exec_ctx, &parser);
 
-  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);
+  grpc_chttp2_hpack_parser_init(&exec_ctx, &parser);
+  grpc_chttp2_hptbl_set_max_bytes(&exec_ctx, &parser.table, 256);
+  grpc_chttp2_hptbl_set_current_table_size(&exec_ctx, &parser.table, 256);
   /* D.5.1 */
   test_vector(&parser, mode,
               "4803 3330 3258 0770 7269 7661 7465 611d"
@@ -171,11 +172,11 @@ static void test_vectors(grpc_slice_split_mode mode) {
               "https://www.example.com", "content-encoding", "gzip",
               "set-cookie",
               "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1", NULL);
-  grpc_chttp2_hpack_parser_destroy(&parser);
+  grpc_chttp2_hpack_parser_destroy(&exec_ctx, &parser);
 
-  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);
+  grpc_chttp2_hpack_parser_init(&exec_ctx, &parser);
+  grpc_chttp2_hptbl_set_max_bytes(&exec_ctx, &parser.table, 256);
+  grpc_chttp2_hptbl_set_current_table_size(&exec_ctx, &parser.table, 256);
   /* D.6.1 */
   test_vector(&parser, mode,
               "4882 6402 5885 aec3 771a 4b61 96d0 7abe"
@@ -202,7 +203,9 @@ static void test_vectors(grpc_slice_split_mode mode) {
               "https://www.example.com", "content-encoding", "gzip",
               "set-cookie",
               "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1", NULL);
-  grpc_chttp2_hpack_parser_destroy(&parser);
+  grpc_chttp2_hpack_parser_destroy(&exec_ctx, &parser);
+
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 int main(int argc, char** argv) {
diff --git a/test/core/transport/chttp2/hpack_table_test.cc b/test/core/transport/chttp2/hpack_table_test.cc
index 3f3cb2ee9d..ff7c2de538 100644
--- a/test/core/transport/chttp2/hpack_table_test.cc
+++ b/test/core/transport/chttp2/hpack_table_test.cc
@@ -44,10 +44,10 @@ static void assert_index(const grpc_chttp2_hptbl* tbl, uint32_t idx,
 }
 
 static void test_static_lookup(void) {
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_chttp2_hptbl tbl;
 
-  grpc_chttp2_hptbl_init(&tbl);
+  grpc_chttp2_hptbl_init(&exec_ctx, &tbl);
 
   LOG_TEST("test_static_lookup");
   assert_index(&tbl, 1, ":authority", "");
@@ -112,7 +112,8 @@ static void test_static_lookup(void) {
   assert_index(&tbl, 60, "via", "");
   assert_index(&tbl, 61, "www-authenticate", "");
 
-  grpc_chttp2_hptbl_destroy(&tbl);
+  grpc_chttp2_hptbl_destroy(&exec_ctx, &tbl);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_many_additions(void) {
@@ -123,17 +124,18 @@ static void test_many_additions(void) {
 
   LOG_TEST("test_many_additions");
 
-  grpc_core::ExecCtx exec_ctx;
-  grpc_chttp2_hptbl_init(&tbl);
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_chttp2_hptbl_init(&exec_ctx, &tbl);
 
   for (i = 0; i < 100000; i++) {
     grpc_mdelem elem;
     gpr_asprintf(&key, "K:%d", i);
     gpr_asprintf(&value, "VALUE:%d", i);
-    elem = grpc_mdelem_from_slices(grpc_slice_from_copied_string(key),
-                                   grpc_slice_from_copied_string(value));
-    GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem) == GRPC_ERROR_NONE);
-    GRPC_MDELEM_UNREF(elem);
+    elem =
+        grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_copied_string(key),
+                                grpc_slice_from_copied_string(value));
+    GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
+    GRPC_MDELEM_UNREF(&exec_ctx, elem);
     assert_index(&tbl, 1 + GRPC_CHTTP2_LAST_STATIC_ENTRY, key, value);
     gpr_free(key);
     gpr_free(value);
@@ -146,23 +148,25 @@ static void test_many_additions(void) {
     }
   }
 
-  grpc_chttp2_hptbl_destroy(&tbl);
+  grpc_chttp2_hptbl_destroy(&exec_ctx, &tbl);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static grpc_chttp2_hptbl_find_result find_simple(grpc_chttp2_hptbl* tbl,
                                                  const char* key,
                                                  const char* value) {
-  grpc_core::ExecCtx exec_ctx;
-  grpc_mdelem md = grpc_mdelem_from_slices(
-      grpc_slice_from_copied_string(key), grpc_slice_from_copied_string(value));
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_mdelem md =
+      grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_copied_string(key),
+                              grpc_slice_from_copied_string(value));
   grpc_chttp2_hptbl_find_result r = grpc_chttp2_hptbl_find(tbl, md);
-  GRPC_MDELEM_UNREF(md);
-
+  GRPC_MDELEM_UNREF(&exec_ctx, md);
+  grpc_exec_ctx_finish(&exec_ctx);
   return r;
 }
 
 static void test_find(void) {
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_chttp2_hptbl tbl;
   uint32_t i;
   char buffer[32];
@@ -171,19 +175,21 @@ static void test_find(void) {
 
   LOG_TEST("test_find");
 
-  grpc_chttp2_hptbl_init(&tbl);
-  elem = grpc_mdelem_from_slices(grpc_slice_from_static_string("abc"),
-                                 grpc_slice_from_static_string("xyz"));
-  GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem) == GRPC_ERROR_NONE);
-  GRPC_MDELEM_UNREF(elem);
-  elem = grpc_mdelem_from_slices(grpc_slice_from_static_string("abc"),
-                                 grpc_slice_from_static_string("123"));
-  GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem) == GRPC_ERROR_NONE);
-  GRPC_MDELEM_UNREF(elem);
-  elem = grpc_mdelem_from_slices(grpc_slice_from_static_string("x"),
+  grpc_chttp2_hptbl_init(&exec_ctx, &tbl);
+  elem =
+      grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_static_string("abc"),
+                              grpc_slice_from_static_string("xyz"));
+  GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
+  GRPC_MDELEM_UNREF(&exec_ctx, elem);
+  elem =
+      grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_static_string("abc"),
+                              grpc_slice_from_static_string("123"));
+  GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
+  GRPC_MDELEM_UNREF(&exec_ctx, elem);
+  elem = grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_static_string("x"),
                                  grpc_slice_from_static_string("1"));
-  GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem) == GRPC_ERROR_NONE);
-  GRPC_MDELEM_UNREF(elem);
+  GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
+  GRPC_MDELEM_UNREF(&exec_ctx, elem);
 
   r = find_simple(&tbl, "abc", "123");
   GPR_ASSERT(r.index == 2 + GRPC_CHTTP2_LAST_STATIC_ENTRY);
@@ -232,10 +238,11 @@ static void test_find(void) {
   /* overflow the string buffer, check find still works */
   for (i = 0; i < 10000; i++) {
     int64_ttoa(i, buffer);
-    elem = grpc_mdelem_from_slices(grpc_slice_from_static_string("test"),
+    elem = grpc_mdelem_from_slices(&exec_ctx,
+                                   grpc_slice_from_static_string("test"),
                                    grpc_slice_from_copied_string(buffer));
-    GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem) == GRPC_ERROR_NONE);
-    GRPC_MDELEM_UNREF(elem);
+    GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
+    GRPC_MDELEM_UNREF(&exec_ctx, elem);
   }
 
   r = find_simple(&tbl, "abc", "123");
@@ -263,7 +270,8 @@ static void test_find(void) {
   GPR_ASSERT(r.index != 0);
   GPR_ASSERT(r.has_value == 0);
 
-  grpc_chttp2_hptbl_destroy(&tbl);
+  grpc_chttp2_hptbl_destroy(&exec_ctx, &tbl);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 int main(int argc, char** argv) {
diff --git a/test/core/transport/chttp2/settings_timeout_test.cc b/test/core/transport/chttp2/settings_timeout_test.cc
index 08473c72b6..670eae1f79 100644
--- a/test/core/transport/chttp2/settings_timeout_test.cc
+++ b/test/core/transport/chttp2/settings_timeout_test.cc
@@ -97,7 +97,7 @@ class Client {
       : server_address_(server_address) {}
 
   void Connect() {
-    grpc_core::ExecCtx exec_ctx;
+    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resolved_addresses* server_addresses = nullptr;
     grpc_error* error =
         grpc_blocking_resolve_address(server_address_, "80", &server_addresses);
@@ -106,53 +106,56 @@ class Client {
     pollset_ = (grpc_pollset*)gpr_zalloc(grpc_pollset_size());
     grpc_pollset_init(pollset_, &mu_);
     grpc_pollset_set* pollset_set = grpc_pollset_set_create();
-    grpc_pollset_set_add_pollset(pollset_set, pollset_);
+    grpc_pollset_set_add_pollset(&exec_ctx, pollset_set, pollset_);
     EventState state;
-    grpc_tcp_client_connect(state.closure(), &endpoint_, pollset_set,
+    grpc_tcp_client_connect(&exec_ctx, state.closure(), &endpoint_, pollset_set,
                             nullptr /* channel_args */, server_addresses->addrs,
                             1000);
     ASSERT_TRUE(PollUntilDone(
-        &state,
+        &exec_ctx, &state,
         grpc_timespec_to_millis_round_up(gpr_inf_future(GPR_CLOCK_MONOTONIC))));
     ASSERT_EQ(GRPC_ERROR_NONE, state.error());
-    grpc_pollset_set_destroy(pollset_set);
-    grpc_endpoint_add_to_pollset(endpoint_, pollset_);
+    grpc_pollset_set_destroy(&exec_ctx, pollset_set);
+    grpc_endpoint_add_to_pollset(&exec_ctx, endpoint_, pollset_);
     grpc_resolved_addresses_destroy(server_addresses);
+    grpc_exec_ctx_finish(&exec_ctx);
   }
 
   // Reads until an error is returned.
   // Returns true if an error was encountered before the deadline.
   bool ReadUntilError() {
-    grpc_core::ExecCtx exec_ctx;
+    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_slice_buffer read_buffer;
     grpc_slice_buffer_init(&read_buffer);
     bool retval = true;
     // Use a deadline of 3 seconds, which is a lot more than we should
     // need for a 1-second timeout, but this helps avoid flakes.
-    grpc_millis deadline = grpc_core::ExecCtx::Get()->Now() + 3000;
+    grpc_millis deadline = grpc_exec_ctx_now(&exec_ctx) + 3000;
     while (true) {
       EventState state;
-      grpc_endpoint_read(endpoint_, &read_buffer, state.closure());
-      if (!PollUntilDone(&state, deadline)) {
+      grpc_endpoint_read(&exec_ctx, endpoint_, &read_buffer, state.closure());
+      if (!PollUntilDone(&exec_ctx, &state, deadline)) {
         retval = false;
         break;
       }
       if (state.error() != GRPC_ERROR_NONE) break;
       gpr_log(GPR_INFO, "client read %" PRIuPTR " bytes", read_buffer.length);
-      grpc_slice_buffer_reset_and_unref_internal(&read_buffer);
+      grpc_slice_buffer_reset_and_unref_internal(&exec_ctx, &read_buffer);
     }
-    grpc_endpoint_shutdown(endpoint_,
+    grpc_endpoint_shutdown(&exec_ctx, endpoint_,
                            GRPC_ERROR_CREATE_FROM_STATIC_STRING("shutdown"));
-    grpc_slice_buffer_destroy_internal(&read_buffer);
+    grpc_slice_buffer_destroy_internal(&exec_ctx, &read_buffer);
+    grpc_exec_ctx_finish(&exec_ctx);
     return retval;
   }
 
   void Shutdown() {
-    grpc_core::ExecCtx exec_ctx;
-    grpc_endpoint_destroy(endpoint_);
-    grpc_pollset_shutdown(pollset_,
+    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+    grpc_endpoint_destroy(&exec_ctx, endpoint_);
+    grpc_pollset_shutdown(&exec_ctx, pollset_,
                           GRPC_CLOSURE_CREATE(&Client::PollsetDestroy, pollset_,
                                               grpc_schedule_on_exec_ctx));
+    grpc_exec_ctx_finish(&exec_ctx);
   }
 
  private:
@@ -174,7 +177,8 @@ class Client {
     grpc_error* error() const { return error_; }
 
    private:
-    static void OnEventDone(void* arg, grpc_error* error) {
+    static void OnEventDone(grpc_exec_ctx* exec_ctx, void* arg,
+                            grpc_error* error) {
       gpr_log(GPR_INFO, "OnEventDone(): %s", grpc_error_string(error));
       EventState* state = (EventState*)arg;
       state->error_ = GRPC_ERROR_REF(error);
@@ -187,23 +191,24 @@ class Client {
   };
 
   // Returns true if done, or false if deadline exceeded.
-  bool PollUntilDone(EventState* state, grpc_millis deadline) {
+  bool PollUntilDone(grpc_exec_ctx* exec_ctx, EventState* state,
+                     grpc_millis deadline) {
     while (true) {
       grpc_pollset_worker* worker = nullptr;
       gpr_mu_lock(mu_);
-      GRPC_LOG_IF_ERROR(
-          "grpc_pollset_work",
-          grpc_pollset_work(pollset_, &worker,
-                            grpc_core::ExecCtx::Get()->Now() + 1000));
+      GRPC_LOG_IF_ERROR("grpc_pollset_work",
+                        grpc_pollset_work(exec_ctx, pollset_, &worker,
+                                          grpc_exec_ctx_now(exec_ctx) + 1000));
       gpr_mu_unlock(mu_);
       if (state != nullptr && state->done()) return true;
-      if (grpc_core::ExecCtx::Get()->Now() >= deadline) return false;
+      if (grpc_exec_ctx_now(exec_ctx) >= deadline) return false;
     }
   }
 
-  static void PollsetDestroy(void* arg, grpc_error* error) {
+  static void PollsetDestroy(grpc_exec_ctx* exec_ctx, void* arg,
+                             grpc_error* error) {
     grpc_pollset* pollset = (grpc_pollset*)arg;
-    grpc_pollset_destroy(pollset);
+    grpc_pollset_destroy(exec_ctx, pollset);
     gpr_free(pollset);
   }
 
diff --git a/test/core/transport/chttp2/varint_test.cc b/test/core/transport/chttp2/varint_test.cc
index 36760d0c72..413b461b3a 100644
--- a/test/core/transport/chttp2/varint_test.cc
+++ b/test/core/transport/chttp2/varint_test.cc
@@ -18,7 +18,6 @@
 
 #include "src/core/ext/transport/chttp2/transport/varint.h"
 
-#include <grpc/grpc.h>
 #include <grpc/slice.h>
 #include <grpc/support/log.h>
 
@@ -45,13 +44,11 @@ static void test_varint(uint32_t value, uint32_t prefix_bits, uint8_t prefix_or,
 
 int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
-  grpc_init();
   TEST_VARINT(0, 1, 0, "\x00");
   TEST_VARINT(128, 1, 0, "\x7f\x01");
   TEST_VARINT(16384, 1, 0, "\x7f\x81\x7f");
   TEST_VARINT(2097152, 1, 0, "\x7f\x81\xff\x7f");
   TEST_VARINT(268435456, 1, 0, "\x7f\x81\xff\xff\x7f");
   TEST_VARINT(0xffffffff, 1, 0, "\x7f\x80\xff\xff\xff\x0f");
-  grpc_shutdown();
   return 0;
 }
diff --git a/test/core/transport/connectivity_state_test.cc b/test/core/transport/connectivity_state_test.cc
index f5894599e5..11046e126e 100644
--- a/test/core/transport/connectivity_state_test.cc
+++ b/test/core/transport/connectivity_state_test.cc
@@ -29,13 +29,14 @@
 
 int g_counter;
 
-static void must_succeed(void* arg, grpc_error* error) {
+static void must_succeed(grpc_exec_ctx* exec_ctx, void* arg,
+                         grpc_error* error) {
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(arg == THE_ARG);
   g_counter++;
 }
 
-static void must_fail(void* arg, grpc_error* error) {
+static void must_fail(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
   GPR_ASSERT(error != GRPC_ERROR_NONE);
   GPR_ASSERT(arg == THE_ARG);
   g_counter++;
@@ -58,7 +59,7 @@ static void test_connectivity_state_name(void) {
 
 static void test_check(void) {
   grpc_connectivity_state_tracker tracker;
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_error* error;
   gpr_log(GPR_DEBUG, "test_check");
   grpc_connectivity_state_init(&tracker, GRPC_CHANNEL_IDLE, "xxx");
@@ -66,7 +67,8 @@ static void test_check(void) {
              GRPC_CHANNEL_IDLE);
   GPR_ASSERT(grpc_connectivity_state_check(&tracker) == GRPC_CHANNEL_IDLE);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
-  grpc_connectivity_state_destroy(&tracker);
+  grpc_connectivity_state_destroy(&exec_ctx, &tracker);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_subscribe_then_unsubscribe(void) {
@@ -74,21 +76,23 @@ static void test_subscribe_then_unsubscribe(void) {
   grpc_closure* closure =
       GRPC_CLOSURE_CREATE(must_fail, THE_ARG, grpc_schedule_on_exec_ctx);
   grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   gpr_log(GPR_DEBUG, "test_subscribe_then_unsubscribe");
   g_counter = 0;
   grpc_connectivity_state_init(&tracker, GRPC_CHANNEL_IDLE, "xxx");
-  GPR_ASSERT(grpc_connectivity_state_notify_on_state_change(&tracker, &state,
-                                                            closure));
-  grpc_core::ExecCtx::Get()->Flush();
+  GPR_ASSERT(grpc_connectivity_state_notify_on_state_change(&exec_ctx, &tracker,
+                                                            &state, closure));
+  grpc_exec_ctx_flush(&exec_ctx);
   GPR_ASSERT(state == GRPC_CHANNEL_IDLE);
   GPR_ASSERT(g_counter == 0);
-  grpc_connectivity_state_notify_on_state_change(&tracker, nullptr, closure);
-  grpc_core::ExecCtx::Get()->Flush();
+  grpc_connectivity_state_notify_on_state_change(&exec_ctx, &tracker, nullptr,
+                                                 closure);
+  grpc_exec_ctx_flush(&exec_ctx);
   GPR_ASSERT(state == GRPC_CHANNEL_IDLE);
   GPR_ASSERT(g_counter == 1);
 
-  grpc_connectivity_state_destroy(&tracker);
+  grpc_connectivity_state_destroy(&exec_ctx, &tracker);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_subscribe_then_destroy(void) {
@@ -96,18 +100,17 @@ static void test_subscribe_then_destroy(void) {
   grpc_closure* closure =
       GRPC_CLOSURE_CREATE(must_succeed, THE_ARG, grpc_schedule_on_exec_ctx);
   grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   gpr_log(GPR_DEBUG, "test_subscribe_then_destroy");
   g_counter = 0;
   grpc_connectivity_state_init(&tracker, GRPC_CHANNEL_IDLE, "xxx");
-  GPR_ASSERT(grpc_connectivity_state_notify_on_state_change(&tracker, &state,
-                                                            closure));
-  grpc_core::ExecCtx::Get()->Flush();
+  GPR_ASSERT(grpc_connectivity_state_notify_on_state_change(&exec_ctx, &tracker,
+                                                            &state, closure));
+  grpc_exec_ctx_flush(&exec_ctx);
   GPR_ASSERT(state == GRPC_CHANNEL_IDLE);
   GPR_ASSERT(g_counter == 0);
-  grpc_connectivity_state_destroy(&tracker);
-
-  grpc_core::ExecCtx::Get()->Flush();
+  grpc_connectivity_state_destroy(&exec_ctx, &tracker);
+  grpc_exec_ctx_finish(&exec_ctx);
   GPR_ASSERT(state == GRPC_CHANNEL_SHUTDOWN);
   GPR_ASSERT(g_counter == 1);
 }
@@ -117,30 +120,28 @@ static void test_subscribe_with_failure_then_destroy(void) {
   grpc_closure* closure =
       GRPC_CLOSURE_CREATE(must_fail, THE_ARG, grpc_schedule_on_exec_ctx);
   grpc_connectivity_state state = GRPC_CHANNEL_SHUTDOWN;
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   gpr_log(GPR_DEBUG, "test_subscribe_with_failure_then_destroy");
   g_counter = 0;
   grpc_connectivity_state_init(&tracker, GRPC_CHANNEL_SHUTDOWN, "xxx");
   GPR_ASSERT(0 == grpc_connectivity_state_notify_on_state_change(
-                      &tracker, &state, closure));
-  grpc_core::ExecCtx::Get()->Flush();
+                      &exec_ctx, &tracker, &state, closure));
+  grpc_exec_ctx_flush(&exec_ctx);
   GPR_ASSERT(state == GRPC_CHANNEL_SHUTDOWN);
   GPR_ASSERT(g_counter == 0);
-  grpc_connectivity_state_destroy(&tracker);
-  grpc_core::ExecCtx::Get()->Flush();
+  grpc_connectivity_state_destroy(&exec_ctx, &tracker);
+  grpc_exec_ctx_finish(&exec_ctx);
   GPR_ASSERT(state == GRPC_CHANNEL_SHUTDOWN);
   GPR_ASSERT(g_counter == 1);
 }
 
 int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
-  grpc_init();
   grpc_core::testing::grpc_tracer_enable_flag(&grpc_connectivity_state_trace);
   test_connectivity_state_name();
   test_check();
   test_subscribe_then_unsubscribe();
   test_subscribe_then_destroy();
   test_subscribe_with_failure_then_destroy();
-  grpc_shutdown();
   return 0;
 }
diff --git a/test/core/transport/metadata_test.cc b/test/core/transport/metadata_test.cc
index 5c52ae8d5f..b60a9619fb 100644
--- a/test/core/transport/metadata_test.cc
+++ b/test/core/transport/metadata_test.cc
@@ -60,15 +60,15 @@ static void test_create_metadata(bool intern_keys, bool intern_values) {
           intern_keys, intern_values);
 
   grpc_init();
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   m1 = grpc_mdelem_from_slices(
-      maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+      &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
       maybe_intern(grpc_slice_from_static_string("b"), intern_values));
   m2 = grpc_mdelem_from_slices(
-      maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+      &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
       maybe_intern(grpc_slice_from_static_string("b"), intern_values));
   m3 = grpc_mdelem_from_slices(
-      maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+      &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
       maybe_intern(grpc_slice_from_static_string("c"), intern_values));
   GPR_ASSERT(grpc_mdelem_eq(m1, m2));
   GPR_ASSERT(!grpc_mdelem_eq(m3, m1));
@@ -77,10 +77,10 @@ static void test_create_metadata(bool intern_keys, bool intern_values) {
   GPR_ASSERT(grpc_slice_str_cmp(GRPC_MDKEY(m1), "a") == 0);
   GPR_ASSERT(grpc_slice_str_cmp(GRPC_MDVALUE(m1), "b") == 0);
   GPR_ASSERT(grpc_slice_str_cmp(GRPC_MDVALUE(m3), "c") == 0);
-  GRPC_MDELEM_UNREF(m1);
-  GRPC_MDELEM_UNREF(m2);
-  GRPC_MDELEM_UNREF(m3);
-
+  GRPC_MDELEM_UNREF(&exec_ctx, m1);
+  GRPC_MDELEM_UNREF(&exec_ctx, m2);
+  GRPC_MDELEM_UNREF(&exec_ctx, m3);
+  grpc_exec_ctx_finish(&exec_ctx);
   grpc_shutdown();
 }
 
@@ -95,15 +95,19 @@ static void test_create_many_ephemeral_metadata(bool intern_keys,
       intern_keys, intern_values);
 
   grpc_init();
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_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_slices(
-        maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
-        maybe_intern(grpc_slice_from_copied_string(buffer), intern_values)));
+    GRPC_MDELEM_UNREF(
+        &exec_ctx,
+        grpc_mdelem_from_slices(
+            &exec_ctx,
+            maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+            maybe_intern(grpc_slice_from_copied_string(buffer),
+                         intern_values)));
   }
-
+  grpc_exec_ctx_finish(&exec_ctx);
   grpc_shutdown();
 }
 
@@ -117,28 +121,28 @@ static void test_create_many_persistant_metadata(void) {
   gpr_log(GPR_INFO, "test_create_many_persistant_metadata");
 
   grpc_init();
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   /* add phase */
   for (i = 0; i < MANY; i++) {
     gpr_ltoa(i, buffer);
     created[i] = grpc_mdelem_from_slices(
-        grpc_slice_intern(grpc_slice_from_static_string("a")),
+        &exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("a")),
         grpc_slice_intern(grpc_slice_from_static_string(buffer)));
   }
   /* verify phase */
   for (i = 0; i < MANY; i++) {
     gpr_ltoa(i, buffer);
     md = grpc_mdelem_from_slices(
-        grpc_slice_intern(grpc_slice_from_static_string("a")),
+        &exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("a")),
         grpc_slice_intern(grpc_slice_from_static_string(buffer)));
     GPR_ASSERT(grpc_mdelem_eq(md, created[i]));
-    GRPC_MDELEM_UNREF(md);
+    GRPC_MDELEM_UNREF(&exec_ctx, md);
   }
   /* cleanup phase */
   for (i = 0; i < MANY; i++) {
-    GRPC_MDELEM_UNREF(created[i]);
+    GRPC_MDELEM_UNREF(&exec_ctx, created[i]);
   }
-
+  grpc_exec_ctx_finish(&exec_ctx);
   grpc_shutdown();
 
   gpr_free(created);
@@ -151,25 +155,31 @@ static void test_spin_creating_the_same_thing(bool intern_keys,
           intern_keys, intern_values);
 
   grpc_init();
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_mdelem a, b, c;
   GRPC_MDELEM_UNREF(
+      &exec_ctx,
       a = grpc_mdelem_from_slices(
+          &exec_ctx,
           maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
           maybe_intern(grpc_slice_from_static_string("b"), intern_values)));
   GRPC_MDELEM_UNREF(
+      &exec_ctx,
       b = grpc_mdelem_from_slices(
+          &exec_ctx,
           maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
           maybe_intern(grpc_slice_from_static_string("b"), intern_values)));
   GRPC_MDELEM_UNREF(
+      &exec_ctx,
       c = grpc_mdelem_from_slices(
+          &exec_ctx,
           maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
           maybe_intern(grpc_slice_from_static_string("b"), intern_values)));
   if (intern_keys && intern_values) {
     GPR_ASSERT(a.payload == b.payload);
     GPR_ASSERT(a.payload == c.payload);
   }
-
+  grpc_exec_ctx_finish(&exec_ctx);
   grpc_shutdown();
 }
 
@@ -178,16 +188,16 @@ static void test_identity_laws(bool intern_keys, bool intern_values) {
           intern_keys, intern_values);
 
   grpc_init();
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_mdelem a, b, c;
   a = grpc_mdelem_from_slices(
-      maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+      &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
       maybe_intern(grpc_slice_from_static_string("b"), intern_values));
   b = grpc_mdelem_from_slices(
-      maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+      &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
       maybe_intern(grpc_slice_from_static_string("b"), intern_values));
   c = grpc_mdelem_from_slices(
-      maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+      &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
       maybe_intern(grpc_slice_from_static_string("b"), intern_values));
   GPR_ASSERT(grpc_mdelem_eq(a, a));
   GPR_ASSERT(grpc_mdelem_eq(b, b));
@@ -206,10 +216,10 @@ static void test_identity_laws(bool intern_keys, bool intern_values) {
     GPR_ASSERT(a.payload != c.payload);
     GPR_ASSERT(b.payload != c.payload);
   }
-  GRPC_MDELEM_UNREF(a);
-  GRPC_MDELEM_UNREF(b);
-  GRPC_MDELEM_UNREF(c);
-
+  GRPC_MDELEM_UNREF(&exec_ctx, a);
+  GRPC_MDELEM_UNREF(&exec_ctx, b);
+  GRPC_MDELEM_UNREF(&exec_ctx, c);
+  grpc_exec_ctx_finish(&exec_ctx);
   grpc_shutdown();
 }
 
@@ -225,7 +235,7 @@ static void test_things_stick_around(void) {
   gpr_log(GPR_INFO, "test_things_stick_around");
 
   grpc_init();
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   for (i = 0; i < nstrs; i++) {
     gpr_asprintf(&buffer, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%" PRIuPTR "x", i);
@@ -236,7 +246,7 @@ static void test_things_stick_around(void) {
 
   for (i = 0; i < nstrs; i++) {
     grpc_slice_ref_internal(strs[i]);
-    grpc_slice_unref_internal(strs[i]);
+    grpc_slice_unref_internal(&exec_ctx, strs[i]);
   }
 
   for (i = 0; i < nstrs; i++) {
@@ -248,17 +258,18 @@ static void test_things_stick_around(void) {
   }
 
   for (i = 0; i < nstrs; i++) {
-    grpc_slice_unref_internal(strs[shuf[i]]);
+    grpc_slice_unref_internal(&exec_ctx, strs[shuf[i]]);
     for (j = i + 1; j < nstrs; j++) {
       gpr_asprintf(&buffer, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%" PRIuPTR "x",
                    shuf[j]);
       test = grpc_slice_intern(grpc_slice_from_static_string(buffer));
       GPR_ASSERT(grpc_slice_is_equivalent(test, strs[shuf[j]]));
-      grpc_slice_unref_internal(test);
+      grpc_slice_unref_internal(&exec_ctx, test);
       gpr_free(buffer);
     }
   }
 
+  grpc_exec_ctx_finish(&exec_ctx);
   grpc_shutdown();
   gpr_free(strs);
   gpr_free(shuf);
@@ -271,38 +282,39 @@ static void test_user_data_works(void) {
   gpr_log(GPR_INFO, "test_user_data_works");
 
   grpc_init();
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   ud1 = static_cast<int*>(gpr_malloc(sizeof(int)));
   *ud1 = 1;
   ud2 = static_cast<int*>(gpr_malloc(sizeof(int)));
   *ud2 = 2;
   md = grpc_mdelem_from_slices(
-      grpc_slice_intern(grpc_slice_from_static_string("abc")),
+      &exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("abc")),
       grpc_slice_intern(grpc_slice_from_static_string("123")));
   grpc_mdelem_set_user_data(md, gpr_free, ud1);
   grpc_mdelem_set_user_data(md, gpr_free, ud2);
   GPR_ASSERT(grpc_mdelem_get_user_data(md, gpr_free) == ud1);
-  GRPC_MDELEM_UNREF(md);
-
+  GRPC_MDELEM_UNREF(&exec_ctx, md);
+  grpc_exec_ctx_finish(&exec_ctx);
   grpc_shutdown();
 }
 
-static void verify_ascii_header_size(const char* key, const char* value,
-                                     bool intern_key, bool intern_value) {
+static void verify_ascii_header_size(grpc_exec_ctx* exec_ctx, const char* key,
+                                     const char* value, bool intern_key,
+                                     bool intern_value) {
   grpc_mdelem elem = grpc_mdelem_from_slices(
-      maybe_intern(grpc_slice_from_static_string(key), intern_key),
+      exec_ctx, maybe_intern(grpc_slice_from_static_string(key), intern_key),
       maybe_intern(grpc_slice_from_static_string(value), intern_value));
   size_t elem_size = grpc_mdelem_get_size_in_hpack_table(elem, false);
   size_t expected_size = 32 + strlen(key) + strlen(value);
   GPR_ASSERT(expected_size == elem_size);
-  GRPC_MDELEM_UNREF(elem);
+  GRPC_MDELEM_UNREF(exec_ctx, elem);
 }
 
-static void verify_binary_header_size(const char* key, const uint8_t* value,
-                                      size_t value_len, bool intern_key,
-                                      bool intern_value) {
+static void verify_binary_header_size(grpc_exec_ctx* exec_ctx, const char* key,
+                                      const uint8_t* value, size_t value_len,
+                                      bool intern_key, bool intern_value) {
   grpc_mdelem elem = grpc_mdelem_from_slices(
-      maybe_intern(grpc_slice_from_static_string(key), intern_key),
+      exec_ctx, maybe_intern(grpc_slice_from_static_string(key), intern_key),
       maybe_intern(grpc_slice_from_static_buffer(value, value_len),
                    intern_value));
   GPR_ASSERT(grpc_is_binary_header(GRPC_MDKEY(elem)));
@@ -312,9 +324,9 @@ static void verify_binary_header_size(const char* key, const uint8_t* value,
   grpc_slice base64_encoded = grpc_chttp2_base64_encode(value_slice);
   size_t expected_size = 32 + strlen(key) + GRPC_SLICE_LENGTH(base64_encoded);
   GPR_ASSERT(expected_size == elem_size);
-  grpc_slice_unref_internal(value_slice);
-  grpc_slice_unref_internal(base64_encoded);
-  GRPC_MDELEM_UNREF(elem);
+  grpc_slice_unref_internal(exec_ctx, value_slice);
+  grpc_slice_unref_internal(exec_ctx, base64_encoded);
+  GRPC_MDELEM_UNREF(exec_ctx, elem);
 }
 
 #define BUFFER_SIZE 64
@@ -322,23 +334,27 @@ static void test_mdelem_sizes_in_hpack(bool intern_key, bool intern_value) {
   gpr_log(GPR_INFO, "test_mdelem_size: intern_key=%d intern_value=%d",
           intern_key, intern_value);
   grpc_init();
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   uint8_t binary_value[BUFFER_SIZE] = {0};
   for (uint8_t i = 0; i < BUFFER_SIZE; i++) {
     binary_value[i] = i;
   }
 
-  verify_ascii_header_size("hello", "world", intern_key, intern_value);
-  verify_ascii_header_size("hello", "worldxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-                           intern_key, intern_value);
-  verify_ascii_header_size(":scheme", "http", intern_key, intern_value);
+  verify_ascii_header_size(&exec_ctx, "hello", "world", intern_key,
+                           intern_value);
+  verify_ascii_header_size(&exec_ctx, "hello",
+                           "worldxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", intern_key,
+                           intern_value);
+  verify_ascii_header_size(&exec_ctx, ":scheme", "http", intern_key,
+                           intern_value);
 
   for (uint8_t i = 0; i < BUFFER_SIZE; i++) {
-    verify_binary_header_size("hello-bin", binary_value, i, intern_key,
-                              intern_value);
+    verify_binary_header_size(&exec_ctx, "hello-bin", binary_value, i,
+                              intern_key, intern_value);
   }
 
+  grpc_exec_ctx_finish(&exec_ctx);
   grpc_shutdown();
 }
 
@@ -346,13 +362,13 @@ static void test_copied_static_metadata(bool dup_key, bool dup_value) {
   gpr_log(GPR_INFO, "test_static_metadata: dup_key=%d dup_value=%d", dup_key,
           dup_value);
   grpc_init();
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   for (size_t i = 0; i < GRPC_STATIC_MDELEM_COUNT; i++) {
     grpc_mdelem p = GRPC_MAKE_MDELEM(&grpc_static_mdelem_table[i],
                                      GRPC_MDELEM_STORAGE_STATIC);
     grpc_mdelem q =
-        grpc_mdelem_from_slices(maybe_dup(GRPC_MDKEY(p), dup_key),
+        grpc_mdelem_from_slices(&exec_ctx, maybe_dup(GRPC_MDKEY(p), dup_key),
                                 maybe_dup(GRPC_MDVALUE(p), dup_value));
     GPR_ASSERT(grpc_mdelem_eq(p, q));
     if (dup_key || dup_value) {
@@ -360,16 +376,16 @@ static void test_copied_static_metadata(bool dup_key, bool dup_value) {
     } else {
       GPR_ASSERT(p.payload == q.payload);
     }
-    GRPC_MDELEM_UNREF(p);
-    GRPC_MDELEM_UNREF(q);
+    GRPC_MDELEM_UNREF(&exec_ctx, p);
+    GRPC_MDELEM_UNREF(&exec_ctx, q);
   }
 
+  grpc_exec_ctx_finish(&exec_ctx);
   grpc_shutdown();
 }
 
 int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
-  grpc_init();
   test_no_op();
   for (int k = 0; k <= 1; k++) {
     for (int v = 0; v <= 1; v++) {
@@ -384,6 +400,5 @@ int main(int argc, char** argv) {
   test_create_many_persistant_metadata();
   test_things_stick_around();
   test_user_data_works();
-  grpc_shutdown();
   return 0;
 }
diff --git a/test/core/transport/status_conversion_test.cc b/test/core/transport/status_conversion_test.cc
index 1ed6ccfba6..7af5d12cb7 100644
--- a/test/core/transport/status_conversion_test.cc
+++ b/test/core/transport/status_conversion_test.cc
@@ -22,11 +22,12 @@
 
 #define GRPC_STATUS_TO_HTTP2_ERROR(a, b) \
   GPR_ASSERT(grpc_status_to_http2_error(a) == (b))
-#define HTTP2_ERROR_TO_GRPC_STATUS(a, deadline, b)                   \
-  do {                                                               \
-    grpc_core::ExecCtx exec_ctx;                                     \
-    GPR_ASSERT(grpc_http2_error_to_grpc_status(a, deadline) == (b)); \
-                                                                     \
+#define HTTP2_ERROR_TO_GRPC_STATUS(a, deadline, b)                           \
+  do {                                                                       \
+    grpc_exec_ctx my_exec_ctx = GRPC_EXEC_CTX_INIT;                          \
+    GPR_ASSERT(grpc_http2_error_to_grpc_status(&my_exec_ctx, a, deadline) == \
+               (b));                                                         \
+    grpc_exec_ctx_finish(&my_exec_ctx);                                      \
   } while (0)
 #define GRPC_STATUS_TO_HTTP2_STATUS(a, b) \
   GPR_ASSERT(grpc_status_to_http2_status(a) == (b))
diff --git a/test/core/transport/stream_owned_slice_test.cc b/test/core/transport/stream_owned_slice_test.cc
index 7831f67a04..e82df2117d 100644
--- a/test/core/transport/stream_owned_slice_test.cc
+++ b/test/core/transport/stream_owned_slice_test.cc
@@ -20,14 +20,12 @@
 
 #include "test/core/util/test_config.h"
 
-#include <grpc/grpc.h>
 #include <grpc/support/log.h>
 
-static void do_nothing(void* arg, grpc_error* error) {}
+static void do_nothing(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {}
 
 int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
-  grpc_init();
 
   uint8_t buffer[] = "abc123";
   grpc_stream_refcount r;
@@ -41,6 +39,5 @@ int main(int argc, char** argv) {
   grpc_slice_unref(slice);
   GPR_ASSERT(r.refs.count == 1);
 
-  grpc_shutdown();
   return 0;
 }