grpc 1.7.3 → 1.8.0

data/src/core/ext/transport/inproc/inproc_transport.h

@@ -25,11 +25,11 @@
 extern "C" {
 #endif
 
-grpc_channel *grpc_inproc_channel_create(grpc_server *server,
-                                         grpc_channel_args *args,
-                                         void *reserved);
+grpc_channel* grpc_inproc_channel_create(grpc_server* server,
+                                         grpc_channel_args* args,
+                                         void* reserved);
 
-extern grpc_tracer_flag grpc_inproc_trace;
+extern grpc_core::TraceFlag grpc_inproc_trace;
 
 void grpc_inproc_transport_init(void);
 void grpc_inproc_transport_shutdown(void);

data/src/core/lib/backoff/backoff.cc

@@ -0,0 +1,80 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/core/lib/backoff/backoff.h"
+
+#include <grpc/support/useful.h>
+
+void grpc_backoff_init(grpc_backoff* backoff, grpc_millis initial_backoff,
+                       double multiplier, double jitter,
+                       grpc_millis min_connect_timeout,
+                       grpc_millis max_backoff) {
+  backoff->initial_backoff = initial_backoff;
+  backoff->multiplier = multiplier;
+  backoff->jitter = jitter;
+  backoff->min_connect_timeout = min_connect_timeout;
+  backoff->max_backoff = max_backoff;
+  backoff->rng_state = (uint32_t)gpr_now(GPR_CLOCK_REALTIME).tv_nsec;
+}
+
+grpc_backoff_result grpc_backoff_begin(grpc_exec_ctx* exec_ctx,
+                                       grpc_backoff* backoff) {
+  backoff->current_backoff = backoff->initial_backoff;
+  const grpc_millis initial_timeout =
+      GPR_MAX(backoff->initial_backoff, backoff->min_connect_timeout);
+  const grpc_millis now = grpc_exec_ctx_now(exec_ctx);
+  const grpc_backoff_result result = {now + initial_timeout,
+                                      now + backoff->current_backoff};
+  return result;
+}
+
+/* Generate a random number between 0 and 1. */
+static double generate_uniform_random_number(uint32_t* rng_state) {
+  *rng_state = (1103515245 * *rng_state + 12345) % ((uint32_t)1 << 31);
+  return *rng_state / (double)((uint32_t)1 << 31);
+}
+
+static double generate_uniform_random_number_between(uint32_t* rng_state,
+                                                     double a, double b) {
+  if (a == b) return a;
+  if (a > b) GPR_SWAP(double, a, b);  // make sure a < b
+  const double range = b - a;
+  return a + generate_uniform_random_number(rng_state) * range;
+}
+
+grpc_backoff_result grpc_backoff_step(grpc_exec_ctx* exec_ctx,
+                                      grpc_backoff* backoff) {
+  backoff->current_backoff = (grpc_millis)(GPR_MIN(
+      backoff->current_backoff * backoff->multiplier, backoff->max_backoff));
+  const double jitter = generate_uniform_random_number_between(
+      &backoff->rng_state, -backoff->jitter * backoff->current_backoff,
+      backoff->jitter * backoff->current_backoff);
+  const grpc_millis current_timeout =
+      GPR_MAX((grpc_millis)(backoff->current_backoff + jitter),
+              backoff->min_connect_timeout);
+  const grpc_millis next_timeout = GPR_MIN(
+      (grpc_millis)(backoff->current_backoff + jitter), backoff->max_backoff);
+  const grpc_millis now = grpc_exec_ctx_now(exec_ctx);
+  const grpc_backoff_result result = {now + current_timeout,
+                                      now + next_timeout};
+  return result;
+}
+
+void grpc_backoff_reset(grpc_backoff* backoff) {
+  backoff->current_backoff = backoff->initial_backoff;
+}

data/src/core/lib/backoff/backoff.h

@@ -0,0 +1,83 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef GRPC_CORE_LIB_BACKOFF_BACKOFF_H
+#define GRPC_CORE_LIB_BACKOFF_BACKOFF_H
+
+#include "src/core/lib/iomgr/exec_ctx.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  /// const:  how long to wait after the first failure before retrying
+  grpc_millis initial_backoff;
+
+  /// const: factor with which to multiply backoff after a failed retry
+  double multiplier;
+
+  /// const: amount to randomize backoffs
+  double jitter;
+
+  /// const: minimum time between retries
+  grpc_millis min_connect_timeout;
+
+  /// const: maximum time between retries
+  grpc_millis max_backoff;
+
+  /// current delay before retries
+  grpc_millis current_backoff;
+
+  /// random number generator
+  uint32_t rng_state;
+} grpc_backoff;
+
+typedef struct {
+  /// Deadline to be used for the current attempt.
+  grpc_millis current_deadline;
+
+  /// Deadline to be used for the next attempt, following the backoff strategy.
+  grpc_millis next_attempt_start_time;
+} grpc_backoff_result;
+
+/// Initialize backoff machinery - does not need to be destroyed
+void grpc_backoff_init(grpc_backoff* backoff, grpc_millis initial_backoff,
+                       double multiplier, double jitter,
+                       grpc_millis min_connect_timeout,
+                       grpc_millis max_backoff);
+
+/// Begin retry loop: returns the deadlines to be used for the current attempt
+/// and the subsequent retry, if any.
+grpc_backoff_result grpc_backoff_begin(grpc_exec_ctx* exec_ctx,
+                                       grpc_backoff* backoff);
+
+/// Step a retry loop: returns the deadlines to be used for the current attempt
+/// and the subsequent retry, if any.
+grpc_backoff_result grpc_backoff_step(grpc_exec_ctx* exec_ctx,
+                                      grpc_backoff* backoff);
+
+/// Reset the backoff, so the next grpc_backoff_step will be a
+/// grpc_backoff_begin.
+void grpc_backoff_reset(grpc_backoff* backoff);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_CORE_LIB_BACKOFF_BACKOFF_H */

