Removing instances of exec_ctx being passed around in functions in

src/core. exec_ctx is now a thread_local pointer of type ExecCtx instead of
grpc_exec_ctx which is initialized whenever ExecCtx is instantiated. ExecCtx
also keeps track of the previous exec_ctx so that nesting of exec_ctx is
allowed. This means that there is only one exec_ctx being used at any
time. Also, grpc_exec_ctx_finish is called in the destructor of the
object, and the previous exec_ctx is restored to avoid breaking current
functionality. The code still explicitly calls grpc_exec_ctx_finish
because removing all such instances causes the code to break.

12 files changed, 500 insertions, 413 deletions

diff --git a/test/core/transport/bdp_estimator_test.cc b/test/core/transport/bdp_estimator_test.cc
index 7ac35016c0..cf1b422043 100644
--- a/test/core/transport/bdp_estimator_test.cc
+++ b/test/core/transport/bdp_estimator_test.cc
@@ -23,92 +23,97 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/useful.h>
-#include <gtest/gtest.h>
 #include <limits.h>
 #include "src/core/lib/iomgr/timer_manager.h"
 #include "src/core/lib/support/string.h"
 #include "test/core/util/test_config.h"
 
-extern "C" gpr_timespec (*gpr_now_impl)(gpr_clock_type clock_type);
+extern gpr_timespec (*gpr_now_impl)(gpr_clock_type clock_type);
 
