grpc 1.7.3 → 1.8.0

data/src/ruby/ext/grpc/rb_call.h

@@ -24,24 +24,24 @@
 #include <grpc/grpc.h>
 
 /* Gets the wrapped call from a VALUE. */
-grpc_call *grpc_rb_get_wrapped_call(VALUE v);
+grpc_call* grpc_rb_get_wrapped_call(VALUE v);
 
 /* Gets the VALUE corresponding to given grpc_call. */
-VALUE grpc_rb_wrap_call(grpc_call *c, grpc_completion_queue *q);
+VALUE grpc_rb_wrap_call(grpc_call* c, grpc_completion_queue* q);
 
 /* Provides the details of an call error */
-const char *grpc_call_error_detail_of(grpc_call_error err);
+const char* grpc_call_error_detail_of(grpc_call_error err);
 
 /* Converts a metadata array to a hash. */
-VALUE grpc_rb_md_ary_to_h(grpc_metadata_array *md_ary);
+VALUE grpc_rb_md_ary_to_h(grpc_metadata_array* md_ary);
 
 /* grpc_rb_md_ary_convert converts a ruby metadata hash into
    a grpc_metadata_array.
 */
-void grpc_rb_md_ary_convert(VALUE md_ary_hash, grpc_metadata_array *md_ary);
+void grpc_rb_md_ary_convert(VALUE md_ary_hash, grpc_metadata_array* md_ary);
 
 void grpc_rb_metadata_array_destroy_including_entries(
-    grpc_metadata_array *md_ary);
+    grpc_metadata_array* md_ary);
 
 /* grpc_rb_eCallError is the ruby class of the exception thrown during call
    operations. */

data/src/ruby/ext/grpc/rb_call_credentials.c

@@ -44,13 +44,13 @@ typedef struct grpc_rb_call_credentials {
   VALUE mark;
 
   /* The actual credentials */
-  grpc_call_credentials *wrapped;
+  grpc_call_credentials* wrapped;
 } grpc_rb_call_credentials;
 
 typedef struct callback_params {
   VALUE get_metadata;
   grpc_auth_metadata_context context;
-  void *user_data;
+  void* user_data;
   grpc_credentials_plugin_metadata_cb callback;
 } callback_params;
 
@@ -82,8 +82,8 @@ static VALUE grpc_rb_call_credentials_callback_rescue(VALUE args,
   return result;
 }
 