data/src/core/lib/channel/{channel_args.c → channel_args.cc}

@@ -31,7 +31,7 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/support/string.h"
 
-static grpc_arg copy_arg(const grpc_arg *src) {
+static grpc_arg copy_arg(const grpc_arg* src) {
   grpc_arg dst;
   dst.type = src->type;
   dst.key = gpr_strdup(src->key);
@@ -51,21 +51,21 @@ static grpc_arg copy_arg(const grpc_arg *src) {
   return dst;
 }
 
-grpc_channel_args *grpc_channel_args_copy_and_add(const grpc_channel_args *src,
-                                                  const grpc_arg *to_add,
+grpc_channel_args* grpc_channel_args_copy_and_add(const grpc_channel_args* src,
+                                                  const grpc_arg* to_add,
                                                   size_t num_to_add) {
-  return grpc_channel_args_copy_and_add_and_remove(src, NULL, 0, to_add,
+  return grpc_channel_args_copy_and_add_and_remove(src, nullptr, 0, to_add,
                                                    num_to_add);
 }
 
-grpc_channel_args *grpc_channel_args_copy_and_remove(
-    const grpc_channel_args *src, const char **to_remove,
+grpc_channel_args* grpc_channel_args_copy_and_remove(
+    const grpc_channel_args* src, const char** to_remove,
     size_t num_to_remove) {
   return grpc_channel_args_copy_and_add_and_remove(src, to_remove,
-                                                   num_to_remove, NULL, 0);
+                                                   num_to_remove, nullptr, 0);
 }
 
-static bool should_remove_arg(const grpc_arg *arg, const char **to_remove,
+static bool should_remove_arg(const grpc_arg* arg, const char** to_remove,
                               size_t num_to_remove) {
   for (size_t i = 0; i < num_to_remove; ++i) {
     if (strcmp(arg->key, to_remove[i]) == 0) return true;
@@ -73,12 +73,12 @@ static bool should_remove_arg(const grpc_arg *arg, const char **to_remove,
   return false;
 }
 
-grpc_channel_args *grpc_channel_args_copy_and_add_and_remove(
-    const grpc_channel_args *src, const char **to_remove, size_t num_to_remove,
-    const grpc_arg *to_add, size_t num_to_add) {
+grpc_channel_args* grpc_channel_args_copy_and_add_and_remove(
+    const grpc_channel_args* src, const char** to_remove, size_t num_to_remove,
+    const grpc_arg* to_add, size_t num_to_add) {
   // Figure out how many args we'll be copying.
   size_t num_args_to_copy = 0;
-  if (src != NULL) {
+  if (src != nullptr) {
     for (size_t i = 0; i < src->num_args; ++i) {
       if (!should_remove_arg(&src->args[i], to_remove, num_to_remove)) {
         ++num_args_to_copy;
@@ -86,17 +86,17 @@ grpc_channel_args *grpc_channel_args_copy_and_add_and_remove(
     }
   }
   // Create result.
-  grpc_channel_args *dst =
-      (grpc_channel_args *)gpr_malloc(sizeof(grpc_channel_args));
+  grpc_channel_args* dst =
+      (grpc_channel_args*)gpr_malloc(sizeof(grpc_channel_args));
   dst->num_args = num_args_to_copy + num_to_add;
   if (dst->num_args == 0) {
-    dst->args = NULL;
+    dst->args = nullptr;
     return dst;
   }
-  dst->args = (grpc_arg *)gpr_malloc(sizeof(grpc_arg) * dst->num_args);
+  dst->args = (grpc_arg*)gpr_malloc(sizeof(grpc_arg) * dst->num_args);
   // Copy args from src that are not being removed.
   size_t dst_idx = 0;
-  if (src != NULL) {
+  if (src != nullptr) {
     for (size_t i = 0; i < src->num_args; ++i) {
       if (!should_remove_arg(&src->args[i], to_remove, num_to_remove)) {
         dst->args[dst_idx++] = copy_arg(&src->args[i]);
@@ -111,30 +111,30 @@ grpc_channel_args *grpc_channel_args_copy_and_add_and_remove(
   return dst;
 }
 
-grpc_channel_args *grpc_channel_args_copy(const grpc_channel_args *src) {
-  return grpc_channel_args_copy_and_add(src, NULL, 0);
+grpc_channel_args* grpc_channel_args_copy(const grpc_channel_args* src) {
+  return grpc_channel_args_copy_and_add(src, nullptr, 0);
 }
 
-grpc_channel_args *grpc_channel_args_union(const grpc_channel_args *a,
-                                           const grpc_channel_args *b) {
+grpc_channel_args* grpc_channel_args_union(const grpc_channel_args* a,
+                                           const grpc_channel_args* b) {
   const size_t max_out = (a->num_args + b->num_args);
-  grpc_arg *uniques = (grpc_arg *)gpr_malloc(sizeof(*uniques) * max_out);
+  grpc_arg* uniques = (grpc_arg*)gpr_malloc(sizeof(*uniques) * max_out);
   for (size_t i = 0; i < a->num_args; ++i) uniques[i] = a->args[i];
 
   size_t uniques_idx = a->num_args;
   for (size_t i = 0; i < b->num_args; ++i) {
-    const char *b_key = b->args[i].key;
-    if (grpc_channel_args_find(a, b_key) == NULL) {  // not found
+    const char* b_key = b->args[i].key;
+    if (grpc_channel_args_find(a, b_key) == nullptr) {  // not found
       uniques[uniques_idx++] = b->args[i];
     }
   }
-  grpc_channel_args *result =
-      grpc_channel_args_copy_and_add(NULL, uniques, uniques_idx);
+  grpc_channel_args* result =
+      grpc_channel_args_copy_and_add(nullptr, uniques, uniques_idx);
   gpr_free(uniques);
   return result;
 }
 
-static int cmp_arg(const grpc_arg *a, const grpc_arg *b) {
+static int cmp_arg(const grpc_arg* a, const grpc_arg* b) {
   int c = GPR_ICMP(a->type, b->type);
   if (c != 0) return c;
   c = strcmp(a->key, b->key);
@@ -160,26 +160,26 @@ static int cmp_arg(const grpc_arg *a, const grpc_arg *b) {
 
 /* stabilizing comparison function: since channel_args ordering matters for
  * keys with the same name, we need to preserve that ordering */
-static int cmp_key_stable(const void *ap, const void *bp) {
-  const grpc_arg *const *a = (const grpc_arg *const *)ap;
-  const grpc_arg *const *b = (const grpc_arg *const *)bp;
+static int cmp_key_stable(const void* ap, const void* bp) {
+  const grpc_arg* const* a = (const grpc_arg* const*)ap;
+  const grpc_arg* const* b = (const grpc_arg* const*)bp;
   int c = strcmp((*a)->key, (*b)->key);
   if (c == 0) c = GPR_ICMP(*a, *b);
   return c;
 }
 
-grpc_channel_args *grpc_channel_args_normalize(const grpc_channel_args *a) {
-  grpc_arg **args = (grpc_arg **)gpr_malloc(sizeof(grpc_arg *) * a->num_args);
+grpc_channel_args* grpc_channel_args_normalize(const grpc_channel_args* a) {
+  grpc_arg** args = (grpc_arg**)gpr_malloc(sizeof(grpc_arg*) * a->num_args);
   for (size_t i = 0; i < a->num_args; i++) {
     args[i] = &a->args[i];
   }
   if (a->num_args > 1)
-    qsort(args, a->num_args, sizeof(grpc_arg *), cmp_key_stable);
+    qsort(args, a->num_args, sizeof(grpc_arg*), cmp_key_stable);
 
-  grpc_channel_args *b =
-      (grpc_channel_args *)gpr_malloc(sizeof(grpc_channel_args));
+  grpc_channel_args* b =
+      (grpc_channel_args*)gpr_malloc(sizeof(grpc_channel_args));
   b->num_args = a->num_args;
-  b->args = (grpc_arg *)gpr_malloc(sizeof(grpc_arg) * b->num_args);
+  b->args = (grpc_arg*)gpr_malloc(sizeof(grpc_arg) * b->num_args);
   for (size_t i = 0; i < a->num_args; i++) {
     b->args[i] = copy_arg(args[i]);
   }
@@ -188,7 +188,7 @@ grpc_channel_args *grpc_channel_args_normalize(const grpc_channel_args *a) {
   return b;
 }
 
-void grpc_channel_args_destroy(grpc_exec_ctx *exec_ctx, grpc_channel_args *a) {
+void grpc_channel_args_destroy(grpc_exec_ctx* exec_ctx, grpc_channel_args* a) {
   size_t i;
   if (!a) return;
   for (i = 0; i < a->num_args; i++) {
@@ -210,9 +210,9 @@ void grpc_channel_args_destroy(grpc_exec_ctx *exec_ctx, grpc_channel_args *a) {
 }
 
 grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
-    const grpc_channel_args *a) {
+    const grpc_channel_args* a) {
   size_t i;
-  if (a == NULL) return GRPC_COMPRESS_NONE;
+  if (a == nullptr) return GRPC_COMPRESS_NONE;
   for (i = 0; i < a->num_args; ++i) {
     if (a->args[i].type == GRPC_ARG_INTEGER &&
         !strcmp(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM, a->args[i].key)) {
@@ -224,9 +224,9 @@ grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
 }
 
 grpc_stream_compression_algorithm
-grpc_channel_args_get_stream_compression_algorithm(const grpc_channel_args *a) {
+grpc_channel_args_get_stream_compression_algorithm(const grpc_channel_args* a) {
   size_t i;
-  if (a == NULL) return GRPC_STREAM_COMPRESS_NONE;
+  if (a == nullptr) return GRPC_STREAM_COMPRESS_NONE;
   for (i = 0; i < a->num_args; ++i) {
     if (a->args[i].type == GRPC_ARG_INTEGER &&
         !strcmp(GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM,
@@ -238,22 +238,22 @@ grpc_channel_args_get_stream_compression_algorithm(const grpc_channel_args *a) {
   return GRPC_STREAM_COMPRESS_NONE;
 }
 
-grpc_channel_args *grpc_channel_args_set_compression_algorithm(
-    grpc_channel_args *a, grpc_compression_algorithm algorithm) {
+grpc_channel_args* grpc_channel_args_set_compression_algorithm(
+    grpc_channel_args* a, grpc_compression_algorithm algorithm) {
   GPR_ASSERT(algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT);
   grpc_arg tmp;
   tmp.type = GRPC_ARG_INTEGER;
-  tmp.key = (char *)GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM;
+  tmp.key = (char*)GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM;
   tmp.value.integer = algorithm;
   return grpc_channel_args_copy_and_add(a, &tmp, 1);
 }
 
-grpc_channel_args *grpc_channel_args_set_stream_compression_algorithm(
-    grpc_channel_args *a, grpc_stream_compression_algorithm algorithm) {
+grpc_channel_args* grpc_channel_args_set_stream_compression_algorithm(
+    grpc_channel_args* a, grpc_stream_compression_algorithm algorithm) {
   GPR_ASSERT(algorithm < GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT);
   grpc_arg tmp;
   tmp.type = GRPC_ARG_INTEGER;
-  tmp.key = (char *)GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM;
+  tmp.key = (char*)GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM;
   tmp.value.integer = algorithm;
   return grpc_channel_args_copy_and_add(a, &tmp, 1);
 }
@@ -261,9 +261,9 @@ grpc_channel_args *grpc_channel_args_set_stream_compression_algorithm(
 /** Returns 1 if the argument for compression algorithm's enabled states bitset
  * was found in \a a, returning the arg's value in \a states. Otherwise, returns
  * 0. */
-static int find_compression_algorithm_states_bitset(const grpc_channel_args *a,
-                                                    int **states_arg) {
-  if (a != NULL) {
+static int find_compression_algorithm_states_bitset(const grpc_channel_args* a,
+                                                    int** states_arg) {
+  if (a != nullptr) {
     size_t i;
     for (i = 0; i < a->num_args; ++i) {
       if (a->args[i].type == GRPC_ARG_INTEGER &&
@@ -282,8 +282,8 @@ static int find_compression_algorithm_states_bitset(const grpc_channel_args *a,
  * was found in \a a, returning the arg's value in \a states. Otherwise, returns
  * 0. */
 static int find_stream_compression_algorithm_states_bitset(
-    const grpc_channel_args *a, int **states_arg) {
-  if (a != NULL) {
+    const grpc_channel_args* a, int** states_arg) {
+  if (a != nullptr) {
     size_t i;
     for (i = 0; i < a->num_args; ++i) {
       if (a->args[i].type == GRPC_ARG_INTEGER &&
@@ -298,17 +298,17 @@ static int find_stream_compression_algorithm_states_bitset(
   return 0; /* GPR_FALSE */
 }
 
-grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
-    grpc_exec_ctx *exec_ctx, grpc_channel_args **a,
+grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
+    grpc_exec_ctx* exec_ctx, grpc_channel_args** a,
     grpc_compression_algorithm algorithm, int state) {
-  int *states_arg = NULL;
-  grpc_channel_args *result = *a;
+  int* states_arg = nullptr;
+  grpc_channel_args* result = *a;
   const int states_arg_found =
       find_compression_algorithm_states_bitset(*a, &states_arg);
 
   if (grpc_channel_args_get_compression_algorithm(*a) == algorithm &&
       state == 0) {
-    const char *algo_name = NULL;
+    const char* algo_name = nullptr;
     GPR_ASSERT(grpc_compression_algorithm_name(algorithm, &algo_name) != 0);
     gpr_log(GPR_ERROR,
             "Tried to disable default compression algorithm '%s'. The "
@@ -316,21 +316,21 @@ grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
             algo_name);
   } else if (states_arg_found) {
     if (state != 0) {
-      GPR_BITSET((unsigned *)states_arg, algorithm);
+      GPR_BITSET((unsigned*)states_arg, algorithm);
     } else if (algorithm != GRPC_COMPRESS_NONE) {
-      GPR_BITCLEAR((unsigned *)states_arg, algorithm);
+      GPR_BITCLEAR((unsigned*)states_arg, algorithm);
     }
   } else {
     /* create a new arg */
     grpc_arg tmp;
     tmp.type = GRPC_ARG_INTEGER;
-    tmp.key = (char *)GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET;
+    tmp.key = (char*)GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET;
     /* all enabled by default */
     tmp.value.integer = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
     if (state != 0) {
-      GPR_BITSET((unsigned *)&tmp.value.integer, algorithm);
+      GPR_BITSET((unsigned*)&tmp.value.integer, algorithm);
     } else if (algorithm != GRPC_COMPRESS_NONE) {
-      GPR_BITCLEAR((unsigned *)&tmp.value.integer, algorithm);
+      GPR_BITCLEAR((unsigned*)&tmp.value.integer, algorithm);
     }
     result = grpc_channel_args_copy_and_add(*a, &tmp, 1);
     grpc_channel_args_destroy(exec_ctx, *a);
@@ -339,17 +339,17 @@ grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
   return result;
 }
 
-grpc_channel_args *grpc_channel_args_stream_compression_algorithm_set_state(
-    grpc_exec_ctx *exec_ctx, grpc_channel_args **a,
+grpc_channel_args* grpc_channel_args_stream_compression_algorithm_set_state(
+    grpc_exec_ctx* exec_ctx, grpc_channel_args** a,
     grpc_stream_compression_algorithm algorithm, int state) {
-  int *states_arg = NULL;
-  grpc_channel_args *result = *a;
+  int* states_arg = nullptr;
+  grpc_channel_args* result = *a;
   const int states_arg_found =
       find_stream_compression_algorithm_states_bitset(*a, &states_arg);
 
   if (grpc_channel_args_get_stream_compression_algorithm(*a) == algorithm &&
       state == 0) {
-    const char *algo_name = NULL;
+    const char* algo_name = nullptr;
     GPR_ASSERT(grpc_stream_compression_algorithm_name(algorithm, &algo_name) !=
                0);
     gpr_log(GPR_ERROR,
@@ -358,21 +358,21 @@ grpc_channel_args *grpc_channel_args_stream_compression_algorithm_set_state(
             algo_name);
   } else if (states_arg_found) {
     if (state != 0) {
-      GPR_BITSET((unsigned *)states_arg, algorithm);
+      GPR_BITSET((unsigned*)states_arg, algorithm);
     } else if (algorithm != GRPC_STREAM_COMPRESS_NONE) {
-      GPR_BITCLEAR((unsigned *)states_arg, algorithm);
+      GPR_BITCLEAR((unsigned*)states_arg, algorithm);
     }
   } else {
     /* create a new arg */
     grpc_arg tmp;
     tmp.type = GRPC_ARG_INTEGER;
-    tmp.key = (char *)GRPC_STREAM_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET;
+    tmp.key = (char*)GRPC_STREAM_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET;
     /* all enabled by default */
     tmp.value.integer = (1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) - 1;
     if (state != 0) {
-      GPR_BITSET((unsigned *)&tmp.value.integer, algorithm);
+      GPR_BITSET((unsigned*)&tmp.value.integer, algorithm);
     } else if (algorithm != GRPC_STREAM_COMPRESS_NONE) {
-      GPR_BITCLEAR((unsigned *)&tmp.value.integer, algorithm);
+      GPR_BITCLEAR((unsigned*)&tmp.value.integer, algorithm);
     }
     result = grpc_channel_args_copy_and_add(*a, &tmp, 1);
     grpc_channel_args_destroy(exec_ctx, *a);
@@ -382,8 +382,8 @@ grpc_channel_args *grpc_channel_args_stream_compression_algorithm_set_state(
 }
 
 uint32_t grpc_channel_args_compression_algorithm_get_states(
-    const grpc_channel_args *a) {
-  int *states_arg;
+    const grpc_channel_args* a) {
+  int* states_arg;
   if (find_compression_algorithm_states_bitset(a, &states_arg)) {
     return (uint32_t)*states_arg;
   } else {
@@ -392,8 +392,8 @@ uint32_t grpc_channel_args_compression_algorithm_get_states(
 }
 
 uint32_t grpc_channel_args_stream_compression_algorithm_get_states(
-    const grpc_channel_args *a) {
-  int *states_arg;
+    const grpc_channel_args* a) {
+  int* states_arg;
   if (find_stream_compression_algorithm_states_bitset(a, &states_arg)) {
     return (uint32_t)*states_arg;
   } else {
@@ -402,14 +402,14 @@ uint32_t grpc_channel_args_stream_compression_algorithm_get_states(
   }
 }
 
-grpc_channel_args *grpc_channel_args_set_socket_mutator(
-    grpc_channel_args *a, grpc_socket_mutator *mutator) {
+grpc_channel_args* grpc_channel_args_set_socket_mutator(
+    grpc_channel_args* a, grpc_socket_mutator* mutator) {
   grpc_arg tmp = grpc_socket_mutator_to_arg(mutator);
   return grpc_channel_args_copy_and_add(a, &tmp, 1);
 }
 
-int grpc_channel_args_compare(const grpc_channel_args *a,
-                              const grpc_channel_args *b) {
+int grpc_channel_args_compare(const grpc_channel_args* a,
+                              const grpc_channel_args* b) {
   int c = GPR_ICMP(a->num_args, b->num_args);
   if (c != 0) return c;
   for (size_t i = 0; i < a->num_args; i++) {
@@ -419,21 +419,21 @@ int grpc_channel_args_compare(const grpc_channel_args *a,
   return 0;
 }
 
-const grpc_arg *grpc_channel_args_find(const grpc_channel_args *args,
-                                       const char *name) {
-  if (args != NULL) {
+const grpc_arg* grpc_channel_args_find(const grpc_channel_args* args,
+                                       const char* name) {
+  if (args != nullptr) {
     for (size_t i = 0; i < args->num_args; ++i) {
       if (strcmp(args->args[i].key, name) == 0) {
         return &args->args[i];
       }
     }
   }
-  return NULL;
+  return nullptr;
 }
 
-int grpc_channel_arg_get_integer(const grpc_arg *arg,
+int grpc_channel_arg_get_integer(const grpc_arg* arg,
                                  const grpc_integer_options options) {
-  if (arg == NULL) return options.default_value;
+  if (arg == nullptr) return options.default_value;
   if (arg->type != GRPC_ARG_INTEGER) {
     gpr_log(GPR_ERROR, "%s ignored: it must be an integer", arg->key);
     return options.default_value;
@@ -451,8 +451,8 @@ int grpc_channel_arg_get_integer(const grpc_arg *arg,
   return arg->value.integer;
 }
 
-bool grpc_channel_arg_get_bool(const grpc_arg *arg, bool default_value) {
-  if (arg == NULL) return default_value;
+bool grpc_channel_arg_get_bool(const grpc_arg* arg, bool default_value) {
+  if (arg == nullptr) return default_value;
   if (arg->type != GRPC_ARG_INTEGER) {
     gpr_log(GPR_ERROR, "%s ignored: it must be an integer", arg->key);
     return default_value;
@@ -469,12 +469,12 @@ bool grpc_channel_arg_get_bool(const grpc_arg *arg, bool default_value) {
   }
 }
 
-bool grpc_channel_args_want_minimal_stack(const grpc_channel_args *args) {
+bool grpc_channel_args_want_minimal_stack(const grpc_channel_args* args) {
   return grpc_channel_arg_get_bool(
       grpc_channel_args_find(args, GRPC_ARG_MINIMAL_STACK), false);
 }
 
-grpc_arg grpc_channel_arg_string_create(char *name, char *value) {
+grpc_arg grpc_channel_arg_string_create(char* name, char* value) {
   grpc_arg arg;
   arg.type = GRPC_ARG_STRING;
   arg.key = name;
@@ -482,7 +482,7 @@ grpc_arg grpc_channel_arg_string_create(char *name, char *value) {
   return arg;
 }
 
-grpc_arg grpc_channel_arg_integer_create(char *name, int value) {
+grpc_arg grpc_channel_arg_integer_create(char* name, int value) {
   grpc_arg arg;
   arg.type = GRPC_ARG_INTEGER;
   arg.key = name;
@@ -491,7 +491,7 @@ grpc_arg grpc_channel_arg_integer_create(char *name, int value) {
 }
 
 grpc_arg grpc_channel_arg_pointer_create(
-    char *name, void *value, const grpc_arg_pointer_vtable *vtable) {
+    char* name, void* value, const grpc_arg_pointer_vtable* vtable) {
   grpc_arg arg;
   arg.type = GRPC_ARG_POINTER;
   arg.key = name;