Merge branch 'master' into node_electron_build

6 files changed, 250 insertions, 235 deletions

diff --git a/test/core/iomgr/endpoint_tests.c b/test/core/iomgr/endpoint_tests.c
index b79c22e42a..8186ea7e85 100644
--- a/test/core/iomgr/endpoint_tests.c
+++ b/test/core/iomgr/endpoint_tests.c
@@ -36,9 +36,9 @@
 #include <stdbool.h>
 #include <sys/types.h>
 
+#include <grpc/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/slice.h>
 #include <grpc/support/time.h>
 #include <grpc/support/useful.h>
 #include "test/core/util/test_config.h"
@@ -62,18 +62,18 @@
 static gpr_mu *g_mu;
 static grpc_pollset *g_pollset;
 
-size_t count_slices(gpr_slice *slices, size_t nslices, int *current_data) {
+size_t count_slices(grpc_slice *slices, size_t nslices, int *current_data) {
   size_t num_bytes = 0;
   size_t i;
   size_t j;
   unsigned char *buf;
   for (i = 0; i < nslices; ++i) {
-    buf = GPR_SLICE_START_PTR(slices[i]);
-    for (j = 0; j < GPR_SLICE_LENGTH(slices[i]); ++j) {
+    buf = GRPC_SLICE_START_PTR(slices[i]);
+    for (j = 0; j < GRPC_SLICE_LENGTH(slices[i]); ++j) {
       GPR_ASSERT(buf[j] == *current_data);
       *current_data = (*current_data + 1) % 256;
     }
-    num_bytes += GPR_SLICE_LENGTH(slices[i]);
+    num_bytes += GRPC_SLICE_LENGTH(slices[i]);
   }
   return num_bytes;
 }
@@ -87,10 +87,10 @@ static grpc_endpoint_test_fixture begin_test(grpc_endpoint_test_config config,
 
 static void end_test(grpc_endpoint_test_config config) { config.clean_up(); }
 
-static gpr_slice *allocate_blocks(size_t num_bytes, size_t slice_size,
-                                  size_t *num_blocks, uint8_t *current_data) {
+static grpc_slice *allocate_blocks(size_t num_bytes, size_t slice_size,
+                                   size_t *num_blocks, uint8_t *current_data) {
   size_t nslices = num_bytes / slice_size + (num_bytes % slice_size ? 1 : 0);
-  gpr_slice *slices = gpr_malloc(sizeof(gpr_slice) * nslices);
+  grpc_slice *slices = gpr_malloc(sizeof(grpc_slice) * nslices);
   size_t num_bytes_left = num_bytes;
   size_t i;
   size_t j;
@@ -98,11 +98,11 @@ static gpr_slice *allocate_blocks(size_t num_bytes, size_t slice_size,
   *num_blocks = nslices;
 
   for (i = 0; i < nslices; ++i) {
-    slices[i] = gpr_slice_malloc(slice_size > num_bytes_left ? num_bytes_left
-                                                             : slice_size);
-    num_bytes_left -= GPR_SLICE_LENGTH(slices[i]);
-    buf = GPR_SLICE_START_PTR(slices[i]);
-    for (j = 0; j < GPR_SLICE_LENGTH(slices[i]); ++j) {
+    slices[i] = grpc_slice_malloc(slice_size > num_bytes_left ? num_bytes_left
+                                                              : slice_size);
+    num_bytes_left -= GRPC_SLICE_LENGTH(slices[i]);
+    buf = GRPC_SLICE_START_PTR(slices[i]);
+    for (j = 0; j < GRPC_SLICE_LENGTH(slices[i]); ++j) {
       buf[j] = *current_data;
       (*current_data)++;
     }
@@ -122,8 +122,8 @@ struct read_and_write_test_state {
   uint8_t current_write_data;
   int read_done;
   int write_done;
-  gpr_slice_buffer incoming;
-  gpr_slice_buffer outgoing;
+  grpc_slice_buffer incoming;
+  grpc_slice_buffer outgoing;
   grpc_closure done_read;
   grpc_closure done_write;
 };
@@ -149,7 +149,7 @@ static void read_and_write_test_read_handler(grpc_exec_ctx *exec_ctx,
 static void read_and_write_test_write_handler(grpc_exec_ctx *exec_ctx,
                                               void *data, grpc_error *error) {
   struct read_and_write_test_state *state = data;
-  gpr_slice *slices = NULL;
+  grpc_slice *slices = NULL;
   size_t nslices;
 
   if (error == GRPC_ERROR_NONE) {
@@ -161,8 +161,8 @@ static void read_and_write_test_write_handler(grpc_exec_ctx *exec_ctx,
     if (state->current_write_size != 0) {
       slices = allocate_blocks(state->current_write_size, 8192, &nslices,
                                &state->current_write_data);
-      gpr_slice_buffer_reset_and_unref(&state->outgoing);
-      gpr_slice_buffer_addn(&state->outgoing, slices, nslices);
+      grpc_slice_buffer_reset_and_unref(&state->outgoing);
+      grpc_slice_buffer_addn(&state->outgoing, slices, nslices);
       grpc_endpoint_write(exec_ctx, state->write_ep, &state->outgoing,
                           &state->done_write);
       gpr_free(slices);
@@ -214,8 +214,8 @@ static void read_and_write_test(grpc_endpoint_test_config config,
   grpc_closure_init(&state.done_read, read_and_write_test_read_handler, &state);
   grpc_closure_init(&state.done_write, read_and_write_test_write_handler,
                     &state);
-  gpr_slice_buffer_init(&state.outgoing);
-  gpr_slice_buffer_init(&state.incoming);
+  grpc_slice_buffer_init(&state.outgoing);
+  grpc_slice_buffer_init(&state.incoming);
 
   /* Get started by pretending an initial write completed */
   /* NOTE: Sets up initial conditions so we can have the same write handler
@@ -249,8 +249,8 @@ static void read_and_write_test(grpc_endpoint_test_config config,
   grpc_exec_ctx_flush(&exec_ctx);
 
   end_test(config);
-  gpr_slice_buffer_destroy(&state.outgoing);
-  gpr_slice_buffer_destroy(&state.incoming);
+  grpc_slice_buffer_destroy(&state.outgoing);
+  grpc_slice_buffer_destroy(&state.incoming);
   grpc_endpoint_destroy(&exec_ctx, state.read_ep);
   grpc_endpoint_destroy(&exec_ctx, state.write_ep);
   grpc_exec_ctx_finish(&exec_ctx);
@@ -284,8 +284,8 @@ static void multiple_shutdown_test(grpc_endpoint_test_config config) {
       begin_test(config, "multiple_shutdown_test", 128);
   int fail_count = 0;
 
-  gpr_slice_buffer slice_buffer;
-  gpr_slice_buffer_init(&slice_buffer);
+  grpc_slice_buffer slice_buffer;
+  grpc_slice_buffer_init(&slice_buffer);
 
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_endpoint_add_to_pollset(&exec_ctx, f.client_ep, g_pollset);
@@ -297,14 +297,14 @@ static void multiple_shutdown_test(grpc_endpoint_test_config config) {
   grpc_endpoint_read(&exec_ctx, f.client_ep, &slice_buffer,
                      grpc_closure_create(inc_on_failure, &fail_count));
   wait_for_fail_count(&exec_ctx, &fail_count, 2);
-  gpr_slice_buffer_add(&slice_buffer, gpr_slice_from_copied_string("a"));
+  grpc_slice_buffer_add(&slice_buffer, grpc_slice_from_copied_string("a"));
   grpc_endpoint_write(&exec_ctx, f.client_ep, &slice_buffer,
                       grpc_closure_create(inc_on_failure, &fail_count));
   wait_for_fail_count(&exec_ctx, &fail_count, 3);
   grpc_endpoint_shutdown(&exec_ctx, f.client_ep);
   wait_for_fail_count(&exec_ctx, &fail_count, 3);
 
-  gpr_slice_buffer_destroy(&slice_buffer);
+  grpc_slice_buffer_destroy(&slice_buffer);
 
   grpc_endpoint_destroy(&exec_ctx, f.client_ep);
   grpc_endpoint_destroy(&exec_ctx, f.server_ep);
diff --git a/test/core/iomgr/load_file_test.c b/test/core/iomgr/load_file_test.c
index f70295a81c..8714e1f368 100644
--- a/test/core/iomgr/load_file_test.c
+++ b/test/core/iomgr/load_file_test.c
@@ -34,9 +34,9 @@
 #include <stdio.h>
 #include <string.h>
 
+#include <grpc/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/slice.h>
 
 #include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/support/string.h"
@@ -49,8 +49,8 @@ static const char prefix[] = "file_test";
 
 static void test_load_empty_file(void) {
   FILE *tmp = NULL;
-  gpr_slice slice;
-  gpr_slice slice_with_null_term;
+  grpc_slice slice;
+  grpc_slice slice_with_null_term;
   grpc_error *error;
   char *tmp_name;
 
@@ -63,22 +63,22 @@ static void test_load_empty_file(void) {
 
   error = grpc_load_file(tmp_name, 0, &slice);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
-  GPR_ASSERT(GPR_SLICE_LENGTH(slice) == 0);
+  GPR_ASSERT(GRPC_SLICE_LENGTH(slice) == 0);
 
   error = grpc_load_file(tmp_name, 1, &slice_with_null_term);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
-  GPR_ASSERT(GPR_SLICE_LENGTH(slice_with_null_term) == 1);
-  GPR_ASSERT(GPR_SLICE_START_PTR(slice_with_null_term)[0] == 0);
+  GPR_ASSERT(GRPC_SLICE_LENGTH(slice_with_null_term) == 1);
+  GPR_ASSERT(GRPC_SLICE_START_PTR(slice_with_null_term)[0] == 0);
 
   remove(tmp_name);
   gpr_free(tmp_name);
-  gpr_slice_unref(slice);
-  gpr_slice_unref(slice_with_null_term);
+  grpc_slice_unref(slice);
+  grpc_slice_unref(slice_with_null_term);
 }
 
 static void test_load_failure(void) {
   FILE *tmp = NULL;
-  gpr_slice slice;
+  grpc_slice slice;
   grpc_error *error;
   char *tmp_name;
 
@@ -93,15 +93,15 @@ static void test_load_failure(void) {
   error = grpc_load_file(tmp_name, 0, &slice);
   GPR_ASSERT(error != GRPC_ERROR_NONE);
   GRPC_ERROR_UNREF(error);
-  GPR_ASSERT(GPR_SLICE_LENGTH(slice) == 0);
+  GPR_ASSERT(GRPC_SLICE_LENGTH(slice) == 0);
   gpr_free(tmp_name);
-  gpr_slice_unref(slice);
+  grpc_slice_unref(slice);
 }
 
 static void test_load_small_file(void) {
   FILE *tmp = NULL;
-  gpr_slice slice;
-  gpr_slice slice_with_null_term;
+  grpc_slice slice;
+  grpc_slice slice_with_null_term;
   grpc_error *error;
   char *tmp_name;
   const char *blah = "blah";
@@ -116,24 +116,24 @@ static void test_load_small_file(void) {
 
   error = grpc_load_file(tmp_name, 0, &slice);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
-  GPR_ASSERT(GPR_SLICE_LENGTH(slice) == strlen(blah));
-  GPR_ASSERT(!memcmp(GPR_SLICE_START_PTR(slice), blah, strlen(blah)));
+  GPR_ASSERT(GRPC_SLICE_LENGTH(slice) == strlen(blah));
+  GPR_ASSERT(!memcmp(GRPC_SLICE_START_PTR(slice), blah, strlen(blah)));
 
   error = grpc_load_file(tmp_name, 1, &slice_with_null_term);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
-  GPR_ASSERT(GPR_SLICE_LENGTH(slice_with_null_term) == (strlen(blah) + 1));
-  GPR_ASSERT(strcmp((const char *)GPR_SLICE_START_PTR(slice_with_null_term),
+  GPR_ASSERT(GRPC_SLICE_LENGTH(slice_with_null_term) == (strlen(blah) + 1));
+  GPR_ASSERT(strcmp((const char *)GRPC_SLICE_START_PTR(slice_with_null_term),
                     blah) == 0);
 
   remove(tmp_name);
   gpr_free(tmp_name);
-  gpr_slice_unref(slice);
-  gpr_slice_unref(slice_with_null_term);
+  grpc_slice_unref(slice);
+  grpc_slice_unref(slice_with_null_term);
 }
 
 static void test_load_big_file(void) {
   FILE *tmp = NULL;
-  gpr_slice slice;
+  grpc_slice slice;
   grpc_error *error;
   char *tmp_name;
   static const size_t buffer_size = 124631;
@@ -153,15 +153,15 @@ static void test_load_big_file(void) {
 
   error = grpc_load_file(tmp_name, 0, &slice);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
-  GPR_ASSERT(GPR_SLICE_LENGTH(slice) == buffer_size);
-  current = GPR_SLICE_START_PTR(slice);
+  GPR_ASSERT(GRPC_SLICE_LENGTH(slice) == buffer_size);
+  current = GRPC_SLICE_START_PTR(slice);
   for (i = 0; i < buffer_size; i++) {
     GPR_ASSERT(current[i] == 42);
   }
 
   remove(tmp_name);
   gpr_free(tmp_name);
-  gpr_slice_unref(slice);
+  grpc_slice_unref(slice);
   gpr_free(buffer);
 }
 
diff --git a/test/core/iomgr/resource_quota_test.c b/test/core/iomgr/resource_quota_test.c
index 34dee1aee1..a82d44f7f8 100644
--- a/test/core/iomgr/resource_quota_test.c
+++ b/test/core/iomgr/resource_quota_test.c
@@ -81,11 +81,7 @@ grpc_closure *make_unused_reclaimer(grpc_closure *then) {
 
 static void destroy_user(grpc_resource_user *usr) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  bool done = false;
-  grpc_resource_user_shutdown(&exec_ctx, usr, set_bool(&done));
-  grpc_exec_ctx_flush(&exec_ctx);
-  GPR_ASSERT(done);
-  grpc_resource_user_destroy(&exec_ctx, usr);
+  grpc_resource_user_unref(&exec_ctx, usr);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
@@ -106,10 +102,9 @@ static void test_resource_user_no_op(void) {
   gpr_log(GPR_INFO, "** test_resource_user_no_op **");
   grpc_resource_quota *q =
       grpc_resource_quota_create("test_resource_user_no_op");
-  grpc_resource_user usr;
-  grpc_resource_user_init(&usr, q, "usr");
+  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   grpc_resource_quota_unref(q);
-  destroy_user(&usr);
+  destroy_user(usr);
 }
 
 static void test_instant_alloc_then_free(void) {
@@ -117,20 +112,19 @@ static void test_instant_alloc_then_free(void) {
   grpc_resource_quota *q =
       grpc_resource_quota_create("test_instant_alloc_then_free");
   grpc_resource_quota_resize(q, 1024 * 1024);
-  grpc_resource_user usr;
-  grpc_resource_user_init(&usr, q, "usr");
+  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr, 1024, NULL);
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, NULL);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_free(&exec_ctx, &usr, 1024);
+    grpc_resource_user_free(&exec_ctx, usr, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   grpc_resource_quota_unref(q);
-  destroy_user(&usr);
+  destroy_user(usr);
 }
 
 static void test_instant_alloc_free_pair(void) {
@@ -138,16 +132,15 @@ static void test_instant_alloc_free_pair(void) {
   grpc_resource_quota *q =
       grpc_resource_quota_create("test_instant_alloc_free_pair");
   grpc_resource_quota_resize(q, 1024 * 1024);
-  grpc_resource_user usr;
-  grpc_resource_user_init(&usr, q, "usr");
+  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr, 1024, NULL);
-    grpc_resource_user_free(&exec_ctx, &usr, 1024);
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, NULL);
+    grpc_resource_user_free(&exec_ctx, usr, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   grpc_resource_quota_unref(q);
-  destroy_user(&usr);
+  destroy_user(usr);
 }
 
 static void test_simple_async_alloc(void) {
@@ -155,22 +148,21 @@ static void test_simple_async_alloc(void) {
   grpc_resource_quota *q =
       grpc_resource_quota_create("test_simple_async_alloc");
   grpc_resource_quota_resize(q, 1024 * 1024);
-  grpc_resource_user usr;
-  grpc_resource_user_init(&usr, q, "usr");
+  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   {
     bool done = false;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(done);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_free(&exec_ctx, &usr, 1024);
+    grpc_resource_user_free(&exec_ctx, usr, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   grpc_resource_quota_unref(q);
-  destroy_user(&usr);
+  destroy_user(usr);
 }
 
 static void test_async_alloc_blocked_by_size(void) {
@@ -178,12 +170,11 @@ static void test_async_alloc_blocked_by_size(void) {
   grpc_resource_quota *q =
       grpc_resource_quota_create("test_async_alloc_blocked_by_size");
   grpc_resource_quota_resize(q, 1);
-  grpc_resource_user usr;
-  grpc_resource_user_init(&usr, q, "usr");
+  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   bool done = false;
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(!done);
   }
@@ -191,87 +182,83 @@ static void test_async_alloc_blocked_by_size(void) {
   GPR_ASSERT(done);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_free(&exec_ctx, &usr, 1024);
+    grpc_resource_user_free(&exec_ctx, usr, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   grpc_resource_quota_unref(q);
-  destroy_user(&usr);
+  destroy_user(usr);
 }
 
 static void test_scavenge(void) {
   gpr_log(GPR_INFO, "** test_scavenge **");
   grpc_resource_quota *q = grpc_resource_quota_create("test_scavenge");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user usr1;
-  grpc_resource_user usr2;
-  grpc_resource_user_init(&usr1, q, "usr1");
-  grpc_resource_user_init(&usr2, q, "usr2");
+  grpc_resource_user *usr1 = grpc_resource_user_create(q, "usr1");
+  grpc_resource_user *usr2 = grpc_resource_user_create(q, "usr2");
   {
     bool done = false;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr1, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_bool(&done));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(done);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_free(&exec_ctx, &usr1, 1024);
+    grpc_resource_user_free(&exec_ctx, usr1, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   {
     bool done = false;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr2, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_bool(&done));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(done);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_free(&exec_ctx, &usr2, 1024);
+    grpc_resource_user_free(&exec_ctx, usr2, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   grpc_resource_quota_unref(q);
-  destroy_user(&usr1);
-  destroy_user(&usr2);
+  destroy_user(usr1);
+  destroy_user(usr2);
 }
 
 static void test_scavenge_blocked(void) {
   gpr_log(GPR_INFO, "** test_scavenge_blocked **");
   grpc_resource_quota *q = grpc_resource_quota_create("test_scavenge_blocked");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user usr1;
-  grpc_resource_user usr2;
-  grpc_resource_user_init(&usr1, q, "usr1");
-  grpc_resource_user_init(&usr2, q, "usr2");
+  grpc_resource_user *usr1 = grpc_resource_user_create(q, "usr1");
+  grpc_resource_user *usr2 = grpc_resource_user_create(q, "usr2");
   bool done;
   {
     done = false;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr1, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_bool(&done));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(done);
   }
   {
     done = false;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr2, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_bool(&done));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(!done);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_free(&exec_ctx, &usr1, 1024);
+    grpc_resource_user_free(&exec_ctx, usr1, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(done);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_free(&exec_ctx, &usr2, 1024);
+    grpc_resource_user_free(&exec_ctx, usr2, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   grpc_resource_quota_unref(q);
-  destroy_user(&usr1);
-  destroy_user(&usr2);
+  destroy_user(usr1);
+  destroy_user(usr2);
 }
 
 static void test_blocked_until_scheduled_reclaim(void) {
@@ -279,12 +266,11 @@ static void test_blocked_until_scheduled_reclaim(void) {
   grpc_resource_quota *q =
       grpc_resource_quota_create("test_blocked_until_scheduled_reclaim");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user usr;
-  grpc_resource_user_init(&usr, q, "usr");
+  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   {
     bool done = false;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(done);
   }
@@ -292,25 +278,25 @@ static void test_blocked_until_scheduled_reclaim(void) {
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
-        &exec_ctx, &usr, false,
-        make_reclaimer(&usr, 1024, set_bool(&reclaim_done)));
+        &exec_ctx, usr, false,
+        make_reclaimer(usr, 1024, set_bool(&reclaim_done)));
     grpc_exec_ctx_finish(&exec_ctx);
   }
   {
     bool done = false;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(reclaim_done);
     GPR_ASSERT(done);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_free(&exec_ctx, &usr, 1024);
+    grpc_resource_user_free(&exec_ctx, usr, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   grpc_resource_quota_unref(q);
-  destroy_user(&usr);
+  destroy_user(usr);
 }
 
 static void test_blocked_until_scheduled_reclaim_and_scavenge(void) {
@@ -318,14 +304,12 @@ static void test_blocked_until_scheduled_reclaim_and_scavenge(void) {
   grpc_resource_quota *q = grpc_resource_quota_create(
       "test_blocked_until_scheduled_reclaim_and_scavenge");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user usr1;
-  grpc_resource_user usr2;
-  grpc_resource_user_init(&usr1, q, "usr1");
-  grpc_resource_user_init(&usr2, q, "usr2");
+  grpc_resource_user *usr1 = grpc_resource_user_create(q, "usr1");
+  grpc_resource_user *usr2 = grpc_resource_user_create(q, "usr2");
   {
     bool done = false;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr1, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_bool(&done));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(done);
   }
@@ -333,26 +317,26 @@ static void test_blocked_until_scheduled_reclaim_and_scavenge(void) {
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
-        &exec_ctx, &usr1, false,
-        make_reclaimer(&usr1, 1024, set_bool(&reclaim_done)));
+        &exec_ctx, usr1, false,
+        make_reclaimer(usr1, 1024, set_bool(&reclaim_done)));
     grpc_exec_ctx_finish(&exec_ctx);
   }
   {
     bool done = false;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr2, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_bool(&done));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(reclaim_done);
     GPR_ASSERT(done);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_free(&exec_ctx, &usr2, 1024);
+    grpc_resource_user_free(&exec_ctx, usr2, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   grpc_resource_quota_unref(q);
-  destroy_user(&usr1);
-  destroy_user(&usr2);
+  destroy_user(usr1);
+  destroy_user(usr2);
 }
 
 static void test_blocked_until_scheduled_destructive_reclaim(void) {
@@ -360,12 +344,11 @@ static void test_blocked_until_scheduled_destructive_reclaim(void) {
   grpc_resource_quota *q = grpc_resource_quota_create(
       "test_blocked_until_scheduled_destructive_reclaim");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user usr;
-  grpc_resource_user_init(&usr, q, "usr");
+  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   {
     bool done = false;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(done);
   }
@@ -373,25 +356,25 @@ static void test_blocked_until_scheduled_destructive_reclaim(void) {
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
-        &exec_ctx, &usr, true,
-        make_reclaimer(&usr, 1024, set_bool(&reclaim_done)));
+        &exec_ctx, usr, true,
+        make_reclaimer(usr, 1024, set_bool(&reclaim_done)));
     grpc_exec_ctx_finish(&exec_ctx);
   }
   {
     bool done = false;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(reclaim_done);
     GPR_ASSERT(done);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_free(&exec_ctx, &usr, 1024);
+    grpc_resource_user_free(&exec_ctx, usr, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   grpc_resource_quota_unref(q);
-  destroy_user(&usr);
+  destroy_user(usr);
 }
 
 static void test_unused_reclaim_is_cancelled(void) {
@@ -399,23 +382,22 @@ static void test_unused_reclaim_is_cancelled(void) {
   grpc_resource_quota *q =
       grpc_resource_quota_create("test_unused_reclaim_is_cancelled");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user usr;
-  grpc_resource_user_init(&usr, q, "usr");
+  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   bool benign_done = false;
   bool destructive_done = false;
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
-        &exec_ctx, &usr, false, make_unused_reclaimer(set_bool(&benign_done)));
+        &exec_ctx, usr, false, make_unused_reclaimer(set_bool(&benign_done)));
     grpc_resource_user_post_reclaimer(
-        &exec_ctx, &usr, true,
+        &exec_ctx, usr, true,
         make_unused_reclaimer(set_bool(&destructive_done)));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(!benign_done);
     GPR_ASSERT(!destructive_done);
   }
   grpc_resource_quota_unref(q);
-  destroy_user(&usr);
+  destroy_user(usr);
   GPR_ASSERT(benign_done);
   GPR_ASSERT(destructive_done);
 }
@@ -425,24 +407,23 @@ static void test_benign_reclaim_is_preferred(void) {
   grpc_resource_quota *q =
       grpc_resource_quota_create("test_benign_reclaim_is_preferred");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user usr;
-  grpc_resource_user_init(&usr, q, "usr");
+  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   bool benign_done = false;
   bool destructive_done = false;
   {
     bool done = false;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(done);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
-        &exec_ctx, &usr, false,
-        make_reclaimer(&usr, 1024, set_bool(&benign_done)));
+        &exec_ctx, usr, false,
+        make_reclaimer(usr, 1024, set_bool(&benign_done)));
     grpc_resource_user_post_reclaimer(
-        &exec_ctx, &usr, true,
+        &exec_ctx, usr, true,
         make_unused_reclaimer(set_bool(&destructive_done)));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(!benign_done);
@@ -451,7 +432,7 @@ static void test_benign_reclaim_is_preferred(void) {
   {
     bool done = false;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(benign_done);
     GPR_ASSERT(!destructive_done);
@@ -459,11 +440,11 @@ static void test_benign_reclaim_is_preferred(void) {
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_free(&exec_ctx, &usr, 1024);
+    grpc_resource_user_free(&exec_ctx, usr, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   grpc_resource_quota_unref(q);
-  destroy_user(&usr);
+  destroy_user(usr);
   GPR_ASSERT(benign_done);
   GPR_ASSERT(destructive_done);
 }
@@ -473,25 +454,24 @@ static void test_multiple_reclaims_can_be_triggered(void) {
   grpc_resource_quota *q =
       grpc_resource_quota_create("test_multiple_reclaims_can_be_triggered");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user usr;
-  grpc_resource_user_init(&usr, q, "usr");
+  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   bool benign_done = false;
   bool destructive_done = false;
   {
     bool done = false;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(done);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
-        &exec_ctx, &usr, false,
-        make_reclaimer(&usr, 512, set_bool(&benign_done)));
+        &exec_ctx, usr, false,
+        make_reclaimer(usr, 512, set_bool(&benign_done)));
     grpc_resource_user_post_reclaimer(
-        &exec_ctx, &usr, true,
-        make_reclaimer(&usr, 512, set_bool(&destructive_done)));
+        &exec_ctx, usr, true,
+        make_reclaimer(usr, 512, set_bool(&destructive_done)));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(!benign_done);
     GPR_ASSERT(!destructive_done);
@@ -499,7 +479,7 @@ static void test_multiple_reclaims_can_be_triggered(void) {
   {
     bool done = false;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(benign_done);
     GPR_ASSERT(destructive_done);
@@ -507,11 +487,11 @@ static void test_multiple_reclaims_can_be_triggered(void) {
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_free(&exec_ctx, &usr, 1024);
+    grpc_resource_user_free(&exec_ctx, usr, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   grpc_resource_quota_unref(q);
-  destroy_user(&usr);
+  destroy_user(usr);
   GPR_ASSERT(benign_done);
   GPR_ASSERT(destructive_done);
 }
@@ -522,30 +502,21 @@ static void test_resource_user_stays_allocated_until_memory_released(void) {
   grpc_resource_quota *q = grpc_resource_quota_create(
       "test_resource_user_stays_allocated_until_memory_released");
   grpc_resource_quota_resize(q, 1024 * 1024);
-  grpc_resource_user usr;
-  grpc_resource_user_init(&usr, q, "usr");
-  bool done = false;
+  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr, 1024, NULL);
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, NULL);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_quota_unref(q);
-    grpc_resource_user_shutdown(&exec_ctx, &usr, set_bool(&done));
+    grpc_resource_user_unref(&exec_ctx, usr);
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(!done);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_free(&exec_ctx, &usr, 1024);
-    grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
-  }
-  {
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_destroy(&exec_ctx, &usr);
+    grpc_resource_user_free(&exec_ctx, usr, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
   }
 }
@@ -562,14 +533,12 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
       "released");
   grpc_resource_quota_resize(q, 1024);
   for (int i = 0; i < 10; i++) {
-    grpc_resource_user usr;
-    grpc_resource_user_init(&usr, q, "usr");
-    bool done = false;
+    grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
     bool reclaimer_cancelled = false;
     {
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
       grpc_resource_user_post_reclaimer(
-          &exec_ctx, &usr, false,
+          &exec_ctx, usr, false,
           make_unused_reclaimer(set_bool(&reclaimer_cancelled)));
       grpc_exec_ctx_finish(&exec_ctx);
       GPR_ASSERT(!reclaimer_cancelled);
@@ -577,30 +546,23 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
     {
       bool allocated = false;
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-      grpc_resource_user_alloc(&exec_ctx, &usr, 1024, set_bool(&allocated));
+      grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&allocated));
       grpc_exec_ctx_finish(&exec_ctx);
       GPR_ASSERT(allocated);
       GPR_ASSERT(!reclaimer_cancelled);
     }
     {
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-      grpc_resource_user_shutdown(&exec_ctx, &usr, set_bool(&done));
+      grpc_resource_user_unref(&exec_ctx, usr);
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(!done);
       GPR_ASSERT(!reclaimer_cancelled);
     }
     {
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-      grpc_resource_user_free(&exec_ctx, &usr, 1024);
+      grpc_resource_user_free(&exec_ctx, usr, 1024);
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(done);
       GPR_ASSERT(reclaimer_cancelled);
     }
-    {
-      grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-      grpc_resource_user_destroy(&exec_ctx, &usr);
-      grpc_exec_ctx_finish(&exec_ctx);
-    }
   }
   grpc_resource_quota_unref(q);
 }
@@ -610,12 +572,11 @@ static void test_reclaimers_can_be_posted_repeatedly(void) {
   grpc_resource_quota *q =
       grpc_resource_quota_create("test_reclaimers_can_be_posted_repeatedly");
   grpc_resource_quota_resize(q, 1024);
-  grpc_resource_user usr;
-  grpc_resource_user_init(&usr, q, "usr");
+  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   {
     bool allocated = false;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, &usr, 1024, set_bool(&allocated));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&allocated));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(allocated);
   }
@@ -624,15 +585,15 @@ static void test_reclaimers_can_be_posted_repeatedly(void) {
     {
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
       grpc_resource_user_post_reclaimer(
-          &exec_ctx, &usr, false,
-          make_reclaimer(&usr, 1024, set_bool(&reclaimer_done)));
+          &exec_ctx, usr, false,
+          make_reclaimer(usr, 1024, set_bool(&reclaimer_done)));
       grpc_exec_ctx_finish(&exec_ctx);
       GPR_ASSERT(!reclaimer_done);
     }
     {
       bool allocated = false;
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-      grpc_resource_user_alloc(&exec_ctx, &usr, 1024, set_bool(&allocated));
+      grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&allocated));
       grpc_exec_ctx_finish(&exec_ctx);
       GPR_ASSERT(allocated);
       GPR_ASSERT(reclaimer_done);
@@ -640,10 +601,10 @@ static void test_reclaimers_can_be_posted_repeatedly(void) {
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_free(&exec_ctx, &usr, 1024);
+    grpc_resource_user_free(&exec_ctx, usr, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
   }
-  destroy_user(&usr);
+  destroy_user(usr);
   grpc_resource_quota_unref(q);
 }
 
@@ -653,16 +614,14 @@ static void test_one_slice(void) {
   grpc_resource_quota *q = grpc_resource_quota_create("test_one_slice");
   grpc_resource_quota_resize(q, 1024);
 
-  grpc_resource_user usr;
-  grpc_resource_user_init(&usr, q, "usr");
+  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
 
   grpc_resource_user_slice_allocator alloc;
   int num_allocs = 0;
-  grpc_resource_user_slice_allocator_init(&alloc, &usr, inc_int_cb,
-                                          &num_allocs);
+  grpc_resource_user_slice_allocator_init(&alloc, usr, inc_int_cb, &num_allocs);
 
-  gpr_slice_buffer buffer;
-  gpr_slice_buffer_init(&buffer);
+  grpc_slice_buffer buffer;
+  grpc_slice_buffer_init(&buffer);
 
   {
     const int start_allocs = num_allocs;
@@ -672,8 +631,8 @@ static void test_one_slice(void) {
     GPR_ASSERT(num_allocs == start_allocs + 1);
   }
 
-  gpr_slice_buffer_destroy(&buffer);
-  destroy_user(&usr);
+  grpc_slice_buffer_destroy(&buffer);
+  destroy_user(usr);
   grpc_resource_quota_unref(q);
 }
 
@@ -684,16 +643,14 @@ static void test_one_slice_deleted_late(void) {
       grpc_resource_quota_create("test_one_slice_deleted_late");
   grpc_resource_quota_resize(q, 1024);
 
-  grpc_resource_user usr;
-  grpc_resource_user_init(&usr, q, "usr");
+  grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
 
   grpc_resource_user_slice_allocator alloc;
   int num_allocs = 0;
-  grpc_resource_user_slice_allocator_init(&alloc, &usr, inc_int_cb,
-                                          &num_allocs);
+  grpc_resource_user_slice_allocator_init(&alloc, usr, inc_int_cb, &num_allocs);
 
-  gpr_slice_buffer buffer;
-  gpr_slice_buffer_init(&buffer);
+  grpc_slice_buffer buffer;
+  grpc_slice_buffer_init(&buffer);
 
   {
     const int start_allocs = num_allocs;
@@ -703,22 +660,14 @@ static void test_one_slice_deleted_late(void) {
     GPR_ASSERT(num_allocs == start_allocs + 1);
   }
 
-  bool done = false;
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_shutdown(&exec_ctx, &usr, set_bool(&done));
+    grpc_resource_user_unref(&exec_ctx, usr);
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(!done);
   }
 
   grpc_resource_quota_unref(q);
-  gpr_slice_buffer_destroy(&buffer);
-  GPR_ASSERT(done);
-  {
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_destroy(&exec_ctx, &usr);
-    grpc_exec_ctx_finish(&exec_ctx);
-  }
+  grpc_slice_buffer_destroy(&buffer);
 }
 
 int main(int argc, char **argv) {
diff --git a/test/core/iomgr/socket_utils_test.c b/test/core/iomgr/socket_utils_test.c
index 67bc914c15..7eee2d1d10 100644
--- a/test/core/iomgr/socket_utils_test.c
+++ b/test/core/iomgr/socket_utils_test.c
@@ -39,13 +39,57 @@
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 
 #include <errno.h>
+#include <netinet/ip.h>
 #include <string.h>
 
+#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/useful.h>
+#include "src/core/lib/iomgr/socket_mutator.h"
 #include "test/core/util/test_config.h"
 
+struct test_socket_mutator {
+  grpc_socket_mutator base;
+  int option_value;
+};
+
+static bool mutate_fd(int fd, grpc_socket_mutator *mutator) {
+  int newval;
+  socklen_t intlen = sizeof(newval);
+  struct test_socket_mutator *m = (struct test_socket_mutator *)mutator;
+
+  if (0 != setsockopt(fd, IPPROTO_IP, IP_TOS, &m->option_value,
+                      sizeof(m->option_value))) {
+    return false;
+  }
+  if (0 != getsockopt(fd, IPPROTO_IP, IP_TOS, &newval, &intlen)) {
+    return false;
+  }
+  if (newval != m->option_value) {
+    return false;
+  }
+  return true;
+}
+
+static void destroy_test_mutator(grpc_socket_mutator *mutator) {
+  struct test_socket_mutator *m = (struct test_socket_mutator *)mutator;
+  gpr_free(m);
+}
+
+static int compare_test_mutator(grpc_socket_mutator *a,
+                                grpc_socket_mutator *b) {
+  struct test_socket_mutator *ma = (struct test_socket_mutator *)a;
+  struct test_socket_mutator *mb = (struct test_socket_mutator *)b;
+  return GPR_ICMP(ma->option_value, mb->option_value);
+}
+
+static const grpc_socket_mutator_vtable mutator_vtable = {
+    mutate_fd, compare_test_mutator, destroy_test_mutator};
+
 int main(int argc, char **argv) {
   int sock;
+  grpc_error *err;
   grpc_test_init(argc, argv);
 
   sock = socket(PF_INET, SOCK_STREAM, 0);
@@ -68,6 +112,29 @@ int main(int argc, char **argv) {
   GPR_ASSERT(GRPC_LOG_IF_ERROR("set_socket_low_latency",
                                grpc_set_socket_low_latency(sock, 0)));
 
+  struct test_socket_mutator mutator;
+  grpc_socket_mutator_init(&mutator.base, &mutator_vtable);
+
+  mutator.option_value = IPTOS_LOWDELAY;
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "set_socket_with_mutator",
+      grpc_set_socket_with_mutator(sock, (grpc_socket_mutator *)&mutator)));
+
+  mutator.option_value = IPTOS_THROUGHPUT;
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "set_socket_with_mutator",
+      grpc_set_socket_with_mutator(sock, (grpc_socket_mutator *)&mutator)));
+
+  mutator.option_value = IPTOS_RELIABILITY;
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "set_socket_with_mutator",
+      grpc_set_socket_with_mutator(sock, (grpc_socket_mutator *)&mutator)));
+
+  mutator.option_value = -1;
+  err = grpc_set_socket_with_mutator(sock, (grpc_socket_mutator *)&mutator);
+  GPR_ASSERT(err != GRPC_ERROR_NONE);
+  GRPC_ERROR_UNREF(err);
+
   close(sock);
 
   return 0;
diff --git a/test/core/iomgr/tcp_posix_test.c b/test/core/iomgr/tcp_posix_test.c
index 29f12a5afb..5eafa570bb 100644
--- a/test/core/iomgr/tcp_posix_test.c
+++ b/test/core/iomgr/tcp_posix_test.c
@@ -124,22 +124,22 @@ struct read_socket_state {
   grpc_endpoint *ep;
   size_t read_bytes;
   size_t target_read_bytes;
-  gpr_slice_buffer incoming;
+  grpc_slice_buffer incoming;
   grpc_closure read_cb;
 };
 
-static size_t count_slices(gpr_slice *slices, size_t nslices,
+static size_t count_slices(grpc_slice *slices, size_t nslices,
                            int *current_data) {
   size_t num_bytes = 0;
   unsigned i, j;
   unsigned char *buf;
   for (i = 0; i < nslices; ++i) {
-    buf = GPR_SLICE_START_PTR(slices[i]);
-    for (j = 0; j < GPR_SLICE_LENGTH(slices[i]); ++j) {
+    buf = GRPC_SLICE_START_PTR(slices[i]);
+    for (j = 0; j < GRPC_SLICE_LENGTH(slices[i]); ++j) {
       GPR_ASSERT(buf[j] == *current_data);
       *current_data = (*current_data + 1) % 256;
     }
-    num_bytes += GPR_SLICE_LENGTH(slices[i]);
+    num_bytes += GRPC_SLICE_LENGTH(slices[i]);
   }
   return num_bytes;
 }
@@ -193,7 +193,7 @@ static void read_test(size_t num_bytes, size_t slice_size) {
   state.ep = ep;
   state.read_bytes = 0;
   state.target_read_bytes = written_bytes;
-  gpr_slice_buffer_init(&state.incoming);
+  grpc_slice_buffer_init(&state.incoming);
   grpc_closure_init(&state.read_cb, read_cb, &state);
 
   grpc_endpoint_read(&exec_ctx, ep, &state.incoming, &state.read_cb);
@@ -212,7 +212,7 @@ static void read_test(size_t num_bytes, size_t slice_size) {
   GPR_ASSERT(state.read_bytes == state.target_read_bytes);
   gpr_mu_unlock(g_mu);
 
-  gpr_slice_buffer_destroy(&state.incoming);
+  grpc_slice_buffer_destroy(&state.incoming);
   grpc_endpoint_destroy(&exec_ctx, ep);
   grpc_exec_ctx_finish(&exec_ctx);
 }
@@ -244,7 +244,7 @@ static void large_read_test(size_t slice_size) {
   state.ep = ep;
   state.read_bytes = 0;
   state.target_read_bytes = (size_t)written_bytes;
-  gpr_slice_buffer_init(&state.incoming);
+  grpc_slice_buffer_init(&state.incoming);
   grpc_closure_init(&state.read_cb, read_cb, &state);
 
   grpc_endpoint_read(&exec_ctx, ep, &state.incoming, &state.read_cb);
@@ -263,7 +263,7 @@ static void large_read_test(size_t slice_size) {
   GPR_ASSERT(state.read_bytes == state.target_read_bytes);
   gpr_mu_unlock(g_mu);
 
-  gpr_slice_buffer_destroy(&state.incoming);
+  grpc_slice_buffer_destroy(&state.incoming);
   grpc_endpoint_destroy(&exec_ctx, ep);
   grpc_exec_ctx_finish(&exec_ctx);
 }
@@ -273,21 +273,21 @@ struct write_socket_state {
   int write_done;
 };
 
-static gpr_slice *allocate_blocks(size_t num_bytes, size_t slice_size,
-                                  size_t *num_blocks, uint8_t *current_data) {
+static grpc_slice *allocate_blocks(size_t num_bytes, size_t slice_size,
+                                   size_t *num_blocks, uint8_t *current_data) {
   size_t nslices = num_bytes / slice_size + (num_bytes % slice_size ? 1u : 0u);
-  gpr_slice *slices = gpr_malloc(sizeof(gpr_slice) * nslices);
+  grpc_slice *slices = gpr_malloc(sizeof(grpc_slice) * nslices);
   size_t num_bytes_left = num_bytes;
   unsigned i, j;
   unsigned char *buf;
   *num_blocks = nslices;
 
   for (i = 0; i < nslices; ++i) {
-    slices[i] = gpr_slice_malloc(slice_size > num_bytes_left ? num_bytes_left
-                                                             : slice_size);
-    num_bytes_left -= GPR_SLICE_LENGTH(slices[i]);
-    buf = GPR_SLICE_START_PTR(slices[i]);
-    for (j = 0; j < GPR_SLICE_LENGTH(slices[i]); ++j) {
+    slices[i] = grpc_slice_malloc(slice_size > num_bytes_left ? num_bytes_left
+                                                              : slice_size);
+    num_bytes_left -= GRPC_SLICE_LENGTH(slices[i]);
+    buf = GRPC_SLICE_START_PTR(slices[i]);
+    for (j = 0; j < GRPC_SLICE_LENGTH(slices[i]); ++j) {
       buf[j] = *current_data;
       (*current_data)++;
     }
@@ -357,9 +357,9 @@ static void write_test(size_t num_bytes, size_t slice_size) {
   grpc_endpoint *ep;
   struct write_socket_state state;
   size_t num_blocks;
-  gpr_slice *slices;
+  grpc_slice *slices;
   uint8_t current_data = 0;
-  gpr_slice_buffer outgoing;
+  grpc_slice_buffer outgoing;
   grpc_closure write_done_closure;
   gpr_timespec deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE(20);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -382,8 +382,8 @@ static void write_test(size_t num_bytes, size_t slice_size) {
 
   slices = allocate_blocks(num_bytes, slice_size, &num_blocks, &current_data);
 
-  gpr_slice_buffer_init(&outgoing);
-  gpr_slice_buffer_addn(&outgoing, slices, num_blocks);
+  grpc_slice_buffer_init(&outgoing);
+  grpc_slice_buffer_addn(&outgoing, slices, num_blocks);
   grpc_closure_init(&write_done_closure, write_done, &state);
 
   grpc_endpoint_write(&exec_ctx, ep, &outgoing, &write_done_closure);
@@ -404,7 +404,7 @@ static void write_test(size_t num_bytes, size_t slice_size) {
   }
   gpr_mu_unlock(g_mu);
 
-  gpr_slice_buffer_destroy(&outgoing);
+  grpc_slice_buffer_destroy(&outgoing);
   grpc_endpoint_destroy(&exec_ctx, ep);
   gpr_free(slices);
   grpc_exec_ctx_finish(&exec_ctx);
@@ -451,7 +451,7 @@ static void release_fd_test(size_t num_bytes, size_t slice_size) {
   state.ep = ep;
   state.read_bytes = 0;
   state.target_read_bytes = written_bytes;
-  gpr_slice_buffer_init(&state.incoming);
+  grpc_slice_buffer_init(&state.incoming);
   grpc_closure_init(&state.read_cb, read_cb, &state);
 
   grpc_endpoint_read(&exec_ctx, ep, &state.incoming, &state.read_cb);
@@ -472,7 +472,7 @@ static void release_fd_test(size_t num_bytes, size_t slice_size) {
   GPR_ASSERT(state.read_bytes == state.target_read_bytes);
   gpr_mu_unlock(g_mu);
 
-  gpr_slice_buffer_destroy(&state.incoming);
+  grpc_slice_buffer_destroy(&state.incoming);
   grpc_tcp_destroy_and_release_fd(&exec_ctx, ep, &fd, &fd_released_cb);
   grpc_exec_ctx_flush(&exec_ctx);
   gpr_mu_lock(g_mu);
diff --git a/test/core/iomgr/wakeup_fd_cv_test.c b/test/core/iomgr/wakeup_fd_cv_test.c
index 82452d2157..04ae9376dd 100644
--- a/test/core/iomgr/wakeup_fd_cv_test.c
+++ b/test/core/iomgr/wakeup_fd_cv_test.c
@@ -195,16 +195,15 @@ void test_poll_cv_trigger(void) {
   GPR_ASSERT(pfds[4].revents == 0);
   GPR_ASSERT(pfds[5].revents == 0);
 
-  // Pollin on wakeup fd + socket fd
-  trigger_socket_event();
+  // Pollin on wakeupfd before poll()
   pargs.result = -2;
   gpr_thd_new(&t_id, &background_poll, &pargs, &opt);
   gpr_thd_join(t_id);
 
-  GPR_ASSERT(pargs.result == 2);
+  GPR_ASSERT(pargs.result == 1);
   GPR_ASSERT(pfds[0].revents == 0);
   GPR_ASSERT(pfds[1].revents == POLLIN);
-  GPR_ASSERT(pfds[2].revents == POLLIN);
+  GPR_ASSERT(pfds[2].revents == 0);
   GPR_ASSERT(pfds[3].revents == 0);
   GPR_ASSERT(pfds[4].revents == 0);
   GPR_ASSERT(pfds[5].revents == 0);