grpc 1.8.7 → 1.9.0.pre1

data/src/core/ext/transport/chttp2/client/secure/secure_channel_create.cc

@@ -41,10 +41,10 @@ static void client_channel_factory_ref(
     grpc_client_channel_factory* cc_factory) {}
 
 static void client_channel_factory_unref(
-    grpc_exec_ctx* exec_ctx, grpc_client_channel_factory* cc_factory) {}
+    grpc_client_channel_factory* cc_factory) {}
 
 static grpc_subchannel_args* get_secure_naming_subchannel_args(
-    grpc_exec_ctx* exec_ctx, const grpc_subchannel_args* args) {
+    const grpc_subchannel_args* args) {
   grpc_channel_credentials* channel_credentials =
       grpc_channel_credentials_find_in_args(args->args);
   if (channel_credentials == nullptr) {
@@ -68,7 +68,7 @@ static grpc_subchannel_args* get_secure_naming_subchannel_args(
   const char* server_uri_str = server_uri_arg->value.string;
   GPR_ASSERT(server_uri_str != nullptr);
   grpc_uri* server_uri =
-      grpc_uri_parse(exec_ctx, server_uri_str, true /* supress errors */);
+      grpc_uri_parse(server_uri_str, true /* supress errors */);
   GPR_ASSERT(server_uri != nullptr);
   const char* server_uri_path;
   server_uri_path =
@@ -81,7 +81,7 @@ static grpc_subchannel_args* get_secure_naming_subchannel_args(
     const char* target_uri_str =
         grpc_get_subchannel_address_uri_arg(args->args);
     grpc_uri* target_uri =
-        grpc_uri_parse(exec_ctx, target_uri_str, false /* suppress errors */);
+        grpc_uri_parse(target_uri_str, false /* suppress errors */);
     GPR_ASSERT(target_uri != nullptr);
     if (target_uri->path[0] != '\0') {  // "path" may be empty
       const grpc_slice key = grpc_slice_from_static_string(
@@ -89,7 +89,7 @@ static grpc_subchannel_args* get_secure_naming_subchannel_args(
       const char* value =
           (const char*)grpc_slice_hash_table_get(targets_info, key);
       if (value != nullptr) target_name_to_check = gpr_strdup(value);
-      grpc_slice_unref_internal(exec_ctx, key);
+      grpc_slice_unref_internal(key);
     }
     if (target_name_to_check == nullptr) {
       // If the target name to check hasn't already been set, fall back to using
@@ -107,7 +107,7 @@ static grpc_subchannel_args* get_secure_naming_subchannel_args(
   grpc_channel_args* new_args_from_connector = nullptr;
   const grpc_security_status security_status =
       grpc_channel_credentials_create_security_connector(
-          exec_ctx, channel_credentials, target_name_to_check, args->args,
+          channel_credentials, target_name_to_check, args->args,
           &subchannel_security_connector, &new_args_from_connector);
   if (security_status != GRPC_SECURITY_OK) {
     gpr_log(GPR_ERROR,
@@ -123,10 +123,10 @@ static grpc_subchannel_args* get_secure_naming_subchannel_args(
   grpc_channel_args* new_args = grpc_channel_args_copy_and_add(
       new_args_from_connector != nullptr ? new_args_from_connector : args->args,
       &new_security_connector_arg, 1);
-  GRPC_SECURITY_CONNECTOR_UNREF(exec_ctx, &subchannel_security_connector->base,
+  GRPC_SECURITY_CONNECTOR_UNREF(&subchannel_security_connector->base,
                                 "lb_channel_create");
   if (new_args_from_connector != nullptr) {
-    grpc_channel_args_destroy(exec_ctx, new_args_from_connector);
+    grpc_channel_args_destroy(new_args_from_connector);
   }
   grpc_subchannel_args* final_sc_args =
       (grpc_subchannel_args*)gpr_malloc(sizeof(*final_sc_args));
@@ -136,10 +136,9 @@ static grpc_subchannel_args* get_secure_naming_subchannel_args(
 }
 
 static grpc_subchannel* client_channel_factory_create_subchannel(
-    grpc_exec_ctx* exec_ctx, grpc_client_channel_factory* cc_factory,
-    const grpc_subchannel_args* args) {
+    grpc_client_channel_factory* cc_factory, const grpc_subchannel_args* args) {
   grpc_subchannel_args* subchannel_args =
-      get_secure_naming_subchannel_args(exec_ctx, args);
+      get_secure_naming_subchannel_args(args);
   if (subchannel_args == nullptr) {
     gpr_log(
         GPR_ERROR,
@@ -147,19 +146,16 @@ static grpc_subchannel* client_channel_factory_create_subchannel(
     return nullptr;
   }
   grpc_connector* connector = grpc_chttp2_connector_create();
-  grpc_subchannel* s =
-      grpc_subchannel_create(exec_ctx, connector, subchannel_args);
-  grpc_connector_unref(exec_ctx, connector);
-  grpc_channel_args_destroy(exec_ctx,
-                            (grpc_channel_args*)subchannel_args->args);
+  grpc_subchannel* s = grpc_subchannel_create(connector, subchannel_args);
+  grpc_connector_unref(connector);
+  grpc_channel_args_destroy((grpc_channel_args*)subchannel_args->args);
   gpr_free(subchannel_args);
   return s;
 }
 
 static grpc_channel* client_channel_factory_create_channel(
-    grpc_exec_ctx* exec_ctx, grpc_client_channel_factory* cc_factory,
-    const char* target, grpc_client_channel_type type,
-    const grpc_channel_args* args) {
+    grpc_client_channel_factory* cc_factory, const char* target,
+    grpc_client_channel_type type, const grpc_channel_args* args) {
   if (target == nullptr) {
     gpr_log(GPR_ERROR, "cannot create channel with NULL target name");
     return nullptr;
@@ -167,14 +163,14 @@ static grpc_channel* client_channel_factory_create_channel(
   // Add channel arg containing the server URI.
   grpc_arg arg = grpc_channel_arg_string_create(
       (char*)GRPC_ARG_SERVER_URI,
-      grpc_resolver_factory_add_default_prefix_if_needed(exec_ctx, target));
+      grpc_resolver_factory_add_default_prefix_if_needed(target));
   const char* to_remove[] = {GRPC_ARG_SERVER_URI};
   grpc_channel_args* new_args =
       grpc_channel_args_copy_and_add_and_remove(args, to_remove, 1, &arg, 1);
   gpr_free(arg.value.string);
-  grpc_channel* channel = grpc_channel_create(exec_ctx, target, new_args,
-                                              GRPC_CLIENT_CHANNEL, nullptr);
-  grpc_channel_args_destroy(exec_ctx, new_args);
+  grpc_channel* channel =
+      grpc_channel_create(target, new_args, GRPC_CLIENT_CHANNEL, nullptr);
+  grpc_channel_args_destroy(new_args);
   return channel;
 }
 
@@ -194,7 +190,7 @@ grpc_channel* grpc_secure_channel_create(grpc_channel_credentials* creds,
                                          const char* target,
                                          const grpc_channel_args* args,
                                          void* reserved) {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_core::ExecCtx exec_ctx;
   GRPC_API_TRACE(
       "grpc_secure_channel_create(creds=%p, target=%s, args=%p, "
       "reserved=%p)",
@@ -211,11 +207,10 @@ grpc_channel* grpc_secure_channel_create(grpc_channel_credentials* creds,
         args, args_to_add, GPR_ARRAY_SIZE(args_to_add));
     // Create channel.
     channel = client_channel_factory_create_channel(
-        &exec_ctx, &client_channel_factory, target,
-        GRPC_CLIENT_CHANNEL_TYPE_REGULAR, new_args);
+        &client_channel_factory, target, GRPC_CLIENT_CHANNEL_TYPE_REGULAR,
+        new_args);
     // Clean up.
-    grpc_channel_args_destroy(&exec_ctx, new_args);
-    grpc_exec_ctx_finish(&exec_ctx);
+    grpc_channel_args_destroy(new_args);
   }
   return channel != nullptr ? channel
                             : grpc_lame_client_channel_create(

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -69,17 +69,17 @@ typedef struct {
 } server_connection_state;
 
 static void server_connection_state_unref(
-    grpc_exec_ctx* exec_ctx, server_connection_state* connection_state) {
+    server_connection_state* connection_state) {
   if (gpr_unref(&connection_state->refs)) {
     if (connection_state->transport != nullptr) {
-      GRPC_CHTTP2_UNREF_TRANSPORT(exec_ctx, connection_state->transport,
+      GRPC_CHTTP2_UNREF_TRANSPORT(connection_state->transport,
                                   "receive settings timeout");
     }
     gpr_free(connection_state);
   }
 }
 
-static void on_timeout(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+static void on_timeout(void* arg, grpc_error* error) {
   server_connection_state* connection_state = (server_connection_state*)arg;
   // Note that we may be called with GRPC_ERROR_NONE when the timer fires
   // or with an error indicating that the timer system is being shut down.
@@ -87,22 +87,20 @@ static void on_timeout(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
     grpc_transport_op* op = grpc_make_transport_op(nullptr);
     op->disconnect_with_error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Did not receive HTTP/2 settings before handshake timeout");
-    grpc_transport_perform_op(exec_ctx, &connection_state->transport->base, op);
+    grpc_transport_perform_op(&connection_state->transport->base, op);
   }
-  server_connection_state_unref(exec_ctx, connection_state);
+  server_connection_state_unref(connection_state);
 }
 
-static void on_receive_settings(grpc_exec_ctx* exec_ctx, void* arg,
-                                grpc_error* error) {
+static void on_receive_settings(void* arg, grpc_error* error) {
   server_connection_state* connection_state = (server_connection_state*)arg;
   if (error == GRPC_ERROR_NONE) {
-    grpc_timer_cancel(exec_ctx, &connection_state->timer);
+    grpc_timer_cancel(&connection_state->timer);
   }
-  server_connection_state_unref(exec_ctx, connection_state);
+  server_connection_state_unref(connection_state);
 }
 
-static void on_handshake_done(grpc_exec_ctx* exec_ctx, void* arg,
-                              grpc_error* error) {
+static void on_handshake_done(void* arg, grpc_error* error) {
   grpc_handshaker_args* args = (grpc_handshaker_args*)arg;
   server_connection_state* connection_state =
       (server_connection_state*)args->user_data;
@@ -117,10 +115,10 @@ static void on_handshake_done(grpc_exec_ctx* exec_ctx, void* arg,
       // before destroying them, even if we know that there are no
       // pending read/write callbacks.  This should be fixed, at which
       // point this can be removed.
-      grpc_endpoint_shutdown(exec_ctx, args->endpoint, GRPC_ERROR_NONE);
-      grpc_endpoint_destroy(exec_ctx, args->endpoint);
-      grpc_channel_args_destroy(exec_ctx, args->args);
-      grpc_slice_buffer_destroy_internal(exec_ctx, args->read_buffer);
+      grpc_endpoint_shutdown(args->endpoint, GRPC_ERROR_NONE);
+      grpc_endpoint_destroy(args->endpoint);
+      grpc_channel_args_destroy(args->args);
+      grpc_slice_buffer_destroy_internal(args->read_buffer);
       gpr_free(args->read_buffer);
     }
   } else {
@@ -128,10 +126,10 @@ static void on_handshake_done(grpc_exec_ctx* exec_ctx, void* arg,
     // handshaker may have handed off the connection to some external
     // code, so we can just clean up here without creating a transport.
     if (args->endpoint != nullptr) {
-      grpc_transport* transport = grpc_create_chttp2_transport(
-          exec_ctx, args->args, args->endpoint, false);
+      grpc_transport* transport =
+          grpc_create_chttp2_transport(args->args, args->endpoint, false);
       grpc_server_setup_transport(
-          exec_ctx, connection_state->svr_state->server, transport,
+          connection_state->svr_state->server, transport,
           connection_state->accepting_pollset, args->args);
       // Use notify_on_receive_settings callback to enforce the
       // handshake deadline.
@@ -141,16 +139,14 @@ static void on_handshake_done(grpc_exec_ctx* exec_ctx, void* arg,
                         on_receive_settings, connection_state,
                         grpc_schedule_on_exec_ctx);
       grpc_chttp2_transport_start_reading(
-          exec_ctx, transport, args->read_buffer,
-          &connection_state->on_receive_settings);
-      grpc_channel_args_destroy(exec_ctx, args->args);
+          transport, args->read_buffer, &connection_state->on_receive_settings);
+      grpc_channel_args_destroy(args->args);
       gpr_ref(&connection_state->refs);
       GRPC_CHTTP2_REF_TRANSPORT((grpc_chttp2_transport*)transport,
                                 "receive settings timeout");
       GRPC_CLOSURE_INIT(&connection_state->on_timeout, on_timeout,
                         connection_state, grpc_schedule_on_exec_ctx);
-      grpc_timer_init(exec_ctx, &connection_state->timer,
-                      connection_state->deadline,
+      grpc_timer_init(&connection_state->timer, connection_state->deadline,
                       &connection_state->on_timeout);
     }
   }
@@ -158,21 +154,21 @@ static void on_handshake_done(grpc_exec_ctx* exec_ctx, void* arg,
       &connection_state->svr_state->pending_handshake_mgrs,
       connection_state->handshake_mgr);
   gpr_mu_unlock(&connection_state->svr_state->mu);
-  grpc_handshake_manager_destroy(exec_ctx, connection_state->handshake_mgr);
+  grpc_handshake_manager_destroy(connection_state->handshake_mgr);
   gpr_free(connection_state->acceptor);
-  grpc_tcp_server_unref(exec_ctx, connection_state->svr_state->tcp_server);
-  server_connection_state_unref(exec_ctx, connection_state);
+  grpc_tcp_server_unref(connection_state->svr_state->tcp_server);
+  server_connection_state_unref(connection_state);
 }
 
-static void on_accept(grpc_exec_ctx* exec_ctx, void* arg, grpc_endpoint* tcp,
+static void on_accept(void* arg, grpc_endpoint* tcp,
                       grpc_pollset* accepting_pollset,
                       grpc_tcp_server_acceptor* acceptor) {
   server_state* state = (server_state*)arg;
   gpr_mu_lock(&state->mu);
   if (state->shutdown) {
     gpr_mu_unlock(&state->mu);
-    grpc_endpoint_shutdown(exec_ctx, tcp, GRPC_ERROR_NONE);
-    grpc_endpoint_destroy(exec_ctx, tcp);
+    grpc_endpoint_shutdown(tcp, GRPC_ERROR_NONE);
+    grpc_endpoint_destroy(tcp);
     gpr_free(acceptor);
     return;
   }
@@ -188,58 +184,56 @@ static void on_accept(grpc_exec_ctx* exec_ctx, void* arg, grpc_endpoint* tcp,
   connection_state->accepting_pollset = accepting_pollset;
   connection_state->acceptor = acceptor;
   connection_state->handshake_mgr = handshake_mgr;
-  grpc_handshakers_add(exec_ctx, HANDSHAKER_SERVER, state->args,
+  grpc_handshakers_add(HANDSHAKER_SERVER, state->args,
                        connection_state->handshake_mgr);
   const grpc_arg* timeout_arg =
       grpc_channel_args_find(state->args, GRPC_ARG_SERVER_HANDSHAKE_TIMEOUT_MS);
   connection_state->deadline =
-      grpc_exec_ctx_now(exec_ctx) +
+      grpc_core::ExecCtx::Get()->Now() +
       grpc_channel_arg_get_integer(timeout_arg,
                                    {120 * GPR_MS_PER_SEC, 1, INT_MAX});
-  grpc_handshake_manager_do_handshake(exec_ctx, connection_state->handshake_mgr,
-                                      tcp, state->args,
-                                      connection_state->deadline, acceptor,
-                                      on_handshake_done, connection_state);
+  grpc_handshake_manager_do_handshake(
+      connection_state->handshake_mgr, nullptr /* interested_parties */, tcp,
+      state->args, connection_state->deadline, acceptor, on_handshake_done,
+      connection_state);
 }
 
 /* Server callback: start listening on our ports */
-static void server_start_listener(grpc_exec_ctx* exec_ctx, grpc_server* server,
-                                  void* arg, grpc_pollset** pollsets,
+static void server_start_listener(grpc_server* server, void* arg,
+                                  grpc_pollset** pollsets,
                                   size_t pollset_count) {
   server_state* state = (server_state*)arg;
   gpr_mu_lock(&state->mu);
   state->shutdown = false;
   gpr_mu_unlock(&state->mu);
-  grpc_tcp_server_start(exec_ctx, state->tcp_server, pollsets, pollset_count,
-                        on_accept, state);
+  grpc_tcp_server_start(state->tcp_server, pollsets, pollset_count, on_accept,
+                        state);
 }
 
-static void tcp_server_shutdown_complete(grpc_exec_ctx* exec_ctx, void* arg,
-                                         grpc_error* error) {
+static void tcp_server_shutdown_complete(void* arg, grpc_error* error) {
   server_state* state = (server_state*)arg;
   /* ensure all threads have unlocked */
   gpr_mu_lock(&state->mu);
   grpc_closure* destroy_done = state->server_destroy_listener_done;
   GPR_ASSERT(state->shutdown);
   grpc_handshake_manager_pending_list_shutdown_all(
-      exec_ctx, state->pending_handshake_mgrs, GRPC_ERROR_REF(error));
+      state->pending_handshake_mgrs, GRPC_ERROR_REF(error));
   gpr_mu_unlock(&state->mu);
   // Flush queued work before destroying handshaker factory, since that
   // may do a synchronous unref.
-  grpc_exec_ctx_flush(exec_ctx);
+  grpc_core::ExecCtx::Get()->Flush();
   if (destroy_done != nullptr) {
-    destroy_done->cb(exec_ctx, destroy_done->cb_arg, GRPC_ERROR_REF(error));
-    grpc_exec_ctx_flush(exec_ctx);
+    destroy_done->cb(destroy_done->cb_arg, GRPC_ERROR_REF(error));
+    grpc_core::ExecCtx::Get()->Flush();
   }
-  grpc_channel_args_destroy(exec_ctx, state->args);
+  grpc_channel_args_destroy(state->args);
   gpr_mu_destroy(&state->mu);
   gpr_free(state);
 }
 
 /* Server callback: destroy the tcp listener (so we don't generate further
    callbacks) */
-static void server_destroy_listener(grpc_exec_ctx* exec_ctx,
-                                    grpc_server* server, void* arg,
+static void server_destroy_listener(grpc_server* server, void* arg,
                                     grpc_closure* destroy_done) {
   server_state* state = (server_state*)arg;
   gpr_mu_lock(&state->mu);
@@ -247,12 +241,11 @@ static void server_destroy_listener(grpc_exec_ctx* exec_ctx,
   state->server_destroy_listener_done = destroy_done;
   grpc_tcp_server* tcp_server = state->tcp_server;
   gpr_mu_unlock(&state->mu);
-  grpc_tcp_server_shutdown_listeners(exec_ctx, tcp_server);
-  grpc_tcp_server_unref(exec_ctx, tcp_server);
+  grpc_tcp_server_shutdown_listeners(tcp_server);
+  grpc_tcp_server_unref(tcp_server);
 }
 
-grpc_error* grpc_chttp2_server_add_port(grpc_exec_ctx* exec_ctx,
-                                        grpc_server* server, const char* addr,
+grpc_error* grpc_chttp2_server_add_port(grpc_server* server, const char* addr,
                                         grpc_channel_args* args,
                                         int* port_num) {
   grpc_resolved_addresses* resolved = nullptr;
@@ -276,8 +269,8 @@ grpc_error* grpc_chttp2_server_add_port(grpc_exec_ctx* exec_ctx,
   GRPC_CLOSURE_INIT(&state->tcp_server_shutdown_complete,
                     tcp_server_shutdown_complete, state,
                     grpc_schedule_on_exec_ctx);
-  err = grpc_tcp_server_create(exec_ctx, &state->tcp_server_shutdown_complete,
-                               args, &tcp_server);
+  err = grpc_tcp_server_create(&state->tcp_server_shutdown_complete, args,
+                               &tcp_server);
   if (err != GRPC_ERROR_NONE) {
     goto error;
   }
@@ -326,7 +319,7 @@ grpc_error* grpc_chttp2_server_add_port(grpc_exec_ctx* exec_ctx,
   grpc_resolved_addresses_destroy(resolved);
 
   /* Register with the server only upon success */
-  grpc_server_add_listener(exec_ctx, server, state, server_start_listener,
+  grpc_server_add_listener(server, state, server_start_listener,
                            server_destroy_listener);
   goto done;
 
@@ -337,9 +330,9 @@ error:
     grpc_resolved_addresses_destroy(resolved);
   }
   if (tcp_server) {
-    grpc_tcp_server_unref(exec_ctx, tcp_server);
+    grpc_tcp_server_unref(tcp_server);
   } else {
-    grpc_channel_args_destroy(exec_ctx, args);
+    grpc_channel_args_destroy(args);
     gpr_free(state);
   }
   *port_num = 0;

data/src/core/ext/transport/chttp2/server/chttp2_server.h

@@ -23,18 +23,9 @@
 
 #include "src/core/lib/iomgr/exec_ctx.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /// Adds a port to \a server.  Sets \a port_num to the port number.
 /// Takes ownership of \a args.
-grpc_error* grpc_chttp2_server_add_port(grpc_exec_ctx* exec_ctx,
-                                        grpc_server* server, const char* addr,
+grpc_error* grpc_chttp2_server_add_port(grpc_server* server, const char* addr,
                                         grpc_channel_args* args, int* port_num);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_SERVER_CHTTP2_SERVER_H */

data/src/core/ext/transport/chttp2/server/insecure/server_chttp2.cc

@@ -26,12 +26,12 @@
 #include "src/core/lib/surface/server.h"
 
 int grpc_server_add_insecure_http2_port(grpc_server* server, const char* addr) {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_core::ExecCtx exec_ctx;
   int port_num = 0;
   GRPC_API_TRACE("grpc_server_add_insecure_http2_port(server=%p, addr=%s)", 2,
                  (server, addr));
   grpc_error* err = grpc_chttp2_server_add_port(
-      &exec_ctx, server, addr,
+      server, addr,
       grpc_channel_args_copy(grpc_server_get_channel_args(server)), &port_num);
   if (err != GRPC_ERROR_NONE) {
     const char* msg = grpc_error_string(err);
@@ -39,6 +39,6 @@ int grpc_server_add_insecure_http2_port(grpc_server* server, const char* addr) {
 
     GRPC_ERROR_UNREF(err);
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+
   return port_num;
 }

data/src/core/ext/transport/chttp2/server/insecure/server_chttp2_posix.cc

@@ -38,32 +38,29 @@ void grpc_server_add_insecure_channel_from_fd(grpc_server* server,
                                               void* reserved, int fd) {
   GPR_ASSERT(reserved == nullptr);
 
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_core::ExecCtx exec_ctx;
   char* name;
   gpr_asprintf(&name, "fd:%d", fd);
 
-  grpc_endpoint* server_endpoint =
-      grpc_tcp_create(&exec_ctx, grpc_fd_create(fd, name),
-                      grpc_server_get_channel_args(server), name);
+  grpc_endpoint* server_endpoint = grpc_tcp_create(
+      grpc_fd_create(fd, name), grpc_server_get_channel_args(server), name);
 
   gpr_free(name);
 
   const grpc_channel_args* server_args = grpc_server_get_channel_args(server);
   grpc_transport* transport = grpc_create_chttp2_transport(
-      &exec_ctx, server_args, server_endpoint, false /* is_client */);
+      server_args, server_endpoint, false /* is_client */);
 
   grpc_pollset** pollsets;
   size_t num_pollsets = 0;
   grpc_server_get_pollsets(server, &pollsets, &num_pollsets);
 
   for (size_t i = 0; i < num_pollsets; i++) {
-    grpc_endpoint_add_to_pollset(&exec_ctx, server_endpoint, pollsets[i]);
+    grpc_endpoint_add_to_pollset(server_endpoint, pollsets[i]);
   }
 
-  grpc_server_setup_transport(&exec_ctx, server, transport, nullptr,
-                              server_args);
-  grpc_chttp2_transport_start_reading(&exec_ctx, transport, nullptr, nullptr);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_server_setup_transport(server, transport, nullptr, server_args);
+  grpc_chttp2_transport_start_reading(transport, nullptr, nullptr);
 }
 
 #else  // !GPR_SUPPORT_CHANNELS_FROM_FD