Address comments: change names and remove unnecessary lines

src/core/lib/iomgr/iomgr_uv.c

@@ -26,14 +26,14 @@
 #include "src/core/lib/iomgr/pollset_uv.h"
 #include "src/core/lib/iomgr/tcp_uv.h"
 
-gpr_thd_id grpc_init_thread;
+gpr_thd_id g_init_thread;
 
 void grpc_iomgr_platform_init(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_pollset_global_init();
   grpc_register_tracer(&grpc_tcp_trace);
   grpc_executor_set_threading(&exec_ctx, false);
-  grpc_init_thread = gpr_thd_currentid();
+  g_init_thread = gpr_thd_currentid();
   grpc_exec_ctx_finish(&exec_ctx);
 }
 void grpc_iomgr_platform_flush(void) {}

src/core/lib/iomgr/iomgr_uv.h

@@ -25,13 +25,13 @@
 
 /* The thread ID of the thread on which grpc was initialized. Used to verify
  * that all calls into libuv are made on that same thread */
-extern gpr_thd_id grpc_init_thread;
+extern gpr_thd_id g_init_thread;
 
 #ifdef GRPC_UV_THREAD_CHECK
-#define GRPC_ASSERT_SAME_THREAD() \
-  GPR_ASSERT(gpr_thd_currentid() == grpc_init_thread)
+#define GRPC_UV_ASSERT_SAME_THREAD() \
+  GPR_ASSERT(gpr_thd_currentid() == g_init_thread)
 #else
-#define GRPC_ASSERT_SAME_THREAD()
+#define GRPC_UV_ASSERT_SAME_THREAD()
 #endif /* GRPC_UV_THREAD_CHECK */
 
 #endif /* GRPC_CORE_LIB_IOMGR_IOMGR_UV_H */

src/core/lib/iomgr/pollset_uv.c

@@ -71,7 +71,7 @@ void grpc_pollset_global_init(void) {
 }
 
 void grpc_pollset_global_shutdown(void) {
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
   gpr_mu_destroy(&grpc_polling_mu);
   uv_close((uv_handle_t *)dummy_uv_handle, dummy_handle_close_cb);
 }