-namespace grpc_core {
-namespace testing {
-namespace {
-int g_clock = 0;
+static int g_clock = 0;
 
-gpr_timespec fake_gpr_now(gpr_clock_type clock_type) {
-  gpr_timespec ts;
-  ts.tv_sec = g_clock;
-  ts.tv_nsec = 0;
-  ts.clock_type = clock_type;
-  return ts;
+static gpr_timespec fake_gpr_now(gpr_clock_type clock_type) {
+  return (gpr_timespec){
+      .tv_sec = g_clock, .tv_nsec = 0, .clock_type = clock_type,
+  };
 }
 
-void inc_time(void) { g_clock += 30; }
-}  // namespace
+static void inc_time(void) { g_clock += 30; }
 
-TEST(BdpEstimatorTest, NoOp) { BdpEstimator est("test"); }
+static void test_noop(void) {
+  gpr_log(GPR_INFO, "test_noop");
+  grpc_bdp_estimator est;
+  grpc_bdp_estimator_init(&est, "test");
+}
 
-TEST(BdpEstimatorTest, EstimateBdpNoSamples) {
-  BdpEstimator est("test");
+static void test_get_estimate_no_samples(void) {
+  gpr_log(GPR_INFO, "test_get_estimate_no_samples");
+  grpc_bdp_estimator est;
+  grpc_bdp_estimator_init(&est, "test");
   int64_t estimate;
-  est.EstimateBdp(&estimate);
+  grpc_bdp_estimator_get_estimate(&est, &estimate);
 }
 
-namespace {
-void AddSamples(BdpEstimator *estimator, int64_t *samples, size_t n) {
-  estimator->AddIncomingBytes(1234567);
+static void add_samples(grpc_bdp_estimator *estimator, int64_t *samples,
+                        size_t n) {
+  grpc_bdp_estimator_add_incoming_bytes(estimator, 1234567);
   inc_time();
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  estimator->SchedulePing();
-  estimator->StartPing();
+
+  GPR_ASSERT(grpc_bdp_estimator_need_ping(estimator) == true);
+  grpc_bdp_estimator_schedule_ping(estimator);
+  grpc_bdp_estimator_start_ping(estimator);
+
   for (size_t i = 0; i < n; i++) {
-    estimator->AddIncomingBytes(samples[i]);
+    grpc_bdp_estimator_add_incoming_bytes(estimator, samples[i]);
+    GPR_ASSERT(grpc_bdp_estimator_need_ping(estimator) == false);
   }
   gpr_sleep_until(gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
                                gpr_time_from_millis(1, GPR_TIMESPAN)));
-  grpc_exec_ctx_invalidate_now(&exec_ctx);
-  estimator->CompletePing(&exec_ctx);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_bdp_estimator_complete_ping(estimator);
+  grpc_exec_ctx_finish();
 }
 
-void AddSample(BdpEstimator *estimator, int64_t sample) {
-  AddSamples(estimator, &sample, 1);
+static void add_sample(grpc_bdp_estimator *estimator, int64_t sample) {
+  add_samples(estimator, &sample, 1);
 }
-}  // namespace
 
-TEST(BdpEstimatorTest, GetEstimate1Sample) {
-  BdpEstimator est("test");
-  AddSample(&est, 100);
+static void test_get_estimate_1_sample(void) {
+  gpr_log(GPR_INFO, "test_get_estimate_1_sample");
+  grpc_bdp_estimator est;
+  grpc_bdp_estimator_init(&est, "test");
+  add_sample(&est, 100);
   int64_t estimate;
-  est.EstimateBdp(&estimate);
+  grpc_bdp_estimator_get_estimate(&est, &estimate);
 }
 
-TEST(BdpEstimatorTest, GetEstimate2Samples) {
-  BdpEstimator est("test");
-  AddSample(&est, 100);
-  AddSample(&est, 100);
+static void test_get_estimate_2_samples(void) {
+  gpr_log(GPR_INFO, "test_get_estimate_2_samples");
+  grpc_bdp_estimator est;
+  grpc_bdp_estimator_init(&est, "test");
+  add_sample(&est, 100);
+  add_sample(&est, 100);
   int64_t estimate;
-  est.EstimateBdp(&estimate);
+  grpc_bdp_estimator_get_estimate(&est, &estimate);
 }
 
-TEST(BdpEstimatorTest, GetEstimate3Samples) {
-  BdpEstimator est("test");
-  AddSample(&est, 100);
-  AddSample(&est, 100);
-  AddSample(&est, 100);
-  int64_t estimate;
-  est.EstimateBdp(&estimate);
-}
-
-namespace {
-static int64_t GetEstimate(const BdpEstimator &estimator) {
+static int64_t get_estimate(grpc_bdp_estimator *estimator) {
   int64_t out;
-  EXPECT_TRUE(estimator.EstimateBdp(&out));
+  GPR_ASSERT(grpc_bdp_estimator_get_estimate(estimator, &out));
   return out;
 }
 
-int64_t NextPow2(int64_t v) {
+static void test_get_estimate_3_samples(void) {
+  gpr_log(GPR_INFO, "test_get_estimate_3_samples");
+  grpc_bdp_estimator est;
+  grpc_bdp_estimator_init(&est, "test");
+  add_sample(&est, 100);
+  add_sample(&est, 100);
+  add_sample(&est, 100);
+  int64_t estimate;
+  grpc_bdp_estimator_get_estimate(&est, &estimate);
+}
+
+static int64_t next_pow_2(int64_t v) {
   v--;
   v |= v >> 1;
   v |= v >> 2;
@@ -119,40 +124,40 @@ int64_t NextPow2(int64_t v) {
   v++;
   return v;
 }
-}  // namespace
-
-class BdpEstimatorRandomTest : public ::testing::TestWithParam<size_t> {};
 
-TEST_P(BdpEstimatorRandomTest, GetEstimateRandomValues) {
-  BdpEstimator est("test");
+static void test_get_estimate_random_values(size_t n) {
+  gpr_log(GPR_INFO, "test_get_estimate_random_values(%" PRIdPTR ")", n);
+  grpc_bdp_estimator est;
+  grpc_bdp_estimator_init(&est, "test");
   const int kMaxSample = 65535;
   int min = kMaxSample;
   int max = 0;
-  for (size_t i = 0; i < GetParam(); i++) {
+  for (size_t i = 0; i < n; i++) {
     int sample = rand() % (kMaxSample + 1);
     if (sample < min) min = sample;
     if (sample > max) max = sample;
-    AddSample(&est, sample);
+    add_sample(&est, sample);
     if (i >= 3) {
-      EXPECT_LE(GetEstimate(est), GPR_MAX(65536, 2 * NextPow2(max)))
-          << " min:" << min << " max:" << max << " sample:" << sample;
+      gpr_log(GPR_DEBUG, "est:%" PRId64 " min:%d max:%d", get_estimate(&est),
+              min, max);
+      GPR_ASSERT(get_estimate(&est) <= GPR_MAX(65536, 2 * next_pow_2(max)));
     }
   }
 }
 
-INSTANTIATE_TEST_CASE_P(TooManyNames, BdpEstimatorRandomTest,
-                        ::testing::Values(3, 4, 6, 9, 13, 19, 28, 42, 63, 94,
-                                          141, 211, 316, 474, 711));
-}  // namespace testing
-}  // namespace grpc_core
-
 int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
-  gpr_now_impl = grpc_core::testing::fake_gpr_now;
+  gpr_now_impl = fake_gpr_now;
   grpc_init();
   grpc_timer_manager_set_threading(false);
-  ::testing::InitGoogleTest(&argc, argv);
-  int ret = RUN_ALL_TESTS();
+  test_noop();
+  test_get_estimate_no_samples();
+  test_get_estimate_1_sample();
+  test_get_estimate_2_samples();
+  test_get_estimate_3_samples();
+  for (size_t i = 3; i < 1000; i = i * 3 / 2) {
+    test_get_estimate_random_values(i);
+  }
   grpc_shutdown();
-  return ret;
+  return 0;
 }
diff --git a/test/core/transport/byte_stream_test.c b/test/core/transport/byte_stream_test.c
index a0c5f961cf..3516c191e2 100644
--- a/test/core/transport/byte_stream_test.c
+++ b/test/core/transport/byte_stream_test.c
@@ -30,14 +30,13 @@
 // grpc_slice_buffer_stream tests
 //
 
-static void not_called_closure(grpc_exec_ctx *exec_ctx, void *arg,
-                               grpc_error *error) {
+static void not_called_closure(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_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  exec_ctx = GRPC_EXEC_CTX_INIT;
   // Create and populate slice buffer.
   grpc_slice_buffer buffer;
   grpc_slice_buffer_init(&buffer);
@@ -57,23 +56,22 @@ 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(&exec_ctx, &stream.base, ~(size_t)0, &closure));
+    GPR_ASSERT(grpc_byte_stream_next(&stream.base, ~(size_t)0, &closure));
     grpc_slice output;
-    grpc_error *error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
+    grpc_error *error = grpc_byte_stream_pull(&stream.base, &output);
     GPR_ASSERT(error == GRPC_ERROR_NONE);
     GPR_ASSERT(grpc_slice_eq(input[i], output));
-    grpc_slice_unref_internal(&exec_ctx, output);
+    grpc_slice_unref_internal(output);
   }
   // Clean up.
-  grpc_byte_stream_destroy(&exec_ctx, &stream.base);
-  grpc_slice_buffer_destroy_internal(&exec_ctx, &buffer);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_byte_stream_destroy(&stream.base);
+  grpc_slice_buffer_destroy_internal(&buffer);
+  grpc_exec_ctx_finish();
 }
 
 static void test_slice_buffer_stream_shutdown(void) {
   gpr_log(GPR_DEBUG, "test_slice_buffer_stream_shutdown");
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  exec_ctx = GRPC_EXEC_CTX_INIT;
   // Create and populate slice buffer.
   grpc_slice_buffer buffer;
   grpc_slice_buffer_init(&buffer);
@@ -92,29 +90,26 @@ static void test_slice_buffer_stream_shutdown(void) {
   GRPC_CLOSURE_INIT(&closure, not_called_closure, NULL,
                     grpc_schedule_on_exec_ctx);
   // Read the first slice.
-  GPR_ASSERT(
-      grpc_byte_stream_next(&exec_ctx, &stream.base, ~(size_t)0, &closure));
+  GPR_ASSERT(grpc_byte_stream_next(&stream.base, ~(size_t)0, &closure));
   grpc_slice output;
-  grpc_error *error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
+  grpc_error *error = grpc_byte_stream_pull(&stream.base, &output);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(grpc_slice_eq(input[0], output));
-  grpc_slice_unref_internal(&exec_ctx, output);
+  grpc_slice_unref_internal(output);
   // Now shutdown.
   grpc_error *shutdown_error =
       GRPC_ERROR_CREATE_FROM_STATIC_STRING("shutdown error");
-  grpc_byte_stream_shutdown(&exec_ctx, &stream.base,
-                            GRPC_ERROR_REF(shutdown_error));
+  grpc_byte_stream_shutdown(&stream.base, GRPC_ERROR_REF(shutdown_error));
   // After shutdown, the next pull() should return the error.
-  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(grpc_byte_stream_next(&stream.base, ~(size_t)0, &closure));
+  error = grpc_byte_stream_pull(&stream.base, &output);
   GPR_ASSERT(error == shutdown_error);
   GRPC_ERROR_UNREF(error);
   GRPC_ERROR_UNREF(shutdown_error);
   // Clean up.
-  grpc_byte_stream_destroy(&exec_ctx, &stream.base);
-  grpc_slice_buffer_destroy_internal(&exec_ctx, &buffer);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_byte_stream_destroy(&stream.base);
+  grpc_slice_buffer_destroy_internal(&buffer);
+  grpc_exec_ctx_finish();
 }
 
 //
@@ -123,7 +118,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_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  exec_ctx = GRPC_EXEC_CTX_INIT;
   // Create and populate slice buffer byte stream.
   grpc_slice_buffer buffer;
   grpc_slice_buffer_init(&buffer);
@@ -147,24 +142,23 @@ 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(&exec_ctx, &stream.base, ~(size_t)0, &closure));
+    GPR_ASSERT(grpc_byte_stream_next(&stream.base, ~(size_t)0, &closure));
     grpc_slice output;
-    grpc_error *error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
+    grpc_error *error = grpc_byte_stream_pull(&stream.base, &output);
     GPR_ASSERT(error == GRPC_ERROR_NONE);
     GPR_ASSERT(grpc_slice_eq(input[i], output));
-    grpc_slice_unref_internal(&exec_ctx, output);
+    grpc_slice_unref_internal(output);
   }
   // Clean up.
-  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);
+  grpc_byte_stream_destroy(&stream.base);
+  grpc_byte_stream_cache_destroy(&cache);
+  grpc_slice_buffer_destroy_internal(&buffer);
+  grpc_exec_ctx_finish();
 }
 
 static void test_caching_byte_stream_reset(void) {
   gpr_log(GPR_DEBUG, "test_caching_byte_stream_reset");
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  exec_ctx = GRPC_EXEC_CTX_INIT;
   // Create and populate slice buffer byte stream.
   grpc_slice_buffer buffer;
   grpc_slice_buffer_init(&buffer);
@@ -186,34 +180,32 @@ static void test_caching_byte_stream_reset(void) {
   GRPC_CLOSURE_INIT(&closure, not_called_closure, NULL,
                     grpc_schedule_on_exec_ctx);
   // Read one slice.
-  GPR_ASSERT(
-      grpc_byte_stream_next(&exec_ctx, &stream.base, ~(size_t)0, &closure));
+  GPR_ASSERT(grpc_byte_stream_next(&stream.base, ~(size_t)0, &closure));
   grpc_slice output;
-  grpc_error *error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
+  grpc_error *error = grpc_byte_stream_pull(&stream.base, &output);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(grpc_slice_eq(input[0], output));
-  grpc_slice_unref_internal(&exec_ctx, output);
+  grpc_slice_unref_internal(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(&exec_ctx, &stream.base, ~(size_t)0, &closure));
-    error = grpc_byte_stream_pull(&exec_ctx, &stream.base, &output);
+    GPR_ASSERT(grpc_byte_stream_next(&stream.base, ~(size_t)0, &closure));
+    error = grpc_byte_stream_pull(&stream.base, &output);
     GPR_ASSERT(error == GRPC_ERROR_NONE);
     GPR_ASSERT(grpc_slice_eq(input[i], output));
-    grpc_slice_unref_internal(&exec_ctx, output);
+    grpc_slice_unref_internal(output);
   }
   // Clean up.
-  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);
+  grpc_byte_stream_destroy(&stream.base);
+  grpc_byte_stream_cache_destroy(&cache);
+  grpc_slice_buffer_destroy_internal(&buffer);
+  grpc_exec_ctx_finish();
 }
 
 static void test_caching_byte_stream_shared_cache(void) {
   gpr_log(GPR_DEBUG, "test_caching_byte_stream_shared_cache");
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  exec_ctx = GRPC_EXEC_CTX_INIT;
   // Create and populate slice buffer byte stream.
   grpc_slice_buffer buffer;
   grpc_slice_buffer_init(&buffer);
@@ -237,35 +229,32 @@ static void test_caching_byte_stream_shared_cache(void) {
   GRPC_CLOSURE_INIT(&closure, not_called_closure, NULL,
                     grpc_schedule_on_exec_ctx);
   // Read one slice from stream1.
-  GPR_ASSERT(
-      grpc_byte_stream_next(&exec_ctx, &stream1.base, ~(size_t)0, &closure));
+  GPR_ASSERT(grpc_byte_stream_next(&stream1.base, ~(size_t)0, &closure));
   grpc_slice output;
-  grpc_error *error = grpc_byte_stream_pull(&exec_ctx, &stream1.base, &output);
+  grpc_error *error = grpc_byte_stream_pull(&stream1.base, &output);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(grpc_slice_eq(input[0], output));
-  grpc_slice_unref_internal(&exec_ctx, output);
+  grpc_slice_unref_internal(output);
   // Read all slices from stream2.
   for (size_t i = 0; i < GPR_ARRAY_SIZE(input); ++i) {
-    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(grpc_byte_stream_next(&stream2.base, ~(size_t)0, &closure));
+    error = grpc_byte_stream_pull(&stream2.base, &output);
     GPR_ASSERT(error == GRPC_ERROR_NONE);
     GPR_ASSERT(grpc_slice_eq(input[i], output));
-    grpc_slice_unref_internal(&exec_ctx, output);
+    grpc_slice_unref_internal(output);
   }
   // Now read the second slice from stream1.
-  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(grpc_byte_stream_next(&stream1.base, ~(size_t)0, &closure));
+  error = grpc_byte_stream_pull(&stream1.base, &output);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(grpc_slice_eq(input[1], output));
-  grpc_slice_unref_internal(&exec_ctx, output);
+  grpc_slice_unref_internal(output);
   // Clean up.
-  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);
+  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_exec_ctx_finish();
 }
 
 int main(int argc, char **argv) {
diff --git a/test/core/transport/chttp2/bin_decoder_test.c b/test/core/transport/chttp2/bin_decoder_test.c
index 775161ec91..824b756398 100644
--- a/test/core/transport/chttp2/bin_decoder_test.c
+++ b/test/core/transport/chttp2/bin_decoder_test.c
@@ -29,8 +29,8 @@
 
 static int all_ok = 1;
 
-static void expect_slice_eq(grpc_exec_ctx *exec_ctx, grpc_slice expected,
-                            grpc_slice slice, char *debug, int line) {
+static void expect_slice_eq(grpc_slice expected, grpc_slice slice, 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);
@@ -40,104 +40,94 @@ static void expect_slice_eq(grpc_exec_ctx *exec_ctx, grpc_slice expected,
     gpr_free(he);
     all_ok = 0;
   }
-  grpc_slice_unref_internal(exec_ctx, expected);
-  grpc_slice_unref_internal(exec_ctx, slice);
+  grpc_slice_unref_internal(expected);
+  grpc_slice_unref_internal(slice);
 }
 
-static grpc_slice base64_encode(grpc_exec_ctx *exec_ctx, const char *s) {
+static grpc_slice base64_encode(const char *s) {
   grpc_slice ss = grpc_slice_from_copied_string(s);
   grpc_slice out = grpc_chttp2_base64_encode(ss);
-  grpc_slice_unref_internal(exec_ctx, ss);
+  grpc_slice_unref_internal(ss);
   return out;
 }
 
-static grpc_slice base64_decode(grpc_exec_ctx *exec_ctx, const char *s) {
+static grpc_slice base64_decode(const char *s) {
   grpc_slice ss = grpc_slice_from_copied_string(s);
-  grpc_slice out = grpc_chttp2_base64_decode(exec_ctx, ss);
-  grpc_slice_unref_internal(exec_ctx, ss);
+  grpc_slice out = grpc_chttp2_base64_decode(ss);
+  grpc_slice_unref_internal(ss);
   return out;
 }
 
-static grpc_slice base64_decode_with_length(grpc_exec_ctx *exec_ctx,
-                                            const char *s,
+static grpc_slice base64_decode_with_length(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(exec_ctx, ss, output_length);
-  grpc_slice_unref_internal(exec_ctx, ss);
+  grpc_slice out = grpc_chttp2_base64_decode_with_length(ss, output_length);
+  grpc_slice_unref_internal(ss);
   return out;
 }
 
-#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 EXPECT_SLICE_EQ(expected, slice)                                    \
+  expect_slice_eq(                                                          \
+      grpc_slice_from_copied_buffer(expected, sizeof(expected) - 1), slice, \
+      #slice, __LINE__);
 
-#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)));
+#define ENCODE_AND_DECODE(s) \
+  EXPECT_SLICE_EQ(           \
+      s, grpc_chttp2_base64_decode_with_length(base64_encode(s), strlen(s)));
 
 int main(int argc, char **argv) {
-  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("");
+  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(&exec_ctx, "\xc0\xc1\xc2\xc3\xc4\xc5");
+  ENCODE_AND_DECODE("\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, ""));
+  EXPECT_SLICE_EQ("", base64_decode(""));
   /* BASE64("f") = "Zg==" */
-  EXPECT_SLICE_EQ(&exec_ctx, "f", base64_decode(&exec_ctx, "Zg=="));
+  EXPECT_SLICE_EQ("f", base64_decode("Zg=="));
   /* BASE64("fo") = "Zm8=" */
-  EXPECT_SLICE_EQ(&exec_ctx, "fo", base64_decode(&exec_ctx, "Zm8="));
+  EXPECT_SLICE_EQ("fo", base64_decode("Zm8="));
   /* BASE64("foo") = "Zm9v" */
-  EXPECT_SLICE_EQ(&exec_ctx, "foo", base64_decode(&exec_ctx, "Zm9v"));
+  EXPECT_SLICE_EQ("foo", base64_decode("Zm9v"));
   /* BASE64("foob") = "Zm9vYg==" */
-  EXPECT_SLICE_EQ(&exec_ctx, "foob", base64_decode(&exec_ctx, "Zm9vYg=="));
+  EXPECT_SLICE_EQ("foob", base64_decode("Zm9vYg=="));
   /* BASE64("fooba") = "Zm9vYmE=" */
-  EXPECT_SLICE_EQ(&exec_ctx, "fooba", base64_decode(&exec_ctx, "Zm9vYmE="));
+  EXPECT_SLICE_EQ("fooba", base64_decode("Zm9vYmE="));
   /* BASE64("foobar") = "Zm9vYmFy" */
-  EXPECT_SLICE_EQ(&exec_ctx, "foobar", base64_decode(&exec_ctx, "Zm9vYmFy"));
+  EXPECT_SLICE_EQ("foobar", base64_decode("Zm9vYmFy"));
 
-  EXPECT_SLICE_EQ(&exec_ctx, "\xc0\xc1\xc2\xc3\xc4\xc5",
-                  base64_decode(&exec_ctx, "wMHCw8TF"));
+  EXPECT_SLICE_EQ("\xc0\xc1\xc2\xc3\xc4\xc5", base64_decode("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"));
+  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(&exec_ctx, "", base64_decode(&exec_ctx, "Zm:v"));
-  EXPECT_SLICE_EQ(&exec_ctx, "", base64_decode(&exec_ctx, "Zm=v"));
+  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(&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));
+  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(&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));
+  EXPECT_SLICE_EQ("", base64_decode_with_length("Zm:v", 3));
+  EXPECT_SLICE_EQ("", base64_decode_with_length("Zm=v", 3));
 
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
 
   return all_ok ? 0 : 1;
 }
diff --git a/test/core/transport/chttp2/bin_decoder_test.cc b/test/core/transport/chttp2/bin_decoder_test.cc
new file mode 100644
index 0000000000..d426731dae
--- /dev/null
+++ b/test/core/transport/chttp2/bin_decoder_test.cc
@@ -0,0 +1,135 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/core/ext/transport/chttp2/transport/bin_decoder.h"
+
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include "src/core/ext/transport/chttp2/transport/bin_encoder.h"
+#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/lib/support/string.h"
+
+static int all_ok = 1;
+
+static void expect_slice_eq(grpc_slice expected, grpc_slice slice, 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);
+    gpr_log(GPR_ERROR, "FAILED:%d: %s\ngot:  %s\nwant: %s", line, debug, hs,
+            he);
+    gpr_free(hs);
+    gpr_free(he);
+    all_ok = 0;
+  }
+  grpc_slice_unref_internal(expected);
+  grpc_slice_unref_internal(slice);
+}
+
+static grpc_slice base64_encode(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);
+  return out;
+}
+
+static grpc_slice base64_decode(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);
+  return out;
+}
+
+static grpc_slice base64_decode_with_length(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);
+  return out;
+}
+
+#define EXPECT_SLICE_EQ(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( \
+                         exec_ctx, base64_encode(s), strlen(s)));
+
+int main(int argc, char **argv) {
+  ExecCtx _local_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_exec_ctx_finish();
+
+  return all_ok ? 0 : 1;
+}
diff --git a/test/core/transport/chttp2/hpack_encoder_test.c b/test/core/transport/chttp2/hpack_encoder_test.c
index ed51dd1859..f3690fc410 100644
--- a/test/core/transport/chttp2/hpack_encoder_test.c
+++ b/test/core/transport/chttp2/hpack_encoder_test.c
@@ -45,7 +45,7 @@ size_t cap_to_delete = 0;
 
 /* verify that the output generated by encoding the stream matches the
    hexstring passed in */
-static void verify(grpc_exec_ctx *exec_ctx, size_t window_available, bool eof,
+static void verify(size_t window_available, bool eof,
                    bool use_true_binary_metadata, size_t expect_window_used,
                    const char *expected, size_t nheaders, ...) {
   grpc_slice_buffer output;
@@ -67,7 +67,7 @@ static void verify(grpc_exec_ctx *exec_ctx, size_t window_available, bool eof,
       e[i].prev = &e[i - 1];
     }
     e[i].md = grpc_mdelem_from_slices(
-        exec_ctx, grpc_slice_intern(grpc_slice_from_static_string(key)),
+        grpc_slice_intern(grpc_slice_from_static_string(key)),
         grpc_slice_intern(grpc_slice_from_static_string(value)));
   }
   e[0].prev = NULL;
@@ -95,11 +95,10 @@ static void verify(grpc_exec_ctx *exec_ctx, size_t window_available, bool eof,
       .max_frame_size = 16384,
       .stats = &stats,
   };
-  grpc_chttp2_encode_header(exec_ctx, &g_compressor, NULL, 0, &b, &hopt,
-                            &output);
+  grpc_chttp2_encode_header(&g_compressor, NULL, 0, &b, &hopt, &output);
   merged = grpc_slice_merge(output.slices, output.count);
-  grpc_slice_buffer_destroy_internal(exec_ctx, &output);
-  grpc_metadata_batch_destroy(exec_ctx, &b);
+  grpc_slice_buffer_destroy_internal(&output);
+  grpc_metadata_batch_destroy(&b);
 
   if (!grpc_slice_eq(merged, expect)) {
     char *expect_str = grpc_dump_slice(expect, GPR_DUMP_HEX | GPR_DUMP_ASCII);
@@ -112,35 +111,32 @@ static void verify(grpc_exec_ctx *exec_ctx, size_t window_available, bool eof,
     g_failure = 1;
   }
 
-  grpc_slice_unref_internal(exec_ctx, merged);
-  grpc_slice_unref_internal(exec_ctx, expect);
+  grpc_slice_unref_internal(merged);
+  grpc_slice_unref_internal(expect);
 }
 
-static void test_basic_headers(grpc_exec_ctx *exec_ctx) {
+static void test_basic_headers() {
   int i;
 
-  verify(exec_ctx, 0, false, false, 0, "000005 0104 deadbeef 40 0161 0161", 1,
-         "a", "a");
-  verify(exec_ctx, 0, false, false, 0, "000001 0104 deadbeef be", 1, "a", "a");
-  verify(exec_ctx, 0, false, false, 0, "000001 0104 deadbeef be", 1, "a", "a");
-  verify(exec_ctx, 0, false, false, 0, "000006 0104 deadbeef be 40 0162 0163",
-         2, "a", "a", "b", "c");
-  verify(exec_ctx, 0, false, false, 0, "000002 0104 deadbeef bf be", 2, "a",
+  verify(0, false, false, 0, "000005 0104 deadbeef 40 0161 0161", 1, "a", "a");
+  verify(0, false, false, 0, "000001 0104 deadbeef be", 1, "a", "a");
+  verify(0, false, false, 0, "000001 0104 deadbeef be", 1, "a", "a");
+  verify(0, false, false, 0, "000006 0104 deadbeef be 40 0162 0163", 2, "a",
          "a", "b", "c");
-  verify(exec_ctx, 0, false, false, 0, "000004 0104 deadbeef 7f 00 0164", 1,
-         "a", "d");
+  verify(0, false, false, 0, "000002 0104 deadbeef bf be", 2, "a", "a", "b",
+         "c");
+  verify(0, false, false, 0, "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(exec_ctx, 0, false, false, 0, "000003 0104 deadbeef c0 bf be", 3,
-           "a", "a", "b", "c", "a", "d");
+    verify(0, false, false, 0, "000003 0104 deadbeef c0 bf be", 3, "a", "a",
+           "b", "c", "a", "d");
   }
 
-  verify(exec_ctx, 0, false, false, 0, "000006 0104 deadbeef c0 00 016b 0176",
-         2, "a", "a", "k", "v");
+  verify(0, false, false, 0, "000006 0104 deadbeef c0 00 016b 0176", 2, "a",
+         "a", "k", "v");
   /* this could be 000004 0104 deadbeef 0f 30 0176 also */
-  verify(exec_ctx, 0, false, false, 0, "000004 0104 deadbeef 0f 2f 0176", 1,
-         "a", "v");
+  verify(0, false, false, 0, "000004 0104 deadbeef 0f 2f 0176", 1, "a", "v");
 }
 
 static void encode_int_to_str(int i, char *p) {
@@ -151,7 +147,7 @@ static void encode_int_to_str(int i, char *p) {
   p[2] = 0;
 }
 
-static void test_decode_table_overflow(grpc_exec_ctx *exec_ctx) {
+static void test_decode_table_overflow() {
   int i;
   char key[3], value[3];
   char *expect;
@@ -174,25 +170,24 @@ static void test_decode_table_overflow(grpc_exec_ctx *exec_ctx) {
     }
 
     if (i > 0) {
-      verify(exec_ctx, 0, false, false, 0, expect, 2, "aa", "ba", key, value);
+      verify(0, false, false, 0, expect, 2, "aa", "ba", key, value);
     } else {
-      verify(exec_ctx, 0, false, false, 0, expect, 1, key, value);
+      verify(0, false, false, 0, 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(exec_ctx, 0, false, false, 0, "000007 0104 deadbeef 40 026161 026261",
-         1, "aa", "ba");
+  verify(0, false, false, 0, "000007 0104 deadbeef 40 026161 026261", 1, "aa",
+         "ba");
 }
 
-static void verify_table_size_change_match_elem_size(grpc_exec_ctx *exec_ctx,
-                                                     const char *key,
+static void verify_table_size_change_match_elem_size(const char *key,
                                                      const char *value) {
   grpc_slice_buffer output;
   grpc_mdelem elem = grpc_mdelem_from_slices(
-      exec_ctx, grpc_slice_intern(grpc_slice_from_static_string(key)),
+      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);
   size_t initial_table_size = g_compressor.table_size;
@@ -214,27 +209,26 @@ static void verify_table_size_change_match_elem_size(grpc_exec_ctx *exec_ctx,
                                      .use_true_binary_metadata = false,
                                      .max_frame_size = 16384,
                                      .stats = &stats};
-  grpc_chttp2_encode_header(exec_ctx, &g_compressor, NULL, 0, &b, &hopt,
-                            &output);
-  grpc_slice_buffer_destroy_internal(exec_ctx, &output);
-  grpc_metadata_batch_destroy(exec_ctx, &b);
+  grpc_chttp2_encode_header(&g_compressor, NULL, 0, &b, &hopt, &output);
+  grpc_slice_buffer_destroy_internal(&output);
+  grpc_metadata_batch_destroy(&b);
 
   GPR_ASSERT(g_compressor.table_size == elem_size + initial_table_size);
   gpr_free(e);
 }
 
-static void test_encode_header_size(grpc_exec_ctx *exec_ctx) {
-  verify_table_size_change_match_elem_size(exec_ctx, "hello", "world");
-  verify_table_size_change_match_elem_size(exec_ctx, "hello-bin", "world");
+static void test_encode_header_size() {
+  verify_table_size_change_match_elem_size("hello", "world");
+  verify_table_size_change_match_elem_size("hello-bin", "world");
 }
 
-static void run_test(void (*test)(grpc_exec_ctx *exec_ctx), const char *name) {
+static void run_test(void (*test)(), const char *name) {
   gpr_log(GPR_INFO, "RUN TEST: %s", name);
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+
   grpc_chttp2_hpack_compressor_init(&g_compressor);
-  test(&exec_ctx);
-  grpc_chttp2_hpack_compressor_destroy(&exec_ctx, &g_compressor);
-  grpc_exec_ctx_finish(&exec_ctx);
+  test();
+  grpc_chttp2_hpack_compressor_destroy(&g_compressor);
+  grpc_exec_ctx_finish();
 }
 
 int main(int argc, char **argv) {
diff --git a/test/core/transport/chttp2/hpack_parser_fuzzer_test.c b/test/core/transport/chttp2/hpack_parser_fuzzer_test.c
index 03834084cb..944f81f7c6 100644
--- a/test/core/transport/chttp2/hpack_parser_fuzzer_test.c
+++ b/test/core/transport/chttp2/hpack_parser_fuzzer_test.c
@@ -29,9 +29,7 @@
 bool squelch = true;
 bool leak_check = true;
 
-static void onhdr(grpc_exec_ctx *exec_ctx, void *ud, grpc_mdelem md) {
-  GRPC_MDELEM_UNREF(exec_ctx, md);
-}
+static void onhdr(void *ud, grpc_mdelem md) { GRPC_MDELEM_UNREF(md); }
 static void dont_log(gpr_log_func_args *args) {}
 
 int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
@@ -39,13 +37,13 @@ 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_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_chttp2_hpack_parser_init(&exec_ctx, &parser);
+  exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_chttp2_hpack_parser_init(&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);
+      &parser, grpc_slice_from_static_buffer(data, size)));
+  grpc_chttp2_hpack_parser_destroy(&parser);
+  grpc_exec_ctx_finish();
   grpc_shutdown();
   return 0;
 }
diff --git a/test/core/transport/chttp2/hpack_parser_test.c b/test/core/transport/chttp2/hpack_parser_test.c
index 0946c05261..67b527934e 100644
--- a/test/core/transport/chttp2/hpack_parser_test.c
+++ b/test/core/transport/chttp2/hpack_parser_test.c
@@ -30,7 +30,7 @@
 
 typedef struct { va_list args; } test_checker;
 
-static void onhdr(grpc_exec_ctx *exec_ctx, void *ud, grpc_mdelem md) {
+static void onhdr(void *ud, grpc_mdelem md) {
   const char *ekey, *evalue;
   test_checker *chk = ud;
   ekey = va_arg(chk->args, char *);
@@ -39,7 +39,7 @@ static void onhdr(grpc_exec_ctx *exec_ctx, 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(exec_ctx, md);
+  GRPC_MDELEM_UNREF(md);
 }
 
 static void test_vector(grpc_chttp2_hpack_parser *parser,
@@ -60,10 +60,10 @@ static void test_vector(grpc_chttp2_hpack_parser *parser,
   grpc_slice_unref(input);
 
   for (i = 0; i < nslices; i++) {
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    GPR_ASSERT(grpc_chttp2_hpack_parser_parse(&exec_ctx, parser, slices[i]) ==
+    exec_ctx = GRPC_EXEC_CTX_INIT;
+    GPR_ASSERT(grpc_chttp2_hpack_parser_parse(parser, slices[i]) ==
                GRPC_ERROR_NONE);
-    grpc_exec_ctx_finish(&exec_ctx);
+    grpc_exec_ctx_finish();
   }
 
   for (i = 0; i < nslices; i++) {
@@ -78,9 +78,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_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  grpc_chttp2_hpack_parser_init(&exec_ctx, &parser);
+  grpc_chttp2_hpack_parser_init(&parser);
   /* D.2.1 */
   test_vector(&parser, mode,
               "400a 6375 7374 6f6d 2d6b 6579 0d63 7573"
@@ -96,9 +96,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(&exec_ctx, &parser);
+  grpc_chttp2_hpack_parser_destroy(&parser);
 
-  grpc_chttp2_hpack_parser_init(&exec_ctx, &parser);
+  grpc_chttp2_hpack_parser_init(&parser);
   /* D.3.1 */
   test_vector(&parser, mode,
               "8286 8441 0f77 7777 2e65 7861 6d70 6c65"
@@ -116,9 +116,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(&exec_ctx, &parser);
+  grpc_chttp2_hpack_parser_destroy(&parser);
 
-  grpc_chttp2_hpack_parser_init(&exec_ctx, &parser);
+  grpc_chttp2_hpack_parser_init(&parser);
   /* D.4.1 */
   test_vector(&parser, mode,
               "8286 8441 8cf1 e3c2 e5f2 3a6b a0ab 90f4"
@@ -136,11 +136,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(&exec_ctx, &parser);
+  grpc_chttp2_hpack_parser_destroy(&parser);
 
-  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);
+  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 */
   test_vector(&parser, mode,
               "4803 3330 3258 0770 7269 7661 7465 611d"
@@ -170,11 +170,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(&exec_ctx, &parser);
+  grpc_chttp2_hpack_parser_destroy(&parser);
 
-  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);
+  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 */
   test_vector(&parser, mode,
               "4882 6402 5885 aec3 771a 4b61 96d0 7abe"
@@ -201,9 +201,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(&exec_ctx, &parser);
+  grpc_chttp2_hpack_parser_destroy(&parser);
 
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
 }
 
 int main(int argc, char **argv) {
diff --git a/test/core/transport/chttp2/hpack_table_test.c b/test/core/transport/chttp2/hpack_table_test.c
index 430ece33c7..cbb6b1d7a3 100644
--- a/test/core/transport/chttp2/hpack_table_test.c
+++ b/test/core/transport/chttp2/hpack_table_test.c
@@ -44,10 +44,10 @@ static void assert_index(const grpc_chttp2_hptbl *tbl, uint32_t idx,
 }
 
 static void test_static_lookup(void) {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_chttp2_hptbl tbl;
 
-  grpc_chttp2_hptbl_init(&exec_ctx, &tbl);
+  grpc_chttp2_hptbl_init(&tbl);
 
   LOG_TEST("test_static_lookup");
   assert_index(&tbl, 1, ":authority", "");
@@ -112,8 +112,8 @@ static void test_static_lookup(void) {
   assert_index(&tbl, 60, "via", "");
   assert_index(&tbl, 61, "www-authenticate", "");
 
-  grpc_chttp2_hptbl_destroy(&exec_ctx, &tbl);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_chttp2_hptbl_destroy(&tbl);
+  grpc_exec_ctx_finish();
 }
 
 static void test_many_additions(void) {
@@ -124,18 +124,17 @@ static void test_many_additions(void) {
 
   LOG_TEST("test_many_additions");
 
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_chttp2_hptbl_init(&exec_ctx, &tbl);
+  exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_chttp2_hptbl_init(&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(&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);
+    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);
     assert_index(&tbl, 1 + GRPC_CHTTP2_LAST_STATIC_ENTRY, key, value);
     gpr_free(key);
     gpr_free(value);
@@ -148,25 +147,24 @@ static void test_many_additions(void) {
     }
   }
 
-  grpc_chttp2_hptbl_destroy(&exec_ctx, &tbl);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_chttp2_hptbl_destroy(&tbl);
+  grpc_exec_ctx_finish();
 }
 
 static grpc_chttp2_hptbl_find_result find_simple(grpc_chttp2_hptbl *tbl,
                                                  const char *key,
                                                  const char *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));
+  exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_mdelem md = grpc_mdelem_from_slices(
+      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(&exec_ctx, md);
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_MDELEM_UNREF(md);
+  grpc_exec_ctx_finish();
   return r;
 }
 
 static void test_find(void) {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_chttp2_hptbl tbl;
   uint32_t i;
   char buffer[32];
@@ -175,21 +173,19 @@ static void test_find(void) {
 
   LOG_TEST("test_find");
 
-  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_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_slice_from_static_string("1"));
-  GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
-  GRPC_MDELEM_UNREF(&exec_ctx, elem);
+  GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem) == GRPC_ERROR_NONE);
+  GRPC_MDELEM_UNREF(elem);
 
   r = find_simple(&tbl, "abc", "123");
   GPR_ASSERT(r.index == 2 + GRPC_CHTTP2_LAST_STATIC_ENTRY);
@@ -238,11 +234,10 @@ 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(&exec_ctx,
-                                   grpc_slice_from_static_string("test"),
+    elem = grpc_mdelem_from_slices(grpc_slice_from_static_string("test"),
                                    grpc_slice_from_copied_string(buffer));
-    GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
-    GRPC_MDELEM_UNREF(&exec_ctx, elem);
+    GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem) == GRPC_ERROR_NONE);
+    GRPC_MDELEM_UNREF(elem);
   }
 
   r = find_simple(&tbl, "abc", "123");
@@ -270,8 +265,8 @@ static void test_find(void) {
   GPR_ASSERT(r.index != 0);
   GPR_ASSERT(r.has_value == 0);
 
-  grpc_chttp2_hptbl_destroy(&exec_ctx, &tbl);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_chttp2_hptbl_destroy(&tbl);
+  grpc_exec_ctx_finish();
 }
 
 int main(int argc, char **argv) {
diff --git a/test/core/transport/connectivity_state_test.c b/test/core/transport/connectivity_state_test.c
index 4ef8683107..f0a907d4c7 100644
--- a/test/core/transport/connectivity_state_test.c
+++ b/test/core/transport/connectivity_state_test.c
@@ -28,14 +28,13 @@
 
 int g_counter;
 
-static void must_succeed(grpc_exec_ctx *exec_ctx, void *arg,
-                         grpc_error *error) {
+static void must_succeed(void *arg, grpc_error *error) {
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(arg == THE_ARG);
   g_counter++;
 }
 
-static void must_fail(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
+static void must_fail(void *arg, grpc_error *error) {
   GPR_ASSERT(error != GRPC_ERROR_NONE);
   GPR_ASSERT(arg == THE_ARG);
   g_counter++;
@@ -58,7 +57,7 @@ static void test_connectivity_state_name(void) {
 
 static void test_check(void) {
   grpc_connectivity_state_tracker tracker;
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  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,8 +65,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(&exec_ctx, &tracker);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_connectivity_state_destroy(&tracker);
+  grpc_exec_ctx_finish();
 }
 
 static void test_subscribe_then_unsubscribe(void) {
@@ -75,23 +74,22 @@ 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_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  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(&exec_ctx, &tracker,
-                                                            &state, closure));
-  grpc_exec_ctx_flush(&exec_ctx);
+  GPR_ASSERT(grpc_connectivity_state_notify_on_state_change(&tracker, &state,
+                                                            closure));
+  grpc_exec_ctx_flush();
   GPR_ASSERT(state == GRPC_CHANNEL_IDLE);
   GPR_ASSERT(g_counter == 0);
-  grpc_connectivity_state_notify_on_state_change(&exec_ctx, &tracker, NULL,
-                                                 closure);
-  grpc_exec_ctx_flush(&exec_ctx);
+  grpc_connectivity_state_notify_on_state_change(&tracker, NULL, closure);
+  grpc_exec_ctx_flush();
   GPR_ASSERT(state == GRPC_CHANNEL_IDLE);
   GPR_ASSERT(g_counter == 1);
 
-  grpc_connectivity_state_destroy(&exec_ctx, &tracker);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_connectivity_state_destroy(&tracker);
+  grpc_exec_ctx_finish();
 }
 
 static void test_subscribe_then_destroy(void) {
@@ -99,17 +97,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_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  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(&exec_ctx, &tracker,
-                                                            &state, closure));
-  grpc_exec_ctx_flush(&exec_ctx);
+  GPR_ASSERT(grpc_connectivity_state_notify_on_state_change(&tracker, &state,
+                                                            closure));
+  grpc_exec_ctx_flush();
   GPR_ASSERT(state == GRPC_CHANNEL_IDLE);
   GPR_ASSERT(g_counter == 0);
-  grpc_connectivity_state_destroy(&exec_ctx, &tracker);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_connectivity_state_destroy(&tracker);
+  grpc_exec_ctx_finish();
   GPR_ASSERT(state == GRPC_CHANNEL_SHUTDOWN);
   GPR_ASSERT(g_counter == 1);
 }
@@ -119,17 +117,17 @@ 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_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  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(
-                      &exec_ctx, &tracker, &state, closure));
-  grpc_exec_ctx_flush(&exec_ctx);
+                      &tracker, &state, closure));
+  grpc_exec_ctx_flush();
   GPR_ASSERT(state == GRPC_CHANNEL_SHUTDOWN);
   GPR_ASSERT(g_counter == 0);
-  grpc_connectivity_state_destroy(&exec_ctx, &tracker);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_connectivity_state_destroy(&tracker);
+  grpc_exec_ctx_finish();
   GPR_ASSERT(state == GRPC_CHANNEL_SHUTDOWN);
   GPR_ASSERT(g_counter == 1);
 }
diff --git a/test/core/transport/metadata_test.c b/test/core/transport/metadata_test.c
index cb06fce30b..a721247766 100644
--- a/test/core/transport/metadata_test.c
+++ b/test/core/transport/metadata_test.c
@@ -60,15 +60,15 @@ static void test_create_metadata(bool intern_keys, bool intern_values) {
           intern_keys, intern_values);
 
   grpc_init();
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  exec_ctx = GRPC_EXEC_CTX_INIT;
   m1 = grpc_mdelem_from_slices(
-      &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+      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(
-      &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+      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(
-      &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+      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(&exec_ctx, m1);
-  GRPC_MDELEM_UNREF(&exec_ctx, m2);
-  GRPC_MDELEM_UNREF(&exec_ctx, m3);
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_MDELEM_UNREF(m1);
+  GRPC_MDELEM_UNREF(m2);
+  GRPC_MDELEM_UNREF(m3);
+  grpc_exec_ctx_finish();
   grpc_shutdown();
 }
 
@@ -95,19 +95,15 @@ static void test_create_many_ephemeral_metadata(bool intern_keys,
       intern_keys, intern_values);
 
   grpc_init();
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  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(
-        &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_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_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   grpc_shutdown();
 }
 
@@ -120,28 +116,28 @@ static void test_create_many_persistant_metadata(void) {
   gpr_log(GPR_INFO, "test_create_many_persistant_metadata");
 
   grpc_init();
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  exec_ctx = GRPC_EXEC_CTX_INIT;
   /* add phase */
   for (i = 0; i < MANY; i++) {
     gpr_ltoa(i, buffer);
     created[i] = grpc_mdelem_from_slices(
-        &exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("a")),
+        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(
-        &exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("a")),
+        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(&exec_ctx, md);
+    GRPC_MDELEM_UNREF(md);
   }
   /* cleanup phase */
   for (i = 0; i < MANY; i++) {
-    GRPC_MDELEM_UNREF(&exec_ctx, created[i]);
+    GRPC_MDELEM_UNREF(created[i]);
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   grpc_shutdown();
 
   gpr_free(created);
@@ -154,31 +150,25 @@ static void test_spin_creating_the_same_thing(bool intern_keys,
           intern_keys, intern_values);
 
   grpc_init();
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  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_exec_ctx_finish();
   grpc_shutdown();
 }
 
@@ -187,16 +177,16 @@ static void test_identity_laws(bool intern_keys, bool intern_values) {
           intern_keys, intern_values);
 
   grpc_init();
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_mdelem a, b, c;
   a = grpc_mdelem_from_slices(
-      &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+      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(
-      &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+      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(
-      &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+      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));
@@ -215,10 +205,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(&exec_ctx, a);
-  GRPC_MDELEM_UNREF(&exec_ctx, b);
-  GRPC_MDELEM_UNREF(&exec_ctx, c);
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_MDELEM_UNREF(a);
+  GRPC_MDELEM_UNREF(b);
+  GRPC_MDELEM_UNREF(c);
+  grpc_exec_ctx_finish();
   grpc_shutdown();
 }
 
@@ -233,7 +223,7 @@ static void test_things_stick_around(void) {
   gpr_log(GPR_INFO, "test_things_stick_around");
 
   grpc_init();
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  exec_ctx = GRPC_EXEC_CTX_INIT;
 
   for (i = 0; i < nstrs; i++) {
     gpr_asprintf(&buffer, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%" PRIuPTR "x", i);
@@ -244,7 +234,7 @@ static void test_things_stick_around(void) {
 
   for (i = 0; i < nstrs; i++) {
     grpc_slice_ref_internal(strs[i]);
-    grpc_slice_unref_internal(&exec_ctx, strs[i]);
+    grpc_slice_unref_internal(strs[i]);
   }
 
   for (i = 0; i < nstrs; i++) {
@@ -256,18 +246,18 @@ static void test_things_stick_around(void) {
   }
 
   for (i = 0; i < nstrs; i++) {
-    grpc_slice_unref_internal(&exec_ctx, strs[shuf[i]]);
+    grpc_slice_unref_internal(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(&exec_ctx, test);
+      grpc_slice_unref_internal(test);
       gpr_free(buffer);
     }
   }
 
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   grpc_shutdown();
   gpr_free(strs);
   gpr_free(shuf);
@@ -280,39 +270,38 @@ static void test_user_data_works(void) {
   gpr_log(GPR_INFO, "test_user_data_works");
 
   grpc_init();
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  exec_ctx = GRPC_EXEC_CTX_INIT;
   ud1 = gpr_malloc(sizeof(int));
   *ud1 = 1;
   ud2 = gpr_malloc(sizeof(int));
   *ud2 = 2;
   md = grpc_mdelem_from_slices(
-      &exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("abc")),
+      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(&exec_ctx, md);
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_MDELEM_UNREF(md);
+  grpc_exec_ctx_finish();
   grpc_shutdown();
 }
 
-static void verify_ascii_header_size(grpc_exec_ctx *exec_ctx, const char *key,
-                                     const char *value, bool intern_key,
-                                     bool intern_value) {
+static void verify_ascii_header_size(const char *key, const char *value,
+                                     bool intern_key, bool intern_value) {
   grpc_mdelem elem = grpc_mdelem_from_slices(
-      exec_ctx, maybe_intern(grpc_slice_from_static_string(key), intern_key),
+      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);
   size_t expected_size = 32 + strlen(key) + strlen(value);
   GPR_ASSERT(expected_size == elem_size);
-  GRPC_MDELEM_UNREF(exec_ctx, elem);
+  GRPC_MDELEM_UNREF(elem);
 }
 
-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) {
+static void verify_binary_header_size(const char *key, const uint8_t *value,
+                                      size_t value_len, bool intern_key,
+                                      bool intern_value) {
   grpc_mdelem elem = grpc_mdelem_from_slices(
-      exec_ctx, maybe_intern(grpc_slice_from_static_string(key), intern_key),
+      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)));
@@ -322,9 +311,9 @@ static void verify_binary_header_size(grpc_exec_ctx *exec_ctx, const char *key,
   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(exec_ctx, value_slice);
-  grpc_slice_unref_internal(exec_ctx, base64_encoded);
-  GRPC_MDELEM_UNREF(exec_ctx, elem);
+  grpc_slice_unref_internal(value_slice);
+  grpc_slice_unref_internal(base64_encoded);
+  GRPC_MDELEM_UNREF(elem);
 }
 
 #define BUFFER_SIZE 64
@@ -332,27 +321,24 @@ 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_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  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(&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);
+  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);
 
   for (uint8_t i = 0; i < BUFFER_SIZE; i++) {
-    verify_binary_header_size(&exec_ctx, "hello-bin", binary_value, i,
-                              intern_key, intern_value);
+    verify_binary_header_size("hello-bin", binary_value, i, intern_key,
+                              intern_value);
   }
 
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   grpc_shutdown();
 }
 
@@ -360,13 +346,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_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  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(&exec_ctx, maybe_dup(GRPC_MDKEY(p), dup_key),
+        grpc_mdelem_from_slices(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) {
@@ -374,11 +360,11 @@ static void test_copied_static_metadata(bool dup_key, bool dup_value) {
     } else {
       GPR_ASSERT(p.payload == q.payload);
     }
-    GRPC_MDELEM_UNREF(&exec_ctx, p);
-    GRPC_MDELEM_UNREF(&exec_ctx, q);
+    GRPC_MDELEM_UNREF(p);
+    GRPC_MDELEM_UNREF(q);
   }
 
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
   grpc_shutdown();
 }
 
diff --git a/test/core/transport/status_conversion_test.c b/test/core/transport/status_conversion_test.c
index de8fa4458a..d91f3765c6 100644
--- a/test/core/transport/status_conversion_test.c
+++ b/test/core/transport/status_conversion_test.c
@@ -22,12 +22,9 @@
 
 #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_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);                                      \
+#define HTTP2_ERROR_TO_GRPC_STATUS(a, deadline, b)                   \
+  do {                                                               \
+    GPR_ASSERT(grpc_http2_error_to_grpc_status(a, deadline) == (b)); \
   } 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.c b/test/core/transport/stream_owned_slice_test.c
index 774ad4e72e..f380763a6c 100644
--- a/test/core/transport/stream_owned_slice_test.c
+++ b/test/core/transport/stream_owned_slice_test.c
@@ -22,7 +22,7 @@
 
 #include <grpc/support/log.h>
 
-static void do_nothing(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {}
+static void do_nothing(void *arg, grpc_error *error) {}
 
 int main(int argc, char **argv) {
   grpc_test_init(argc, argv);