-static void grpc_rb_call_credentials_callback_with_gil(void *param) {
-  callback_params *const params = (callback_params *)param;
+static void grpc_rb_call_credentials_callback_with_gil(void* param) {
+  callback_params* const params = (callback_params*)param;
   VALUE auth_uri = rb_str_new_cstr(params->context.service_url);
   /* Pass the arguments to the proc in a hash, which currently only has they key
      'auth_uri' */
@@ -93,7 +93,7 @@ static void grpc_rb_call_credentials_callback_with_gil(void *param) {
   grpc_metadata_array md_ary;
   grpc_status_code status;
   VALUE details;
-  char *error_details;
+  char* error_details;
   grpc_metadata_array_init(&md_ary);
   rb_hash_aset(args, ID2SYM(rb_intern("jwt_aud_uri")), auth_uri);
   rb_ary_push(callback_args, params->get_metadata);
@@ -113,34 +113,34 @@ static void grpc_rb_call_credentials_callback_with_gil(void *param) {
 }
 
 static int grpc_rb_call_credentials_plugin_get_metadata(
-    void *state, grpc_auth_metadata_context context,
-    grpc_credentials_plugin_metadata_cb cb, void *user_data,
+    void* state, grpc_auth_metadata_context context,
+    grpc_credentials_plugin_metadata_cb cb, void* user_data,
     grpc_metadata creds_md[GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX],
-    size_t *num_creds_md, grpc_status_code *status,
-    const char **error_details) {
-  callback_params *params = gpr_malloc(sizeof(callback_params));
+    size_t* num_creds_md, grpc_status_code* status,
+    const char** error_details) {
+  callback_params* params = gpr_malloc(sizeof(callback_params));
   params->get_metadata = (VALUE)state;
   params->context = context;
   params->user_data = user_data;
   params->callback = cb;
 
   grpc_rb_event_queue_enqueue(grpc_rb_call_credentials_callback_with_gil,
-                              (void *)(params));
+                              (void*)(params));
   return 0;  // Async return.
 }
 
-static void grpc_rb_call_credentials_plugin_destroy(void *state) {
+static void grpc_rb_call_credentials_plugin_destroy(void* state) {
   (void)state;
   // Not sure what needs to be done here
 }
 
 /* Destroys the credentials instances. */
-static void grpc_rb_call_credentials_free(void *p) {
-  grpc_rb_call_credentials *wrapper;
+static void grpc_rb_call_credentials_free(void* p) {
+  grpc_rb_call_credentials* wrapper;
   if (p == NULL) {
     return;
   }
-  wrapper = (grpc_rb_call_credentials *)p;
+  wrapper = (grpc_rb_call_credentials*)p;
   grpc_call_credentials_release(wrapper->wrapped);
   wrapper->wrapped = NULL;
 
@@ -148,12 +148,12 @@ static void grpc_rb_call_credentials_free(void *p) {
 }
 
 /* Protects the mark object from GC */
-static void grpc_rb_call_credentials_mark(void *p) {
-  grpc_rb_call_credentials *wrapper = NULL;
+static void grpc_rb_call_credentials_mark(void* p) {
+  grpc_rb_call_credentials* wrapper = NULL;
   if (p == NULL) {
     return;
   }
-  wrapper = (grpc_rb_call_credentials *)p;
+  wrapper = (grpc_rb_call_credentials*)p;
   if (wrapper->mark != Qnil) {
     rb_gc_mark(wrapper->mark);
   }
@@ -175,7 +175,7 @@ static rb_data_type_t grpc_rb_call_credentials_data_type = {
 /* Allocates CallCredentials instances.
    Provides safe initial defaults for the instance fields. */
 static VALUE grpc_rb_call_credentials_alloc(VALUE cls) {
-  grpc_rb_call_credentials *wrapper = ALLOC(grpc_rb_call_credentials);
+  grpc_rb_call_credentials* wrapper = ALLOC(grpc_rb_call_credentials);
   wrapper->wrapped = NULL;
   wrapper->mark = Qnil;
   return TypedData_Wrap_Struct(cls, &grpc_rb_call_credentials_data_type,
@@ -185,9 +185,9 @@ static VALUE grpc_rb_call_credentials_alloc(VALUE cls) {
 /* Creates a wrapping object for a given call credentials. This should only be
  * called with grpc_call_credentials objects that are not already associated
  * with any Ruby object */
-VALUE grpc_rb_wrap_call_credentials(grpc_call_credentials *c, VALUE mark) {
+VALUE grpc_rb_wrap_call_credentials(grpc_call_credentials* c, VALUE mark) {
   VALUE rb_wrapper;
-  grpc_rb_call_credentials *wrapper;
+  grpc_rb_call_credentials* wrapper;
   if (c == NULL) {
     return Qnil;
   }
@@ -208,8 +208,8 @@ static ID id_callback;
   proc: (required) Proc that generates auth metadata
   Initializes CallCredential instances. */
 static VALUE grpc_rb_call_credentials_init(VALUE self, VALUE proc) {
-  grpc_rb_call_credentials *wrapper = NULL;
-  grpc_call_credentials *creds = NULL;
+  grpc_rb_call_credentials* wrapper = NULL;
+  grpc_call_credentials* creds = NULL;
   grpc_metadata_credentials_plugin plugin;
 
   grpc_ruby_once_init();
@@ -223,7 +223,7 @@ static VALUE grpc_rb_call_credentials_init(VALUE self, VALUE proc) {
     rb_raise(rb_eTypeError, "Argument to CallCredentials#new must be a proc");
     return Qnil;
   }
-  plugin.state = (void *)proc;
+  plugin.state = (void*)proc;
   plugin.type = "";
 
   creds = grpc_metadata_credentials_create_from_plugin(plugin, NULL);
@@ -239,11 +239,11 @@ static VALUE grpc_rb_call_credentials_init(VALUE self, VALUE proc) {
   return self;
 }
 
-static VALUE grpc_rb_call_credentials_compose(int argc, VALUE *argv,
+static VALUE grpc_rb_call_credentials_compose(int argc, VALUE* argv,
                                               VALUE self) {
-  grpc_call_credentials *creds;
-  grpc_call_credentials *other;
-  grpc_call_credentials *prev = NULL;
+  grpc_call_credentials* creds;
+  grpc_call_credentials* other;
+  grpc_call_credentials* prev = NULL;
   VALUE mark;
   if (argc == 0) {
     return self;
@@ -282,8 +282,8 @@ void Init_grpc_call_credentials() {
 }
 
 /* Gets the wrapped grpc_call_credentials from the ruby wrapper */
-grpc_call_credentials *grpc_rb_get_wrapped_call_credentials(VALUE v) {
-  grpc_rb_call_credentials *wrapper = NULL;
+grpc_call_credentials* grpc_rb_get_wrapped_call_credentials(VALUE v) {
+  grpc_rb_call_credentials* wrapper = NULL;
   TypedData_Get_Struct(v, grpc_rb_call_credentials,
                        &grpc_rb_call_credentials_data_type, wrapper);
   return wrapper->wrapped;

data/src/ruby/ext/grpc/rb_channel.c

@@ -54,9 +54,9 @@ static VALUE grpc_rb_cChannel = Qnil;
 static VALUE grpc_rb_cChannelArgs;
 
 typedef struct bg_watched_channel {
-  grpc_channel *channel;
+  grpc_channel* channel;
   // these fields must only be accessed under global_connection_polling_mu
-  struct bg_watched_channel *next;
+  struct bg_watched_channel* next;
   int channel_destroyed;
   int refcount;
 } bg_watched_channel;
@@ -67,7 +67,7 @@ typedef struct grpc_rb_channel {
 
   /* The actual channel (protected in a wrapper to tell when it's safe to
    * destroy) */
-  bg_watched_channel *bg_wrapped;
+  bg_watched_channel* bg_wrapped;
 } grpc_rb_channel;
 
 typedef enum { CONTINUOUS_WATCH, WATCH_STATE_API } watch_state_op_type;
@@ -82,40 +82,40 @@ typedef struct watch_state_op {
       int called_back;
     } api_callback_args;
     struct {
-      bg_watched_channel *bg;
+      bg_watched_channel* bg;
     } continuous_watch_callback_args;
   } op;
 } watch_state_op;
 
-static bg_watched_channel *bg_watched_channel_list_head = NULL;
+static bg_watched_channel* bg_watched_channel_list_head = NULL;
 
 static void grpc_rb_channel_try_register_connection_polling(
-    bg_watched_channel *bg);
-static void *wait_until_channel_polling_thread_started_no_gil(void *);
-static void wait_until_channel_polling_thread_started_unblocking_func(void *);
-static void *channel_init_try_register_connection_polling_without_gil(
-    void *arg);
+    bg_watched_channel* bg);
+static void* wait_until_channel_polling_thread_started_no_gil(void*);
+static void wait_until_channel_polling_thread_started_unblocking_func(void*);
+static void* channel_init_try_register_connection_polling_without_gil(
+    void* arg);
 
 typedef struct channel_init_try_register_stack {
-  grpc_channel *channel;
-  grpc_rb_channel *wrapper;
+  grpc_channel* channel;
+  grpc_rb_channel* wrapper;
 } channel_init_try_register_stack;
 
-static grpc_completion_queue *channel_polling_cq;
+static grpc_completion_queue* channel_polling_cq;
 static gpr_mu global_connection_polling_mu;
 static gpr_cv global_connection_polling_cv;
 static int abort_channel_polling = 0;
 static int channel_polling_thread_started = 0;
 
-static int bg_watched_channel_list_lookup(bg_watched_channel *bg);
-static bg_watched_channel *bg_watched_channel_list_create_and_add(
-    grpc_channel *channel);
-static void bg_watched_channel_list_free_and_remove(bg_watched_channel *bg);
-static void run_poll_channels_loop_unblocking_func(void *arg);
+static int bg_watched_channel_list_lookup(bg_watched_channel* bg);
+static bg_watched_channel* bg_watched_channel_list_create_and_add(
+    grpc_channel* channel);
+static void bg_watched_channel_list_free_and_remove(bg_watched_channel* bg);
+static void run_poll_channels_loop_unblocking_func(void* arg);
 
 // Needs to be called under global_connection_polling_mu
 static void grpc_rb_channel_watch_connection_state_op_complete(
-    watch_state_op *op, int success) {
+    watch_state_op* op, int success) {
   GPR_ASSERT(!op->op.api_callback_args.called_back);
   op->op.api_callback_args.called_back = 1;
   op->op.api_callback_args.success = success;
@@ -124,7 +124,7 @@ static void grpc_rb_channel_watch_connection_state_op_complete(
 }
 
 /* Avoids destroying a channel twice. */
-static void grpc_rb_channel_safe_destroy(bg_watched_channel *bg) {
+static void grpc_rb_channel_safe_destroy(bg_watched_channel* bg) {
   gpr_mu_lock(&global_connection_polling_mu);
   GPR_ASSERT(bg_watched_channel_list_lookup(bg));
   if (!bg->channel_destroyed) {
@@ -138,18 +138,18 @@ static void grpc_rb_channel_safe_destroy(bg_watched_channel *bg) {
   gpr_mu_unlock(&global_connection_polling_mu);
 }
 
-static void *channel_safe_destroy_without_gil(void *arg) {
-  grpc_rb_channel_safe_destroy((bg_watched_channel *)arg);
+static void* channel_safe_destroy_without_gil(void* arg) {
+  grpc_rb_channel_safe_destroy((bg_watched_channel*)arg);
   return NULL;
 }
 
 /* Destroys Channel instances. */
-static void grpc_rb_channel_free(void *p) {
-  grpc_rb_channel *ch = NULL;
+static void grpc_rb_channel_free(void* p) {
+  grpc_rb_channel* ch = NULL;
   if (p == NULL) {
     return;
   };
-  ch = (grpc_rb_channel *)p;
+  ch = (grpc_rb_channel*)p;
 
   if (ch->bg_wrapped != NULL) {
     /* assumption made here: it's ok to directly gpr_mu_lock the global
@@ -164,12 +164,12 @@ static void grpc_rb_channel_free(void *p) {
 }
 
 /* Protects the mark object from GC */
-static void grpc_rb_channel_mark(void *p) {
-  grpc_rb_channel *channel = NULL;
+static void grpc_rb_channel_mark(void* p) {
+  grpc_rb_channel* channel = NULL;
   if (p == NULL) {
     return;
   }
-  channel = (grpc_rb_channel *)p;
+  channel = (grpc_rb_channel*)p;
   if (channel->credentials != Qnil) {
     rb_gc_mark(channel->credentials);
   }
@@ -189,7 +189,7 @@ static rb_data_type_t grpc_channel_data_type = {"grpc_channel",
 
 /* Allocates grpc_rb_channel instances. */
 static VALUE grpc_rb_channel_alloc(VALUE cls) {
-  grpc_rb_channel *wrapper = ALLOC(grpc_rb_channel);
+  grpc_rb_channel* wrapper = ALLOC(grpc_rb_channel);
   wrapper->bg_wrapped = NULL;
   wrapper->credentials = Qnil;
   return TypedData_Wrap_Struct(cls, &grpc_channel_data_type, wrapper);
@@ -203,14 +203,14 @@ static VALUE grpc_rb_channel_alloc(VALUE cls) {
     secure_channel = Channel:new("myhost:443", {'arg1': 'value1'}, creds)
 
   Creates channel instances. */
-static VALUE grpc_rb_channel_init(int argc, VALUE *argv, VALUE self) {
+static VALUE grpc_rb_channel_init(int argc, VALUE* argv, VALUE self) {
   VALUE channel_args = Qnil;
   VALUE credentials = Qnil;
   VALUE target = Qnil;
-  grpc_rb_channel *wrapper = NULL;
-  grpc_channel *ch = NULL;
-  grpc_channel_credentials *creds = NULL;
-  char *target_chars = NULL;
+  grpc_rb_channel* wrapper = NULL;
+  grpc_channel* ch = NULL;
+  grpc_channel_credentials* creds = NULL;
+  char* target_chars = NULL;
   grpc_channel_args args;
   channel_init_try_register_stack stack;
   int stop_waiting_for_thread_start = 0;
@@ -262,13 +262,13 @@ static VALUE grpc_rb_channel_init(int argc, VALUE *argv, VALUE self) {
 }
 
 typedef struct get_state_stack {
-  bg_watched_channel *bg;
+  bg_watched_channel* bg;
   int try_to_connect;
   int out;
 } get_state_stack;
 
-static void *get_state_without_gil(void *arg) {
-  get_state_stack *stack = (get_state_stack *)arg;
+static void* get_state_without_gil(void* arg) {
+  get_state_stack* stack = (get_state_stack*)arg;
 
   gpr_mu_lock(&global_connection_polling_mu);
   GPR_ASSERT(abort_channel_polling || channel_polling_thread_started);
@@ -292,10 +292,10 @@ static void *get_state_without_gil(void *arg) {
   constants defined in GRPC::Core::ConnectivityStates.
 
   It also tries to connect if the chennel is idle in the second form. */
-static VALUE grpc_rb_channel_get_connectivity_state(int argc, VALUE *argv,
+static VALUE grpc_rb_channel_get_connectivity_state(int argc, VALUE* argv,
                                                     VALUE self) {
   VALUE try_to_connect_param = Qfalse;
-  grpc_rb_channel *wrapper = NULL;
+  grpc_rb_channel* wrapper = NULL;
   get_state_stack stack;
 
   /* "01" == 0 mandatory args, 1 (try_to_connect) is optional */
@@ -315,22 +315,22 @@ static VALUE grpc_rb_channel_get_connectivity_state(int argc, VALUE *argv,
 }
 
 typedef struct watch_state_stack {
-  grpc_channel *channel;
+  grpc_channel* channel;
   gpr_timespec deadline;
   int last_state;
 } watch_state_stack;
 
-static void *wait_for_watch_state_op_complete_without_gvl(void *arg) {
-  watch_state_stack *stack = (watch_state_stack *)arg;
-  watch_state_op *op = NULL;
-  void *success = (void *)0;
+static void* wait_for_watch_state_op_complete_without_gvl(void* arg) {
+  watch_state_stack* stack = (watch_state_stack*)arg;
+  watch_state_op* op = NULL;
+  void* success = (void*)0;
 
   gpr_mu_lock(&global_connection_polling_mu);
   // its unsafe to do a "watch" after "channel polling abort" because the cq has
   // been shut down.
   if (abort_channel_polling) {
     gpr_mu_unlock(&global_connection_polling_mu);
-    return (void *)0;
+    return (void*)0;
   }
   op = gpr_zalloc(sizeof(watch_state_op));
   op->op_type = WATCH_STATE_API;
@@ -343,15 +343,15 @@ static void *wait_for_watch_state_op_complete_without_gvl(void *arg) {
                 gpr_inf_future(GPR_CLOCK_REALTIME));
   }
   if (op->op.api_callback_args.success) {
-    success = (void *)1;
+    success = (void*)1;
   }
   gpr_free(op);
   gpr_mu_unlock(&global_connection_polling_mu);
 
   return success;
 }
-static void wait_for_watch_state_op_complete_unblocking_func(void *arg) {
-  bg_watched_channel *bg = (bg_watched_channel *)arg;
+static void wait_for_watch_state_op_complete_unblocking_func(void* arg) {
+  bg_watched_channel* bg = (bg_watched_channel*)arg;
   gpr_mu_lock(&global_connection_polling_mu);
   if (!bg->channel_destroyed) {
     grpc_channel_destroy(bg->channel);
@@ -370,9 +370,9 @@ static void wait_for_watch_state_op_complete_unblocking_func(void *arg) {
 static VALUE grpc_rb_channel_watch_connectivity_state(VALUE self,
                                                       VALUE last_state,
                                                       VALUE deadline) {
-  grpc_rb_channel *wrapper = NULL;
+  grpc_rb_channel* wrapper = NULL;
   watch_state_stack stack;
-  void *op_success = 0;
+  void* op_success = 0;
 
   TypedData_Get_Struct(self, grpc_rb_channel, &grpc_channel_data_type, wrapper);
 
@@ -405,15 +405,15 @@ static VALUE grpc_rb_channel_create_call(VALUE self, VALUE parent, VALUE mask,
                                          VALUE method, VALUE host,
                                          VALUE deadline) {
   VALUE res = Qnil;
-  grpc_rb_channel *wrapper = NULL;
-  grpc_call *call = NULL;
-  grpc_call *parent_call = NULL;
-  grpc_completion_queue *cq = NULL;
+  grpc_rb_channel* wrapper = NULL;
+  grpc_call* call = NULL;
+  grpc_call* parent_call = NULL;
+  grpc_completion_queue* cq = NULL;
   int flags = GRPC_PROPAGATE_DEFAULTS;
   grpc_slice method_slice;
   grpc_slice host_slice;
-  grpc_slice *host_slice_ptr = NULL;
-  char *tmp_str = NULL;
+  grpc_slice* host_slice_ptr = NULL;
+  char* tmp_str = NULL;
 
   if (host != Qnil) {
     host_slice =
@@ -466,7 +466,7 @@ static VALUE grpc_rb_channel_create_call(VALUE self, VALUE parent, VALUE mask,
 /* Note this is an API-level call; a wrapped channel's finalizer doesn't call
  * this */
 static VALUE grpc_rb_channel_destroy(VALUE self) {
-  grpc_rb_channel *wrapper = NULL;
+  grpc_rb_channel* wrapper = NULL;
 
   TypedData_Get_Struct(self, grpc_rb_channel, &grpc_channel_data_type, wrapper);
   if (wrapper->bg_wrapped != NULL) {
@@ -480,9 +480,9 @@ static VALUE grpc_rb_channel_destroy(VALUE self) {
 
 /* Called to obtain the target that this channel accesses. */
 static VALUE grpc_rb_channel_get_target(VALUE self) {
-  grpc_rb_channel *wrapper = NULL;
+  grpc_rb_channel* wrapper = NULL;
   VALUE res = Qnil;
-  char *target = NULL;
+  char* target = NULL;
 
   TypedData_Get_Struct(self, grpc_rb_channel, &grpc_channel_data_type, wrapper);
   target = grpc_channel_get_target(wrapper->bg_wrapped->channel);
@@ -493,8 +493,8 @@ static VALUE grpc_rb_channel_get_target(VALUE self) {
 }
 
 /* Needs to be called under global_connection_polling_mu */
-static int bg_watched_channel_list_lookup(bg_watched_channel *target) {
-  bg_watched_channel *cur = bg_watched_channel_list_head;
+static int bg_watched_channel_list_lookup(bg_watched_channel* target) {
+  bg_watched_channel* cur = bg_watched_channel_list_head;
 
   while (cur != NULL) {
     if (cur == target) {
@@ -507,9 +507,9 @@ static int bg_watched_channel_list_lookup(bg_watched_channel *target) {
 }
 
 /* Needs to be called under global_connection_polling_mu */
-static bg_watched_channel *bg_watched_channel_list_create_and_add(
-    grpc_channel *channel) {
-  bg_watched_channel *watched = gpr_zalloc(sizeof(bg_watched_channel));
+static bg_watched_channel* bg_watched_channel_list_create_and_add(
+    grpc_channel* channel) {
+  bg_watched_channel* watched = gpr_zalloc(sizeof(bg_watched_channel));
 
   watched->channel = channel;
   watched->next = bg_watched_channel_list_head;
@@ -520,8 +520,8 @@ static bg_watched_channel *bg_watched_channel_list_create_and_add(
 
 /* Needs to be called under global_connection_polling_mu */
 static void bg_watched_channel_list_free_and_remove(
-    bg_watched_channel *target) {
-  bg_watched_channel *bg = NULL;
+    bg_watched_channel* target) {
+  bg_watched_channel* bg = NULL;
 
   GPR_ASSERT(bg_watched_channel_list_lookup(target));
   GPR_ASSERT(target->channel_destroyed && target->refcount == 0);
@@ -544,10 +544,10 @@ static void bg_watched_channel_list_free_and_remove(
 
 /* Initialize a grpc_rb_channel's "protected grpc_channel" and try to push
  * it onto the background thread for constant watches. */
-static void *channel_init_try_register_connection_polling_without_gil(
-    void *arg) {
-  channel_init_try_register_stack *stack =
-      (channel_init_try_register_stack *)arg;
+static void* channel_init_try_register_connection_polling_without_gil(
+    void* arg) {
+  channel_init_try_register_stack* stack =
+      (channel_init_try_register_stack*)arg;
 
   gpr_mu_lock(&global_connection_polling_mu);
   stack->wrapper->bg_wrapped =
@@ -559,9 +559,9 @@ static void *channel_init_try_register_connection_polling_without_gil(
 
 // Needs to be called under global_connection_poolling_mu
 static void grpc_rb_channel_try_register_connection_polling(
-    bg_watched_channel *bg) {
+    bg_watched_channel* bg) {
   grpc_connectivity_state conn_state;
-  watch_state_op *op = NULL;
+  watch_state_op* op = NULL;
 
   GPR_ASSERT(channel_polling_thread_started || abort_channel_polling);
 
@@ -597,10 +597,10 @@ static void grpc_rb_channel_try_register_connection_polling(
 // indicates process shutdown.
 // In the worst case, this stops polling channel connectivity
 // early and falls back to current behavior.
-static void *run_poll_channels_loop_no_gil(void *arg) {
+static void* run_poll_channels_loop_no_gil(void* arg) {
   grpc_event event;
-  watch_state_op *op = NULL;
-  bg_watched_channel *bg = NULL;
+  watch_state_op* op = NULL;
+  bg_watched_channel* bg = NULL;
   (void)arg;
   gpr_log(GPR_DEBUG, "GRPC_RUBY: run_poll_channels_loop_no_gil - begin");
 
@@ -618,15 +618,15 @@ static void *run_poll_channels_loop_no_gil(void *arg) {
     }
     gpr_mu_lock(&global_connection_polling_mu);
     if (event.type == GRPC_OP_COMPLETE) {
-      op = (watch_state_op *)event.tag;
+      op = (watch_state_op*)event.tag;
       if (op->op_type == CONTINUOUS_WATCH) {
-        bg = (bg_watched_channel *)op->op.continuous_watch_callback_args.bg;
+        bg = (bg_watched_channel*)op->op.continuous_watch_callback_args.bg;
         bg->refcount--;
         grpc_rb_channel_try_register_connection_polling(bg);
         gpr_free(op);
       } else if (op->op_type == WATCH_STATE_API) {
         grpc_rb_channel_watch_connection_state_op_complete(
-            (watch_state_op *)event.tag, event.success);
+            (watch_state_op*)event.tag, event.success);
       } else {
         GPR_ASSERT(0);
       }
@@ -641,8 +641,8 @@ static void *run_poll_channels_loop_no_gil(void *arg) {
 }
 
 // Notify the channel polling loop to cleanup and shutdown.
-static void run_poll_channels_loop_unblocking_func(void *arg) {
-  bg_watched_channel *bg = NULL;
+static void run_poll_channels_loop_unblocking_func(void* arg) {
+  bg_watched_channel* bg = NULL;
   (void)arg;
 
   gpr_mu_lock(&global_connection_polling_mu);
@@ -686,8 +686,8 @@ static VALUE run_poll_channels_loop(VALUE arg) {
   return Qnil;
 }
 
-static void *wait_until_channel_polling_thread_started_no_gil(void *arg) {
-  int *stop_waiting = (int *)arg;
+static void* wait_until_channel_polling_thread_started_no_gil(void* arg) {
+  int* stop_waiting = (int*)arg;
   gpr_log(GPR_DEBUG, "GRPC_RUBY: wait for channel polling thread to start");
   gpr_mu_lock(&global_connection_polling_mu);
   while (!channel_polling_thread_started && !abort_channel_polling &&
@@ -701,8 +701,8 @@ static void *wait_until_channel_polling_thread_started_no_gil(void *arg) {
 }
 
 static void wait_until_channel_polling_thread_started_unblocking_func(
-    void *arg) {
-  int *stop_waiting = (int *)arg;
+    void* arg) {
+  int* stop_waiting = (int*)arg;
   gpr_mu_lock(&global_connection_polling_mu);
   gpr_log(GPR_DEBUG,
           "GRPC_RUBY: interrupt wait for channel polling thread to start");
@@ -711,7 +711,7 @@ static void wait_until_channel_polling_thread_started_unblocking_func(
   gpr_mu_unlock(&global_connection_polling_mu);
 }
 
-static void *set_abort_channel_polling_without_gil(void *arg) {
+static void* set_abort_channel_polling_without_gil(void* arg) {
   (void)arg;
   gpr_mu_lock(&global_connection_polling_mu);
   abort_channel_polling = 1;
@@ -822,8 +822,8 @@ void Init_grpc_channel() {
 }
 
 /* Gets the wrapped channel from the ruby wrapper */
-grpc_channel *grpc_rb_get_wrapped_channel(VALUE v) {
-  grpc_rb_channel *wrapper = NULL;
+grpc_channel* grpc_rb_get_wrapped_channel(VALUE v) {
+  grpc_rb_channel* wrapper = NULL;
   TypedData_Get_Struct(v, grpc_rb_channel, &grpc_channel_data_type, wrapper);
   return wrapper->bg_wrapped->channel;
 }