allocate grpc_pops on the stack

src/core/lib/iomgr/pops.c

@@ -36,50 +36,44 @@
 
 #include "src/core/lib/iomgr/pops.h"
 
-struct grpc_pops {
-  union {
-    grpc_pollset *pollset;
-    grpc_pollset_set *pollset_set;
-  } pops;
-  enum pops_tag { POLLSET, POLLSET_SET } tag;
-};
-
-grpc_pops *grpc_pops_create_from_pollset_set(grpc_pollset_set *pollset_set) {
-  grpc_pops *pops = gpr_malloc(sizeof(grpc_pops));
-  pops->pops.pollset_set = pollset_set;
-  pops->tag = POLLSET_SET;
+grpc_pops grpc_pops_create_from_pollset_set(grpc_pollset_set *pollset_set) {
+  grpc_pops pops;
+  pops.pops.pollset_set = pollset_set;
+  pops.tag = POPS_POLLSET_SET;
   return pops;
 }
 
-grpc_pops *grpc_pops_create_from_pollset(grpc_pollset *pollset) {
-  grpc_pops *pops = gpr_malloc(sizeof(grpc_pops));
-  pops->pops.pollset = pollset;
-  pops->tag = POLLSET;
+grpc_pops grpc_pops_create_from_pollset(grpc_pollset *pollset) {
+  grpc_pops pops;
+  pops.pops.pollset = pollset;
+  pops.tag = POPS_POLLSET;
   return pops;
 }
 
-void grpc_pops_destroy(grpc_pops *pops) { gpr_free(pops); }
-
 grpc_pollset *grpc_pops_pollset(grpc_pops *pops) {
-  if (pops->tag == POLLSET) {
+  if (pops->tag == POPS_POLLSET) {
     return pops->pops.pollset;
   }
   return NULL;
 }
 
 grpc_pollset_set *grpc_pops_pollset_set(grpc_pops *pops) {
-  if (pops->tag == POLLSET_SET) {
+  if (pops->tag == POPS_POLLSET_SET) {
     return pops->pops.pollset_set;
   }
   return NULL;
 }
 
+bool grpc_pops_is_empty(const grpc_pops *pops) {
+  return pops->tag == POPS_NONE;
+}
+
 void grpc_pops_add_to_pollset_set(grpc_exec_ctx *exec_ctx, grpc_pops *pops,
                                   grpc_pollset_set *pss_dst) {
-  if (pops->tag == POLLSET) {
+  if (pops->tag == POPS_POLLSET) {
     GPR_ASSERT(pops->pops.pollset != NULL);
     grpc_pollset_set_add_pollset(exec_ctx, pss_dst, pops->pops.pollset);
-  } else if (pops->tag == POLLSET_SET) {
+  } else if (pops->tag == POPS_POLLSET_SET) {
     GPR_ASSERT(pops->pops.pollset_set != NULL);
     grpc_pollset_set_add_pollset_set(exec_ctx, pss_dst, pops->pops.pollset_set);
   } else {
@@ -90,10 +84,10 @@ void grpc_pops_add_to_pollset_set(grpc_exec_ctx *exec_ctx, grpc_pops *pops,
 
 void grpc_pops_del_to_pollset_set(grpc_exec_ctx *exec_ctx, grpc_pops *pops,
                                   grpc_pollset_set *pss_dst) {
-  if (pops->tag == POLLSET) {
+  if (pops->tag == POPS_POLLSET) {
     GPR_ASSERT(pops->pops.pollset != NULL);
     grpc_pollset_set_del_pollset(exec_ctx, pss_dst, pops->pops.pollset);
-  } else if (pops->tag == POLLSET_SET) {
+  } else if (pops->tag == POPS_POLLSET_SET) {
     GPR_ASSERT(pops->pops.pollset_set != NULL);
     grpc_pollset_set_del_pollset_set(exec_ctx, pss_dst, pops->pops.pollset_set);
   } else {

src/core/lib/iomgr/pops.h

@@ -41,10 +41,16 @@
  * accept a pollset XOR a pollset_set to do so through an abstract interface.
  * No ownership is taken. */
 
-typedef struct grpc_pops grpc_pops;
+typedef struct grpc_pops {
+  union {
+    grpc_pollset *pollset;
+    grpc_pollset_set *pollset_set;
+  } pops;
+  enum pops_tag { POPS_NONE, POPS_POLLSET, POPS_POLLSET_SET } tag;
+} grpc_pops;
 
-grpc_pops *grpc_pops_create_from_pollset_set(grpc_pollset_set *pollset_set);
-grpc_pops *grpc_pops_create_from_pollset(grpc_pollset *pollset);
+grpc_pops grpc_pops_create_from_pollset_set(grpc_pollset_set *pollset_set);
+grpc_pops grpc_pops_create_from_pollset(grpc_pollset *pollset);
 
 /** If \a pops contains a pollset, return it. Otherwise, return NULL */
 grpc_pollset *grpc_pops_pollset(grpc_pops *pops);
@@ -52,7 +58,7 @@ grpc_pollset *grpc_pops_pollset(grpc_pops *pops);
 /** If \a pops contains a pollset_set, return it. Otherwise, return NULL */
 grpc_pollset_set *grpc_pops_pollset_set(grpc_pops *pops);
 
-void grpc_pops_destroy(grpc_pops *pops);
+bool grpc_pops_is_empty(const grpc_pops *pops);
 
 /** Add the pollset or pollset_set in \a pops to the destination pollset_set \a
  * pss_dst */

src/core/lib/security/google_default_credentials.c

@@ -61,7 +61,7 @@ static gpr_once g_once = GPR_ONCE_INIT;
 static void init_default_credentials(void) { gpr_mu_init(&g_state_mu); }
 
 typedef struct {
-  grpc_pops *pops;
+  grpc_pops pops;
   int is_done;
   int success;
 } compute_engine_detector;
@@ -85,7 +85,7 @@ static void on_compute_engine_detection_http_response(
   }
   gpr_mu_lock(g_polling_mu);
   detector->is_done = 1;
-  grpc_pollset_kick(grpc_pops_pollset(detector->pops), NULL);
+  grpc_pollset_kick(grpc_pops_pollset(&detector->pops), NULL);
   gpr_mu_unlock(g_polling_mu);
 }
 
@@ -117,7 +117,7 @@ static int is_stack_running_on_compute_engine(void) {
   grpc_httpcli_context_init(&context);
 
   grpc_httpcli_get(
-      &exec_ctx, &context, detector.pops, &request,
+      &exec_ctx, &context, &detector.pops, &request,
       gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), max_detection_delay),
       on_compute_engine_detection_http_response, &detector);
 
@@ -128,7 +128,7 @@ static int is_stack_running_on_compute_engine(void) {
   gpr_mu_lock(g_polling_mu);
   while (!detector.is_done) {
     grpc_pollset_worker *worker = NULL;
-    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(detector.pops), &worker,
+    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(&detector.pops), &worker,
                       gpr_now(GPR_CLOCK_MONOTONIC),
                       gpr_inf_future(GPR_CLOCK_MONOTONIC));
   }
@@ -136,14 +136,13 @@ static int is_stack_running_on_compute_engine(void) {
 
   grpc_httpcli_context_destroy(&context);
   grpc_closure_init(&destroy_closure, destroy_pollset,
-                    grpc_pops_pollset(detector.pops));
-  grpc_pollset_shutdown(&exec_ctx, grpc_pops_pollset(detector.pops),
+                    grpc_pops_pollset(&detector.pops));
+  grpc_pollset_shutdown(&exec_ctx, grpc_pops_pollset(&detector.pops),
                         &destroy_closure);
   grpc_exec_ctx_finish(&exec_ctx);
   g_polling_mu = NULL;
 
-  gpr_free(grpc_pops_pollset(detector.pops));
-  grpc_pops_destroy(detector.pops);
+  gpr_free(grpc_pops_pollset(&detector.pops));
 
   return detector.success;
 }

src/core/lib/security/jwt_verifier.c

@@ -322,7 +322,7 @@ grpc_jwt_verifier_status grpc_jwt_claims_check(const grpc_jwt_claims *claims,
 
 typedef struct {
   grpc_jwt_verifier *verifier;
-  grpc_pops *pops;
+  grpc_pops pops;
   jose_header *header;
   grpc_jwt_claims *claims;
   char *audience;
@@ -360,7 +360,6 @@ void verifier_cb_ctx_destroy(verifier_cb_ctx *ctx) {
   gpr_slice_unref(ctx->signature);
   gpr_slice_unref(ctx->signed_data);
   jose_header_destroy(ctx->header);
-  grpc_pops_destroy(ctx->pops);
   /* TODO: see what to do with claims... */
   gpr_free(ctx);
 }
@@ -646,7 +645,7 @@ static void on_openid_config_retrieved(grpc_exec_ctx *exec_ctx, void *user_data,
     *(req.host + (req.http.path - jwks_uri)) = '\0';
   }
   grpc_httpcli_get(
-      exec_ctx, &ctx->verifier->http_ctx, ctx->pops, &req,
+      exec_ctx, &ctx->verifier->http_ctx, &ctx->pops, &req,
       gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), grpc_jwt_verifier_max_delay),
       on_keys_retrieved, ctx);
   grpc_json_destroy(json);
@@ -749,7 +748,7 @@ static void retrieve_key_and_verify(grpc_exec_ctx *exec_ctx,
   }
 
   grpc_httpcli_get(
-      exec_ctx, &ctx->verifier->http_ctx, ctx->pops, &req,
+      exec_ctx, &ctx->verifier->http_ctx, &ctx->pops, &req,
       gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), grpc_jwt_verifier_max_delay),
       http_cb, ctx);
   gpr_free(req.host);

src/core/lib/surface/call.c

@@ -135,7 +135,7 @@ typedef struct batch_control {
 
 struct grpc_call {
   grpc_completion_queue *cq;
-  grpc_pops *pops;
+  grpc_pops pops;
   grpc_channel *channel;
   grpc_call *parent;
   grpc_call *first_child;
@@ -292,9 +292,9 @@ grpc_call *grpc_call_create(
   if (pollset_set_alternative != NULL) {
     call->pops = grpc_pops_create_from_pollset_set(pollset_set_alternative);
   }
-  if (call->pops != NULL) {
+  if (!grpc_pops_is_empty(&call->pops)) {
     grpc_call_stack_set_pollset_or_pollset_set(
-        &exec_ctx, CALL_STACK_FROM_CALL(call), call->pops);
+        &exec_ctx, CALL_STACK_FROM_CALL(call), &call->pops);
   }
   if (parent_call != NULL) {
     GRPC_CALL_INTERNAL_REF(parent_call, "child");
@@ -350,18 +350,15 @@ void grpc_call_set_completion_queue(grpc_exec_ctx *exec_ctx, grpc_call *call,
                                     grpc_completion_queue *cq) {
   GPR_ASSERT(cq);
 
-  if (call->pops != NULL && grpc_pops_pollset_set(call->pops) != NULL) {
+  if (grpc_pops_pollset_set(&call->pops) != NULL) {
     gpr_log(GPR_ERROR, "A pollset_set is already registered for this call.");
     abort();
   }
   call->cq = cq;
   GRPC_CQ_INTERNAL_REF(cq, "bind");
-  if (call->pops != NULL) {
-    grpc_pops_destroy(call->pops);
-  }
   call->pops = grpc_pops_create_from_pollset(grpc_cq_pollset(cq));
   grpc_call_stack_set_pollset_or_pollset_set(
-      exec_ctx, CALL_STACK_FROM_CALL(call), call->pops);
+      exec_ctx, CALL_STACK_FROM_CALL(call), &call->pops);
 }
 
 #ifdef GRPC_STREAM_REFCOUNT_DEBUG
@@ -407,7 +404,6 @@ static void destroy_call(grpc_exec_ctx *exec_ctx, void *call, bool success) {
   if (c->cq) {
     GRPC_CQ_INTERNAL_UNREF(c->cq, "bind");
   }
-  grpc_pops_destroy(c->pops);
   grpc_channel *channel = c->channel;
   grpc_call_stack_destroy(exec_ctx, CALL_STACK_FROM_CALL(c), c);
   GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, channel, "call");

test/core/http/httpcli_test.c

@@ -48,7 +48,7 @@
 static int g_done = 0;
 static grpc_httpcli_context g_context;
 static gpr_mu *g_mu;
-static grpc_pops *g_pops;
+static grpc_pops g_pops;
 
 static gpr_timespec n_seconds_time(int seconds) {
   return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(seconds);
@@ -66,7 +66,7 @@ static void on_finish(grpc_exec_ctx *exec_ctx, void *arg,
   GPR_ASSERT(0 == memcmp(expect, response->body, response->body_length));
   gpr_mu_lock(g_mu);
   g_done = 1;
-  grpc_pollset_kick(grpc_pops_pollset(g_pops), NULL);
+  grpc_pollset_kick(grpc_pops_pollset(&g_pops), NULL);
   gpr_mu_unlock(g_mu);
 }
 
@@ -86,12 +86,12 @@ static void test_get(int port) {
   req.http.path = "/get";
   req.handshaker = &grpc_httpcli_plaintext;
 
-  grpc_httpcli_get(&exec_ctx, &g_context, g_pops, &req, n_seconds_time(15),
+  grpc_httpcli_get(&exec_ctx, &g_context, &g_pops, &req, n_seconds_time(15),
                    on_finish, (void *)42);
   gpr_mu_lock(g_mu);
   while (!g_done) {
     grpc_pollset_worker *worker = NULL;
-    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(g_pops), &worker,
+    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(&g_pops), &worker,
                       gpr_now(GPR_CLOCK_MONOTONIC), n_seconds_time(20));
     gpr_mu_unlock(g_mu);
     grpc_exec_ctx_finish(&exec_ctx);
@@ -117,12 +117,12 @@ static void test_post(int port) {
   req.http.path = "/post";
   req.handshaker = &grpc_httpcli_plaintext;
 
-  grpc_httpcli_post(&exec_ctx, &g_context, g_pops, &req, "hello", 5,
+  grpc_httpcli_post(&exec_ctx, &g_context, &g_pops, &req, "hello", 5,
                     n_seconds_time(15), on_finish, (void *)42);
   gpr_mu_lock(g_mu);
   while (!g_done) {
     grpc_pollset_worker *worker = NULL;
-    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(g_pops), &worker,
+    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(&g_pops), &worker,
                       gpr_now(GPR_CLOCK_MONOTONIC), n_seconds_time(20));
     gpr_mu_unlock(g_mu);
     grpc_exec_ctx_finish(&exec_ctx);
@@ -188,13 +188,12 @@ int main(int argc, char **argv) {
   test_post(port);
 
   grpc_httpcli_context_destroy(&g_context);
-  grpc_closure_init(&destroyed, destroy_pops, g_pops);
-  grpc_pollset_shutdown(&exec_ctx, grpc_pops_pollset(g_pops), &destroyed);
+  grpc_closure_init(&destroyed, destroy_pops, &g_pops);
+  grpc_pollset_shutdown(&exec_ctx, grpc_pops_pollset(&g_pops), &destroyed);
   grpc_exec_ctx_finish(&exec_ctx);
   grpc_shutdown();
 
-  gpr_free(grpc_pops_pollset(g_pops));
-  grpc_pops_destroy(g_pops);
+  gpr_free(grpc_pops_pollset(&g_pops));
 
   gpr_subprocess_destroy(server);
 

test/core/http/httpscli_test.c

@@ -48,7 +48,7 @@
 static int g_done = 0;
 static grpc_httpcli_context g_context;
 static gpr_mu *g_mu;
-static grpc_pops *g_pops;
+static grpc_pops g_pops;
 
 static gpr_timespec n_seconds_time(int seconds) {
   return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(seconds);
@@ -66,7 +66,7 @@ static void on_finish(grpc_exec_ctx *exec_ctx, void *arg,
   GPR_ASSERT(0 == memcmp(expect, response->body, response->body_length));
   gpr_mu_lock(g_mu);
   g_done = 1;
-  grpc_pollset_kick(grpc_pops_pollset(g_pops), NULL);
+  grpc_pollset_kick(grpc_pops_pollset(&g_pops), NULL);
   gpr_mu_unlock(g_mu);
 }
 
@@ -87,12 +87,12 @@ static void test_get(int port) {
   req.http.path = "/get";
   req.handshaker = &grpc_httpcli_ssl;
 
-  grpc_httpcli_get(&exec_ctx, &g_context, g_pops, &req, n_seconds_time(15),
+  grpc_httpcli_get(&exec_ctx, &g_context, &g_pops, &req, n_seconds_time(15),
                    on_finish, (void *)42);
   gpr_mu_lock(g_mu);
   while (!g_done) {
     grpc_pollset_worker *worker = NULL;
-    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(g_pops), &worker,
+    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(&g_pops), &worker,
                       gpr_now(GPR_CLOCK_MONOTONIC), n_seconds_time(20));
     gpr_mu_unlock(g_mu);
     grpc_exec_ctx_finish(&exec_ctx);
@@ -119,12 +119,12 @@ static void test_post(int port) {
   req.http.path = "/post";
   req.handshaker = &grpc_httpcli_ssl;
 
-  grpc_httpcli_post(&exec_ctx, &g_context, g_pops, &req, "hello", 5,
+  grpc_httpcli_post(&exec_ctx, &g_context, &g_pops, &req, "hello", 5,
                     n_seconds_time(15), on_finish, (void *)42);
   gpr_mu_lock(g_mu);
   while (!g_done) {
     grpc_pollset_worker *worker = NULL;
-    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(g_pops), &worker,
+    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(&g_pops), &worker,
                       gpr_now(GPR_CLOCK_MONOTONIC), n_seconds_time(20));
     gpr_mu_unlock(g_mu);
     grpc_exec_ctx_finish(&exec_ctx);
@@ -191,13 +191,12 @@ int main(int argc, char **argv) {
   test_post(port);
 
   grpc_httpcli_context_destroy(&g_context);
-  grpc_closure_init(&destroyed, destroy_pops, g_pops);
-  grpc_pollset_shutdown(&exec_ctx, grpc_pops_pollset(g_pops), &destroyed);
+  grpc_closure_init(&destroyed, destroy_pops, &g_pops);
+  grpc_pollset_shutdown(&exec_ctx, grpc_pops_pollset(&g_pops), &destroyed);
   grpc_exec_ctx_finish(&exec_ctx);
   grpc_shutdown();
 
-  gpr_free(grpc_pops_pollset(g_pops));
-  grpc_pops_destroy(g_pops);
+  gpr_free(grpc_pops_pollset(&g_pops));
 
   gpr_subprocess_destroy(server);
 

test/core/security/oauth2_utils.c

@@ -46,7 +46,7 @@
 
 typedef struct {
   gpr_mu *mu;
-  grpc_pops *pops;
+  grpc_pops pops;
   int is_done;
   char *token;
 } oauth2_request;
@@ -70,7 +70,7 @@ static void on_oauth2_response(grpc_exec_ctx *exec_ctx, void *user_data,
   gpr_mu_lock(request->mu);
   request->is_done = 1;
   request->token = token;
-  grpc_pollset_kick(grpc_pops_pollset(request->pops), NULL);
+  grpc_pollset_kick(grpc_pops_pollset(&request->pops), NULL);
   gpr_mu_unlock(request->mu);
 }
 
@@ -90,23 +90,22 @@ char *grpc_test_fetch_oauth2_token_with_credentials(
   grpc_closure_init(&do_nothing_closure, do_nothing, NULL);
 
   grpc_call_credentials_get_request_metadata(
-      &exec_ctx, creds, request.pops, null_ctx, on_oauth2_response, &request);
+      &exec_ctx, creds, &request.pops, null_ctx, on_oauth2_response, &request);
 
   grpc_exec_ctx_finish(&exec_ctx);
 
   gpr_mu_lock(request.mu);
   while (!request.is_done) {
     grpc_pollset_worker *worker = NULL;
-    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(request.pops), &worker,
+    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(&request.pops), &worker,
                       gpr_now(GPR_CLOCK_MONOTONIC),
                       gpr_inf_future(GPR_CLOCK_MONOTONIC));
   }
   gpr_mu_unlock(request.mu);
 
-  grpc_pollset_shutdown(&exec_ctx, grpc_pops_pollset(request.pops),
+  grpc_pollset_shutdown(&exec_ctx, grpc_pops_pollset(&request.pops),
                         &do_nothing_closure);
   grpc_exec_ctx_finish(&exec_ctx);
-  gpr_free(grpc_pops_pollset(request.pops));
-  grpc_pops_destroy(request.pops);
+  gpr_free(grpc_pops_pollset(&request.pops));
   return request.token;
 }

test/core/security/print_google_default_creds_token.c

@@ -47,7 +47,7 @@
 
 typedef struct {
   gpr_mu *mu;
-  grpc_pops *pops;
+  grpc_pops pops;
   int is_done;
 } synchronizer;
 
@@ -66,7 +66,7 @@ static void on_metadata_response(grpc_exec_ctx *exec_ctx, void *user_data,
   }
   gpr_mu_lock(sync->mu);
   sync->is_done = 1;
-  grpc_pollset_kick(grpc_pops_pollset(sync->pops), NULL);
+  grpc_pollset_kick(grpc_pops_pollset(&sync->pops), NULL);
   gpr_mu_unlock(sync->mu);
 }
 
@@ -100,12 +100,12 @@ int main(int argc, char **argv) {
 
   grpc_call_credentials_get_request_metadata(
       &exec_ctx, ((grpc_composite_channel_credentials *)creds)->call_creds,
-      sync.pops, context, on_metadata_response, &sync);
+      &sync.pops, context, on_metadata_response, &sync);
 
   gpr_mu_lock(sync.mu);
   while (!sync.is_done) {
     grpc_pollset_worker *worker = NULL;
-    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(sync.pops), &worker,
+    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(&sync.pops), &worker,
                       gpr_now(GPR_CLOCK_MONOTONIC),
                       gpr_inf_future(GPR_CLOCK_MONOTONIC));
     gpr_mu_unlock(sync.mu);
@@ -117,8 +117,7 @@ int main(int argc, char **argv) {
   grpc_exec_ctx_finish(&exec_ctx);
 
   grpc_channel_credentials_release(creds);
-  gpr_free(grpc_pops_pollset(sync.pops));
-  grpc_pops_destroy(sync.pops);
+  gpr_free(grpc_pops_pollset(&sync.pops));
 
 end:
   gpr_cmdline_destroy(cl);

test/core/util/port_server_client.c

@@ -51,7 +51,7 @@
 
 typedef struct freereq {
   gpr_mu *mu;
-  grpc_pops *pops;
+  grpc_pops pops;
   int done;
 } freereq;
 
@@ -60,7 +60,6 @@ static void destroy_pops_and_shutdown(grpc_exec_ctx *exec_ctx, void *p,
   grpc_pollset *pollset = grpc_pops_pollset(p);
   grpc_pollset_destroy(pollset);
   gpr_free(pollset);
-  grpc_pops_destroy(p);
   grpc_shutdown();
 }
 
@@ -69,7 +68,7 @@ static void freed_port_from_server(grpc_exec_ctx *exec_ctx, void *arg,
   freereq *pr = arg;
   gpr_mu_lock(pr->mu);
   pr->done = 1;
-  grpc_pollset_kick(grpc_pops_pollset(pr->pops), NULL);
+  grpc_pollset_kick(grpc_pops_pollset(&pr->pops), NULL);
   gpr_mu_unlock(pr->mu);
 }
 
@@ -89,20 +88,20 @@ void grpc_free_port_using_server(char *server, int port) {
   grpc_pollset *pollset = gpr_malloc(grpc_pollset_size());
   grpc_pollset_init(pollset, &pr.mu);
   pr.pops = grpc_pops_create_from_pollset(pollset);
-  shutdown_closure = grpc_closure_create(destroy_pops_and_shutdown, pr.pops);
+  shutdown_closure = grpc_closure_create(destroy_pops_and_shutdown, &pr.pops);
 
   req.host = server;
   gpr_asprintf(&path, "/drop/%d", port);
   req.http.path = path;
 
   grpc_httpcli_context_init(&context);
-  grpc_httpcli_get(&exec_ctx, &context, pr.pops, &req,
+  grpc_httpcli_get(&exec_ctx, &context, &pr.pops, &req,
                    GRPC_TIMEOUT_SECONDS_TO_DEADLINE(10), freed_port_from_server,
                    &pr);
   gpr_mu_lock(pr.mu);
   while (!pr.done) {
     grpc_pollset_worker *worker = NULL;
-    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(pr.pops), &worker,
+    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(&pr.pops), &worker,
                       gpr_now(GPR_CLOCK_MONOTONIC),
                       GRPC_TIMEOUT_SECONDS_TO_DEADLINE(1));
   }
@@ -110,7 +109,7 @@ void grpc_free_port_using_server(char *server, int port) {
 
   grpc_httpcli_context_destroy(&context);
   grpc_exec_ctx_finish(&exec_ctx);
-  grpc_pollset_shutdown(&exec_ctx, grpc_pops_pollset(pr.pops),
+  grpc_pollset_shutdown(&exec_ctx, grpc_pops_pollset(&pr.pops),
                         shutdown_closure);
   grpc_exec_ctx_finish(&exec_ctx);
   gpr_free(path);
@@ -118,7 +117,7 @@ void grpc_free_port_using_server(char *server, int port) {
 
 typedef struct portreq {
   gpr_mu *mu;
-  grpc_pops *pops;
+  grpc_pops pops;
   int port;
   int retries;
   char *server;
@@ -154,7 +153,7 @@ static void got_port_from_server(grpc_exec_ctx *exec_ctx, void *arg,
     pr->retries++;
     req.host = pr->server;
     req.http.path = "/get";
-    grpc_httpcli_get(exec_ctx, pr->ctx, pr->pops, &req,
+    grpc_httpcli_get(exec_ctx, pr->ctx, &pr->pops, &req,
                      GRPC_TIMEOUT_SECONDS_TO_DEADLINE(10), got_port_from_server,
                      pr);
     return;
@@ -168,7 +167,7 @@ static void got_port_from_server(grpc_exec_ctx *exec_ctx, void *arg,
   GPR_ASSERT(port > 1024);
   gpr_mu_lock(pr->mu);
   pr->port = port;
-  grpc_pollset_kick(grpc_pops_pollset(pr->pops), NULL);
+  grpc_pollset_kick(grpc_pops_pollset(&pr->pops), NULL);
   gpr_mu_unlock(pr->mu);
 }
 
@@ -186,7 +185,7 @@ int grpc_pick_port_using_server(char *server) {
   grpc_pollset *pollset = gpr_malloc(grpc_pollset_size());
   grpc_pollset_init(pollset, &pr.mu);
   pr.pops = grpc_pops_create_from_pollset(pollset);
-  shutdown_closure = grpc_closure_create(destroy_pops_and_shutdown, pr.pops);
+  shutdown_closure = grpc_closure_create(destroy_pops_and_shutdown, &pr.pops);
   pr.port = -1;
   pr.server = server;
   pr.ctx = &context;
@@ -195,21 +194,21 @@ int grpc_pick_port_using_server(char *server) {
   req.http.path = "/get";
 
   grpc_httpcli_context_init(&context);
-  grpc_httpcli_get(&exec_ctx, &context, pr.pops, &req,
+  grpc_httpcli_get(&exec_ctx, &context, &pr.pops, &req,
                    GRPC_TIMEOUT_SECONDS_TO_DEADLINE(10), got_port_from_server,
                    &pr);
   grpc_exec_ctx_finish(&exec_ctx);
   gpr_mu_lock(pr.mu);
   while (pr.port == -1) {
     grpc_pollset_worker *worker = NULL;
-    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(pr.pops), &worker,
+    grpc_pollset_work(&exec_ctx, grpc_pops_pollset(&pr.pops), &worker,
                       gpr_now(GPR_CLOCK_MONOTONIC),
                       GRPC_TIMEOUT_SECONDS_TO_DEADLINE(1));
   }
   gpr_mu_unlock(pr.mu);
 
   grpc_httpcli_context_destroy(&context);
-  grpc_pollset_shutdown(&exec_ctx, grpc_pops_pollset(pr.pops),
+  grpc_pollset_shutdown(&exec_ctx, grpc_pops_pollset(&pr.pops),
                         shutdown_closure);
   grpc_exec_ctx_finish(&exec_ctx);