@@ -81,7 +81,7 @@ static void timer_run_cb(uv_timer_t *timer) {}
 static void timer_close_cb(uv_handle_t *handle) { handle->data = (void *)1; }
 
 void grpc_pollset_init(grpc_pollset *pollset, gpr_mu **mu) {
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
   *mu = &grpc_polling_mu;
   uv_timer_init(uv_default_loop(), &pollset->timer);
   pollset->shutting_down = 0;
@@ -90,7 +90,7 @@ void grpc_pollset_init(grpc_pollset *pollset, gpr_mu **mu) {
 void grpc_pollset_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
                            grpc_closure *closure) {
   GPR_ASSERT(!pollset->shutting_down);
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
   pollset->shutting_down = 1;
   if (grpc_pollset_work_run_loop) {
     // Drain any pending UV callbacks without blocking
@@ -103,7 +103,7 @@ void grpc_pollset_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
 }
 
 void grpc_pollset_destroy(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset) {
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
   uv_close((uv_handle_t *)&pollset->timer, timer_close_cb);
   // timer.data is a boolean indicating that the timer has finished closing
   pollset->timer.data = (void *)0;
@@ -118,7 +118,7 @@ grpc_error *grpc_pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
                               grpc_pollset_worker **worker_hdl,
                               gpr_timespec now, gpr_timespec deadline) {
   uint64_t timeout;
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
   gpr_mu_unlock(&grpc_polling_mu);
   if (grpc_pollset_work_run_loop) {
     if (gpr_time_cmp(deadline, now) >= 0) {
@@ -147,7 +147,7 @@ grpc_error *grpc_pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
 
 grpc_error *grpc_pollset_kick(grpc_pollset *pollset,
                               grpc_pollset_worker *specific_worker) {
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
   uv_timer_start(dummy_uv_handle, dummy_timer_cb, 0, 0);
   return GRPC_ERROR_NONE;
 }

src/core/lib/iomgr/resolve_address_uv.c

@@ -175,7 +175,7 @@ static grpc_error *blocking_resolve_address_impl(
   grpc_error *err;
   int retry_status;
 
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
 
   req.addrinfo = NULL;
 
@@ -231,7 +231,7 @@ static void resolve_address_impl(grpc_exec_ctx *exec_ctx, const char *name,
   char *port = NULL;
   grpc_error *err;
   int s;
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
   err = try_split_host_port(name, default_port, &host, &port);
   if (err != GRPC_ERROR_NONE) {
     GRPC_CLOSURE_SCHED(exec_ctx, on_done, err);

src/core/lib/iomgr/tcp_client_uv.c

@@ -125,7 +125,7 @@ static void tcp_client_connect_impl(grpc_exec_ctx *exec_ctx,
   (void)channel_args;
   (void)interested_parties;
 
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
 
   if (channel_args != NULL) {
     for (size_t i = 0; i < channel_args->num_args; i++) {

src/core/lib/iomgr/tcp_server_uv.c

@@ -108,7 +108,7 @@ grpc_error *grpc_tcp_server_create(grpc_exec_ctx *exec_ctx,
 }
 
 grpc_tcp_server *grpc_tcp_server_ref(grpc_tcp_server *s) {
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
   gpr_ref(&s->refs);
   return s;
 }
@@ -147,12 +147,10 @@ static void handle_close_callback(uv_handle_t *handle) {
 }
 
 static void close_listener(grpc_tcp_listener *sp) {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   if (!sp->closed) {
     sp->closed = true;
     uv_close((uv_handle_t *)sp->handle, handle_close_callback);
   }
-  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void tcp_server_destroy(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s) {
@@ -175,7 +173,7 @@ static void tcp_server_destroy(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s) {
 }
 
 void grpc_tcp_server_unref(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s) {
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
   if (gpr_unref(&s->refs)) {
     /* Complete shutdown_starting work before destroying. */
     grpc_exec_ctx local_exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -248,7 +246,9 @@ static void on_connect(uv_stream_t *server, int status) {
 
   GPR_ASSERT(!sp->has_pending_connection);
 
-  gpr_log(GPR_DEBUG, "SERVER_CONNECT: %p incoming connection", sp->server);
+  if (GRPC_TRACER_ON(grpc_tcp_trace)) {
+    gpr_log(GPR_DEBUG, "SERVER_CONNECT: %p incoming connection", sp->server);
+  }
 
   // Create acceptor.
   if (sp->server->on_accept_cb) {
@@ -338,7 +338,7 @@ grpc_error *grpc_tcp_server_add_port(grpc_tcp_server *s,
   int status;
   grpc_error *error = GRPC_ERROR_NONE;
 
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
 
   if (s->tail != NULL) {
     port_index = s->tail->port_index + 1;
@@ -420,7 +420,7 @@ void grpc_tcp_server_start(grpc_exec_ctx *exec_ctx, grpc_tcp_server *server,
   grpc_tcp_listener *sp;
   (void)pollsets;
   (void)pollset_count;
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
   if (GRPC_TRACER_ON(grpc_tcp_trace)) {
     gpr_log(GPR_DEBUG, "SERVER_START %p", server);
   }

src/core/lib/iomgr/tcp_uv.c

@@ -184,7 +184,7 @@ static void uv_endpoint_read(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
   grpc_tcp *tcp = (grpc_tcp *)ep;
   int status;
   grpc_error *error = GRPC_ERROR_NONE;
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
   GPR_ASSERT(tcp->read_cb == NULL);
   tcp->read_cb = cb;
   tcp->read_slices = read_slices;
@@ -238,7 +238,7 @@ static void uv_endpoint_write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
   unsigned int i;
   grpc_slice *slice;
   uv_write_t *write_req;
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
 
   if (GRPC_TRACER_ON(grpc_tcp_trace)) {
     size_t j;

src/core/lib/iomgr/timer_uv.c

@@ -44,7 +44,7 @@ static void stop_uv_timer(uv_timer_t *handle) {
 void run_expired_timer(uv_timer_t *handle) {
   grpc_timer *timer = (grpc_timer *)handle->data;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
   GPR_ASSERT(timer->pending);
   timer->pending = 0;
   GRPC_CLOSURE_SCHED(&exec_ctx, timer->closure, GRPC_ERROR_NONE);
@@ -57,7 +57,7 @@ void grpc_timer_init(grpc_exec_ctx *exec_ctx, grpc_timer *timer,
                      gpr_timespec now) {
   uint64_t timeout;
   uv_timer_t *uv_timer;
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
   timer->closure = closure;
   if (gpr_time_cmp(deadline, now) <= 0) {
     timer->pending = 0;
@@ -78,7 +78,7 @@ void grpc_timer_init(grpc_exec_ctx *exec_ctx, grpc_timer *timer,
 }
 
 void grpc_timer_cancel(grpc_exec_ctx *exec_ctx, grpc_timer *timer) {
-  GRPC_ASSERT_SAME_THREAD();
+  GRPC_UV_ASSERT_SAME_THREAD();
   if (timer->pending) {
     timer->pending = 0;
     GRPC_CLOSURE_SCHED(exec_ctx, timer->closure, GRPC_ERROR_CANCELLED);