grpc 1.7.3 → 1.8.0

data/src/core/ext/filters/client_channel/resolver_registry.h

@@ -22,18 +22,22 @@
 #include "src/core/ext/filters/client_channel/resolver_factory.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 void grpc_resolver_registry_init();
 void grpc_resolver_registry_shutdown(void);
 
 /** Set the default URI prefix to \a default_prefix. */
-void grpc_resolver_registry_set_default_prefix(const char *default_prefix);
+void grpc_resolver_registry_set_default_prefix(const char* default_prefix);
 
 /** Register a resolver type.
     URI's of \a scheme will be resolved with the given resolver.
     If \a priority is greater than zero, then the resolver will be eligible
     to resolve names that are passed in with no scheme. Higher priority
     resolvers will be tried before lower priority schemes. */
-void grpc_register_resolver_type(grpc_resolver_factory *factory);
+void grpc_register_resolver_type(grpc_resolver_factory* factory);
 
 /** Create a resolver given \a target.
     First tries to parse \a target as a URI. If this succeeds, tries
@@ -48,22 +52,26 @@ void grpc_register_resolver_type(grpc_resolver_factory *factory);
     (typically the set of arguments passed in from the client API).
     \a pollset_set is used to drive IO in the name resolution process, it
     should not be NULL. */
-grpc_resolver *grpc_resolver_create(grpc_exec_ctx *exec_ctx, const char *target,
-                                    const grpc_channel_args *args,
-                                    grpc_pollset_set *pollset_set,
-                                    grpc_combiner *combiner);
+grpc_resolver* grpc_resolver_create(grpc_exec_ctx* exec_ctx, const char* target,
+                                    const grpc_channel_args* args,
+                                    grpc_pollset_set* pollset_set,
+                                    grpc_combiner* combiner);
 
 /** Find a resolver factory given a name and return an (owned-by-the-caller)
  *  reference to it */
-grpc_resolver_factory *grpc_resolver_factory_lookup(const char *name);
+grpc_resolver_factory* grpc_resolver_factory_lookup(const char* name);
 
 /** Given a target, return a (freshly allocated with gpr_malloc) string
     representing the default authority to pass from a client. */
-char *grpc_get_default_authority(grpc_exec_ctx *exec_ctx, const char *target);
+char* grpc_get_default_authority(grpc_exec_ctx* exec_ctx, const char* target);
 
 /** Returns a newly allocated string containing \a target, adding the
     default prefix if needed. */
-char *grpc_resolver_factory_add_default_prefix_if_needed(
-    grpc_exec_ctx *exec_ctx, const char *target);
+char* grpc_resolver_factory_add_default_prefix_if_needed(
+    grpc_exec_ctx* exec_ctx, const char* target);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_REGISTRY_H */

data/src/core/ext/filters/client_channel/{retry_throttle.c → retry_throttle.cc}

@@ -48,7 +48,7 @@ static void get_replacement_throttle_data_if_needed(
     grpc_server_retry_throttle_data* new_throttle_data =
         (grpc_server_retry_throttle_data*)gpr_atm_acq_load(
             &(*throttle_data)->replacement);
-    if (new_throttle_data == NULL) return;
+    if (new_throttle_data == nullptr) return;
     *throttle_data = new_throttle_data;
   }
 }
@@ -88,7 +88,7 @@ void grpc_server_retry_throttle_data_unref(
     grpc_server_retry_throttle_data* replacement =
         (grpc_server_retry_throttle_data*)gpr_atm_acq_load(
             &throttle_data->replacement);
-    if (replacement != NULL) {
+    if (replacement != nullptr) {
       grpc_server_retry_throttle_data_unref(replacement);
     }
     gpr_free(throttle_data);
@@ -109,7 +109,7 @@ static grpc_server_retry_throttle_data* grpc_server_retry_throttle_data_create(
   // the token count by scaling proportionately to the old data.  This
   // ensures that if we're already throttling retries on the old scale,
   // we will start out doing the same thing on the new one.
-  if (old_throttle_data != NULL) {
+  if (old_throttle_data != nullptr) {
     double token_fraction =
         (int)gpr_atm_acq_load(&old_throttle_data->milli_tokens) /
         (double)old_throttle_data->max_milli_tokens;
@@ -119,7 +119,7 @@ static grpc_server_retry_throttle_data* grpc_server_retry_throttle_data_create(
                     (gpr_atm)initial_milli_tokens);
   // If there was a pre-existing entry, mark it as stale and give it a
   // pointer to the new entry, which is its replacement.
-  if (old_throttle_data != NULL) {
+  if (old_throttle_data != nullptr) {
     grpc_server_retry_throttle_data_ref(throttle_data);
     gpr_atm_rel_store(&old_throttle_data->replacement, (gpr_atm)throttle_data);
   }
@@ -170,7 +170,7 @@ void grpc_retry_throttle_map_init() {
 
 void grpc_retry_throttle_map_shutdown() {
   gpr_mu_destroy(&g_mu);
-  gpr_avl_unref(g_avl, NULL);
+  gpr_avl_unref(g_avl, nullptr);
 }
 
 grpc_server_retry_throttle_data* grpc_retry_throttle_map_get_data_for_server(
@@ -178,12 +178,12 @@ grpc_server_retry_throttle_data* grpc_retry_throttle_map_get_data_for_server(
   gpr_mu_lock(&g_mu);
   grpc_server_retry_throttle_data* throttle_data =
       (grpc_server_retry_throttle_data*)gpr_avl_get(g_avl, (char*)server_name,
-                                                    NULL);
-  if (throttle_data == NULL) {
+                                                    nullptr);
+  if (throttle_data == nullptr) {
     // Entry not found.  Create a new one.
     throttle_data = grpc_server_retry_throttle_data_create(
-        max_milli_tokens, milli_token_ratio, NULL);
-    g_avl = gpr_avl_add(g_avl, (char*)server_name, throttle_data, NULL);
+        max_milli_tokens, milli_token_ratio, nullptr);
+    g_avl = gpr_avl_add(g_avl, (char*)server_name, throttle_data, nullptr);
   } else {
     if (throttle_data->max_milli_tokens != max_milli_tokens ||
         throttle_data->milli_token_ratio != milli_token_ratio) {
@@ -191,7 +191,7 @@ grpc_server_retry_throttle_data* grpc_retry_throttle_map_get_data_for_server(
       // the original one.
       throttle_data = grpc_server_retry_throttle_data_create(
           max_milli_tokens, milli_token_ratio, throttle_data);
-      g_avl = gpr_avl_add(g_avl, (char*)server_name, throttle_data, NULL);
+      g_avl = gpr_avl_add(g_avl, (char*)server_name, throttle_data, nullptr);
     } else {
       // Entry found.  Increase refcount.
       grpc_server_retry_throttle_data_ref(throttle_data);

data/src/core/ext/filters/client_channel/retry_throttle.h

@@ -21,6 +21,10 @@
 
 #include <stdbool.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /// Tracks retry throttling data for an individual server name.
 typedef struct grpc_server_retry_throttle_data grpc_server_retry_throttle_data;
 
@@ -47,4 +51,8 @@ void grpc_retry_throttle_map_shutdown();
 grpc_server_retry_throttle_data* grpc_retry_throttle_map_get_data_for_server(
     const char* server_name, int max_milli_tokens, int milli_token_ratio);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_THROTTLE_H */

data/src/core/ext/filters/client_channel/{subchannel.c → subchannel.cc}

@@ -18,6 +18,7 @@
 
 #include "src/core/ext/filters/client_channel/subchannel.h"
 
+#include <inttypes.h>
 #include <limits.h>
 #include <string.h>
 
@@ -30,6 +31,7 @@
 #include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
 #include "src/core/ext/filters/client_channel/subchannel_index.h"
 #include "src/core/ext/filters/client_channel/uri_parser.h"
+#include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/connected_channel.h"
 #include "src/core/lib/debug/stats.h"
@@ -37,7 +39,6 @@
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/support/backoff.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/transport/connectivity_state.h"
@@ -51,27 +52,27 @@
 #define GRPC_SUBCHANNEL_RECONNECT_MAX_BACKOFF_SECONDS 120
 #define GRPC_SUBCHANNEL_RECONNECT_JITTER 0.2
 
-#define GET_CONNECTED_SUBCHANNEL(subchannel, barrier)      \
-  ((grpc_connected_subchannel *)(gpr_atm_##barrier##_load( \
+#define GET_CONNECTED_SUBCHANNEL(subchannel, barrier)     \
+  ((grpc_connected_subchannel*)(gpr_atm_##barrier##_load( \
       &(subchannel)->connected_subchannel)))
 
 typedef struct {
   grpc_closure closure;
-  grpc_subchannel *subchannel;
+  grpc_subchannel* subchannel;
   grpc_connectivity_state connectivity_state;
 } state_watcher;
 
 typedef struct external_state_watcher {
-  grpc_subchannel *subchannel;
-  grpc_pollset_set *pollset_set;
-  grpc_closure *notify;
+  grpc_subchannel* subchannel;
+  grpc_pollset_set* pollset_set;
+  grpc_closure* notify;
   grpc_closure closure;
-  struct external_state_watcher *next;
-  struct external_state_watcher *prev;
+  struct external_state_watcher* next;
+  struct external_state_watcher* prev;
 } external_state_watcher;
 
 struct grpc_subchannel {
-  grpc_connector *connector;
+  grpc_connector* connector;
 
   /** refcount
       - lower INTERNAL_REF_BITS bits are for internal references:
@@ -81,12 +82,12 @@ struct grpc_subchannel {
   gpr_atm ref_pair;
 
   /** non-transport related channel filters */
-  const grpc_channel_filter **filters;
+  const grpc_channel_filter** filters;
   size_t num_filters;
   /** channel arguments */
-  grpc_channel_args *args;
+  grpc_channel_args* args;
 
-  grpc_subchannel_key *key;
+  grpc_subchannel_key* key;
 
   /** set during connection */
   grpc_connect_out_args connecting_result;
@@ -99,7 +100,7 @@ struct grpc_subchannel {
 
   /** pollset_set tracking who's interested in a connection
       being setup */
-  grpc_pollset_set *pollset_set;
+  grpc_pollset_set* pollset_set;
 
   /** active connection, or null; of type grpc_connected_subchannel */
   gpr_atm connected_subchannel;
@@ -116,10 +117,10 @@ struct grpc_subchannel {
 
   external_state_watcher root_external_state_watcher;
 
-  /** next connect attempt time */
-  gpr_timespec next_attempt;
   /** backoff state */
-  gpr_backoff backoff_state;
+  grpc_backoff backoff_state;
+  grpc_backoff_result backoff_result;
+
   /** do we have an active alarm? */
   bool have_alarm;
   /** have we started the backoff loop */
@@ -129,22 +130,22 @@ struct grpc_subchannel {
 };
 
 struct grpc_subchannel_call {
-  grpc_connected_subchannel *connection;
-  grpc_closure *schedule_closure_after_destroy;
+  grpc_connected_subchannel* connection;
+  grpc_closure* schedule_closure_after_destroy;
 };
 
-#define SUBCHANNEL_CALL_TO_CALL_STACK(call) ((grpc_call_stack *)((call) + 1))
-#define CHANNEL_STACK_FROM_CONNECTION(con) ((grpc_channel_stack *)(con))
+#define SUBCHANNEL_CALL_TO_CALL_STACK(call) ((grpc_call_stack*)((call) + 1))
+#define CHANNEL_STACK_FROM_CONNECTION(con) ((grpc_channel_stack*)(con))
 #define CALLSTACK_TO_SUBCHANNEL_CALL(callstack) \
-  (((grpc_subchannel_call *)(callstack)) - 1)
+  (((grpc_subchannel_call*)(callstack)) - 1)
 
-static void subchannel_connected(grpc_exec_ctx *exec_ctx, void *subchannel,
-                                 grpc_error *error);
+static void subchannel_connected(grpc_exec_ctx* exec_ctx, void* subchannel,
+                                 grpc_error* error);
 
 #ifndef NDEBUG
 #define REF_REASON reason
 #define REF_MUTATE_EXTRA_ARGS \
-  GRPC_SUBCHANNEL_REF_EXTRA_ARGS, const char *purpose
+  GRPC_SUBCHANNEL_REF_EXTRA_ARGS, const char* purpose
 #define REF_MUTATE_PURPOSE(x) , file, line, reason, x
 #else
 #define REF_REASON ""
@@ -156,21 +157,21 @@ static void subchannel_connected(grpc_exec_ctx *exec_ctx, void *subchannel,
  * connection implementation
  */
 
-static void connection_destroy(grpc_exec_ctx *exec_ctx, void *arg,
-                               grpc_error *error) {
-  grpc_connected_subchannel *c = (grpc_connected_subchannel *)arg;
+static void connection_destroy(grpc_exec_ctx* exec_ctx, void* arg,
+                               grpc_error* error) {
+  grpc_connected_subchannel* c = (grpc_connected_subchannel*)arg;
   grpc_channel_stack_destroy(exec_ctx, CHANNEL_STACK_FROM_CONNECTION(c));
   gpr_free(c);
 }
 
-grpc_connected_subchannel *grpc_connected_subchannel_ref(
-    grpc_connected_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+grpc_connected_subchannel* grpc_connected_subchannel_ref(
+    grpc_connected_subchannel* c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
   GRPC_CHANNEL_STACK_REF(CHANNEL_STACK_FROM_CONNECTION(c), REF_REASON);
   return c;
 }
 
-void grpc_connected_subchannel_unref(grpc_exec_ctx *exec_ctx,
-                                     grpc_connected_subchannel *c
+void grpc_connected_subchannel_unref(grpc_exec_ctx* exec_ctx,
+                                     grpc_connected_subchannel* c
                                          GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
   GRPC_CHANNEL_STACK_UNREF(exec_ctx, CHANNEL_STACK_FROM_CONNECTION(c),
                            REF_REASON);
@@ -180,10 +181,10 @@ void grpc_connected_subchannel_unref(grpc_exec_ctx *exec_ctx,
  * grpc_subchannel implementation
  */
 
-static void subchannel_destroy(grpc_exec_ctx *exec_ctx, void *arg,
-                               grpc_error *error) {
-  grpc_subchannel *c = (grpc_subchannel *)arg;
-  gpr_free((void *)c->filters);
+static void subchannel_destroy(grpc_exec_ctx* exec_ctx, void* arg,
+                               grpc_error* error) {
+  grpc_subchannel* c = (grpc_subchannel*)arg;
+  gpr_free((void*)c->filters);
   grpc_channel_args_destroy(exec_ctx, c->args);
   grpc_connectivity_state_destroy(exec_ctx, &c->state_tracker);
   grpc_connector_unref(exec_ctx, c->connector);
@@ -193,12 +194,12 @@ static void subchannel_destroy(grpc_exec_ctx *exec_ctx, void *arg,
   gpr_free(c);
 }
 
-static gpr_atm ref_mutate(grpc_subchannel *c, gpr_atm delta,
+static gpr_atm ref_mutate(grpc_subchannel* c, gpr_atm delta,
                           int barrier REF_MUTATE_EXTRA_ARGS) {
   gpr_atm old_val = barrier ? gpr_atm_full_fetch_add(&c->ref_pair, delta)
                             : gpr_atm_no_barrier_fetch_add(&c->ref_pair, delta);
 #ifndef NDEBUG
-  if (GRPC_TRACER_ON(grpc_trace_stream_refcount)) {
+  if (grpc_trace_stream_refcount.enabled()) {
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "SUBCHANNEL: %p %12s 0x%" PRIxPTR " -> 0x%" PRIxPTR " [%s]", c,
             purpose, old_val, old_val + delta, reason);
@@ -207,8 +208,8 @@ static gpr_atm ref_mutate(grpc_subchannel *c, gpr_atm delta,
   return old_val;
 }
 
-grpc_subchannel *grpc_subchannel_ref(
-    grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+grpc_subchannel* grpc_subchannel_ref(
+    grpc_subchannel* c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
   gpr_atm old_refs;
   old_refs = ref_mutate(c, (1 << INTERNAL_REF_BITS),
                         0 REF_MUTATE_PURPOSE("STRONG_REF"));
@@ -216,17 +217,17 @@ grpc_subchannel *grpc_subchannel_ref(
   return c;
 }
 
-grpc_subchannel *grpc_subchannel_weak_ref(
-    grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+grpc_subchannel* grpc_subchannel_weak_ref(
+    grpc_subchannel* c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
   gpr_atm old_refs;
   old_refs = ref_mutate(c, 1, 0 REF_MUTATE_PURPOSE("WEAK_REF"));
   GPR_ASSERT(old_refs != 0);
   return c;
 }
 
-grpc_subchannel *grpc_subchannel_ref_from_weak_ref(
-    grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
-  if (!c) return NULL;
+grpc_subchannel* grpc_subchannel_ref_from_weak_ref(
+    grpc_subchannel* c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+  if (!c) return nullptr;
   for (;;) {
     gpr_atm old_refs = gpr_atm_acq_load(&c->ref_pair);
     if (old_refs >= (1 << INTERNAL_REF_BITS)) {
@@ -235,13 +236,13 @@ grpc_subchannel *grpc_subchannel_ref_from_weak_ref(
         return c;
       }
     } else {
-      return NULL;
+      return nullptr;
     }
   }
 }
 
-static void disconnect(grpc_exec_ctx *exec_ctx, grpc_subchannel *c) {
-  grpc_connected_subchannel *con;
+static void disconnect(grpc_exec_ctx* exec_ctx, grpc_subchannel* c) {
+  grpc_connected_subchannel* con;
   grpc_subchannel_index_unregister(exec_ctx, c->key, c);
   gpr_mu_lock(&c->mu);
   GPR_ASSERT(!c->disconnected);
@@ -250,15 +251,15 @@ static void disconnect(grpc_exec_ctx *exec_ctx, grpc_subchannel *c) {
       exec_ctx, c->connector,
       GRPC_ERROR_CREATE_FROM_STATIC_STRING("Subchannel disconnected"));
   con = GET_CONNECTED_SUBCHANNEL(c, no_barrier);
-  if (con != NULL) {
+  if (con != nullptr) {
     GRPC_CONNECTED_SUBCHANNEL_UNREF(exec_ctx, con, "connection");
     gpr_atm_no_barrier_store(&c->connected_subchannel, (gpr_atm)0xdeadbeef);
   }
   gpr_mu_unlock(&c->mu);
 }
 
-void grpc_subchannel_unref(grpc_exec_ctx *exec_ctx,
-                           grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+void grpc_subchannel_unref(grpc_exec_ctx* exec_ctx,
+                           grpc_subchannel* c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
   gpr_atm old_refs;
   // add a weak ref and subtract a strong ref (atomically)
   old_refs = ref_mutate(c, (gpr_atm)1 - (gpr_atm)(1 << INTERNAL_REF_BITS),
@@ -269,63 +270,64 @@ void grpc_subchannel_unref(grpc_exec_ctx *exec_ctx,
   GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, c, "strong-unref");
 }
 
-void grpc_subchannel_weak_unref(grpc_exec_ctx *exec_ctx,
-                                grpc_subchannel *c
+void grpc_subchannel_weak_unref(grpc_exec_ctx* exec_ctx,
+                                grpc_subchannel* c
                                     GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
   gpr_atm old_refs;
   old_refs = ref_mutate(c, -(gpr_atm)1, 1 REF_MUTATE_PURPOSE("WEAK_UNREF"));
   if (old_refs == 1) {
-    GRPC_CLOSURE_SCHED(exec_ctx, GRPC_CLOSURE_CREATE(subchannel_destroy, c,
-                                                     grpc_schedule_on_exec_ctx),
-                       GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(
+        exec_ctx,
+        GRPC_CLOSURE_CREATE(subchannel_destroy, c, grpc_schedule_on_exec_ctx),
+        GRPC_ERROR_NONE);
   }
 }
 
-grpc_subchannel *grpc_subchannel_create(grpc_exec_ctx *exec_ctx,
-                                        grpc_connector *connector,
-                                        const grpc_subchannel_args *args) {
-  grpc_subchannel_key *key = grpc_subchannel_key_create(args);
-  grpc_subchannel *c = grpc_subchannel_index_find(exec_ctx, key);
+grpc_subchannel* grpc_subchannel_create(grpc_exec_ctx* exec_ctx,
+                                        grpc_connector* connector,
+                                        const grpc_subchannel_args* args) {
+  grpc_subchannel_key* key = grpc_subchannel_key_create(args);
+  grpc_subchannel* c = grpc_subchannel_index_find(exec_ctx, key);
   if (c) {
     grpc_subchannel_key_destroy(exec_ctx, key);
     return c;
   }
 
   GRPC_STATS_INC_CLIENT_SUBCHANNELS_CREATED(exec_ctx);
-  c = (grpc_subchannel *)gpr_zalloc(sizeof(*c));
+  c = (grpc_subchannel*)gpr_zalloc(sizeof(*c));
   c->key = key;
   gpr_atm_no_barrier_store(&c->ref_pair, 1 << INTERNAL_REF_BITS);
   c->connector = connector;
   grpc_connector_ref(c->connector);
   c->num_filters = args->filter_count;
   if (c->num_filters > 0) {
-    c->filters = (const grpc_channel_filter **)gpr_malloc(
-        sizeof(grpc_channel_filter *) * c->num_filters);
-    memcpy((void *)c->filters, args->filters,
-           sizeof(grpc_channel_filter *) * c->num_filters);
+    c->filters = (const grpc_channel_filter**)gpr_malloc(
+        sizeof(grpc_channel_filter*) * c->num_filters);
+    memcpy((void*)c->filters, args->filters,
+           sizeof(grpc_channel_filter*) * c->num_filters);
   } else {
-    c->filters = NULL;
+    c->filters = nullptr;
   }
   c->pollset_set = grpc_pollset_set_create();
-  grpc_resolved_address *addr =
-      (grpc_resolved_address *)gpr_malloc(sizeof(*addr));
+  grpc_resolved_address* addr =
+      (grpc_resolved_address*)gpr_malloc(sizeof(*addr));
   grpc_get_subchannel_address_arg(exec_ctx, args->args, addr);
-  grpc_resolved_address *new_address = NULL;
-  grpc_channel_args *new_args = NULL;
+  grpc_resolved_address* new_address = nullptr;
+  grpc_channel_args* new_args = nullptr;
   if (grpc_proxy_mappers_map_address(exec_ctx, addr, args->args, &new_address,
                                      &new_args)) {
-    GPR_ASSERT(new_address != NULL);
+    GPR_ASSERT(new_address != nullptr);
     gpr_free(addr);
     addr = new_address;
   }
-  static const char *keys_to_remove[] = {GRPC_ARG_SUBCHANNEL_ADDRESS};
+  static const char* keys_to_remove[] = {GRPC_ARG_SUBCHANNEL_ADDRESS};
   grpc_arg new_arg = grpc_create_subchannel_address_arg(addr);
   gpr_free(addr);
   c->args = grpc_channel_args_copy_and_add_and_remove(
-      new_args != NULL ? new_args : args->args, keys_to_remove,
+      new_args != nullptr ? new_args : args->args, keys_to_remove,
       GPR_ARRAY_SIZE(keys_to_remove), &new_arg, 1);
   gpr_free(new_arg.value.string);
-  if (new_args != NULL) grpc_channel_args_destroy(exec_ctx, new_args);
+  if (new_args != nullptr) grpc_channel_args_destroy(exec_ctx, new_args);
   c->root_external_state_watcher.next = c->root_external_state_watcher.prev =
       &c->root_external_state_watcher;
   GRPC_CLOSURE_INIT(&c->connected, subchannel_connected, c,
@@ -343,31 +345,27 @@ grpc_subchannel *grpc_subchannel_create(grpc_exec_ctx *exec_ctx,
                       "grpc.testing.fixed_reconnect_backoff_ms")) {
         fixed_reconnect_backoff = true;
         initial_backoff_ms = min_backoff_ms = max_backoff_ms =
-            grpc_channel_arg_get_integer(
-                &c->args->args[i],
-                (grpc_integer_options){initial_backoff_ms, 100, INT_MAX});
+            grpc_channel_arg_get_integer(&c->args->args[i],
+                                         {initial_backoff_ms, 100, INT_MAX});
       } else if (0 == strcmp(c->args->args[i].key,
                              GRPC_ARG_MIN_RECONNECT_BACKOFF_MS)) {
         fixed_reconnect_backoff = false;
         min_backoff_ms = grpc_channel_arg_get_integer(
-            &c->args->args[i],
-            (grpc_integer_options){min_backoff_ms, 100, INT_MAX});
+            &c->args->args[i], {min_backoff_ms, 100, INT_MAX});
       } else if (0 == strcmp(c->args->args[i].key,
                              GRPC_ARG_MAX_RECONNECT_BACKOFF_MS)) {
         fixed_reconnect_backoff = false;
         max_backoff_ms = grpc_channel_arg_get_integer(
-            &c->args->args[i],
-            (grpc_integer_options){max_backoff_ms, 100, INT_MAX});
+            &c->args->args[i], {max_backoff_ms, 100, INT_MAX});
       } else if (0 == strcmp(c->args->args[i].key,
                              GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS)) {
         fixed_reconnect_backoff = false;
         initial_backoff_ms = grpc_channel_arg_get_integer(
-            &c->args->args[i],
-            (grpc_integer_options){initial_backoff_ms, 100, INT_MAX});
+            &c->args->args[i], {initial_backoff_ms, 100, INT_MAX});
       }
     }
   }
-  gpr_backoff_init(
+  grpc_backoff_init(
       &c->backoff_state, initial_backoff_ms,
       fixed_reconnect_backoff ? 1.0
                               : GRPC_SUBCHANNEL_RECONNECT_BACKOFF_MULTIPLIER,
@@ -378,12 +376,12 @@ grpc_subchannel *grpc_subchannel_create(grpc_exec_ctx *exec_ctx,
   return grpc_subchannel_index_register(exec_ctx, key, c);
 }
 
-static void continue_connect_locked(grpc_exec_ctx *exec_ctx,
-                                    grpc_subchannel *c) {
+static void continue_connect_locked(grpc_exec_ctx* exec_ctx,
+                                    grpc_subchannel* c) {
   grpc_connect_in_args args;
 
   args.interested_parties = c->pollset_set;
-  args.deadline = c->next_attempt;
+  args.deadline = c->backoff_result.current_deadline;
   args.channel_args = c->args;
 
   grpc_connectivity_state_set(exec_ctx, &c->state_tracker,
@@ -393,8 +391,8 @@ static void continue_connect_locked(grpc_exec_ctx *exec_ctx,
                          &c->connected);
 }
 
-grpc_connectivity_state grpc_subchannel_check_connectivity(grpc_subchannel *c,
-                                                           grpc_error **error) {
+grpc_connectivity_state grpc_subchannel_check_connectivity(grpc_subchannel* c,
+                                                           grpc_error** error) {
   grpc_connectivity_state state;
   gpr_mu_lock(&c->mu);
   state = grpc_connectivity_state_get(&c->state_tracker, error);
@@ -402,11 +400,11 @@ grpc_connectivity_state grpc_subchannel_check_connectivity(grpc_subchannel *c,
   return state;
 }
 
-static void on_external_state_watcher_done(grpc_exec_ctx *exec_ctx, void *arg,
-                                           grpc_error *error) {
-  external_state_watcher *w = (external_state_watcher *)arg;
-  grpc_closure *follow_up = w->notify;
-  if (w->pollset_set != NULL) {
+static void on_external_state_watcher_done(grpc_exec_ctx* exec_ctx, void* arg,
+                                           grpc_error* error) {
+  external_state_watcher* w = (external_state_watcher*)arg;
+  grpc_closure* follow_up = w->notify;
+  if (w->pollset_set != nullptr) {
     grpc_pollset_set_del_pollset_set(exec_ctx, w->subchannel->pollset_set,
                                      w->pollset_set);
   }
@@ -419,8 +417,8 @@ static void on_external_state_watcher_done(grpc_exec_ctx *exec_ctx, void *arg,
   GRPC_CLOSURE_RUN(exec_ctx, follow_up, GRPC_ERROR_REF(error));
 }
 
-static void on_alarm(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  grpc_subchannel *c = (grpc_subchannel *)arg;
+static void on_alarm(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  grpc_subchannel* c = (grpc_subchannel*)arg;
   gpr_mu_lock(&c->mu);
   c->have_alarm = false;
   if (c->disconnected) {
@@ -431,8 +429,7 @@ static void on_alarm(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
   }
   if (error == GRPC_ERROR_NONE) {
     gpr_log(GPR_INFO, "Failed to connect to channel, retrying");
-    c->next_attempt =
-        gpr_backoff_step(&c->backoff_state, gpr_now(GPR_CLOCK_MONOTONIC));
+    c->backoff_result = grpc_backoff_step(exec_ctx, &c->backoff_state);
     continue_connect_locked(exec_ctx, c);
     gpr_mu_unlock(&c->mu);
   } else {
@@ -442,8 +439,8 @@ static void on_alarm(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
   GRPC_ERROR_UNREF(error);
 }
 
-static void maybe_start_connecting_locked(grpc_exec_ctx *exec_ctx,
-                                          grpc_subchannel *c) {
+static void maybe_start_connecting_locked(grpc_exec_ctx* exec_ctx,
+                                          grpc_subchannel* c) {
   if (c->disconnected) {
     /* Don't try to connect if we're already disconnected */
     return;
@@ -454,7 +451,7 @@ static void maybe_start_connecting_locked(grpc_exec_ctx *exec_ctx,
     return;
   }
 
-  if (GET_CONNECTED_SUBCHANNEL(c, no_barrier) != NULL) {
+  if (GET_CONNECTED_SUBCHANNEL(c, no_barrier) != nullptr) {
     /* Already connected: don't restart */
     return;
   }
@@ -467,51 +464,50 @@ static void maybe_start_connecting_locked(grpc_exec_ctx *exec_ctx,
   c->connecting = true;
   GRPC_SUBCHANNEL_WEAK_REF(c, "connecting");
 
-  gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
   if (!c->backoff_begun) {
     c->backoff_begun = true;
-    c->next_attempt = gpr_backoff_begin(&c->backoff_state, now);
+    c->backoff_result = grpc_backoff_begin(exec_ctx, &c->backoff_state);
     continue_connect_locked(exec_ctx, c);
   } else {
     GPR_ASSERT(!c->have_alarm);
     c->have_alarm = true;
-    gpr_timespec time_til_next = gpr_time_sub(c->next_attempt, now);
-    if (gpr_time_cmp(time_til_next, gpr_time_0(time_til_next.clock_type)) <=
-        0) {
+    const grpc_millis time_til_next =
+        c->backoff_result.next_attempt_start_time - grpc_exec_ctx_now(exec_ctx);
+    if (time_til_next <= 0) {
       gpr_log(GPR_INFO, "Retry immediately");
     } else {
-      gpr_log(GPR_INFO, "Retry in %" PRId64 ".%09d seconds",
-              time_til_next.tv_sec, time_til_next.tv_nsec);
+      gpr_log(GPR_INFO, "Retry in %" PRIdPTR " milliseconds", time_til_next);
     }
     GRPC_CLOSURE_INIT(&c->on_alarm, on_alarm, c, grpc_schedule_on_exec_ctx);
-    grpc_timer_init(exec_ctx, &c->alarm, c->next_attempt, &c->on_alarm, now);
+    grpc_timer_init(exec_ctx, &c->alarm,
+                    c->backoff_result.next_attempt_start_time, &c->on_alarm);
   }
 }
 
 void grpc_subchannel_notify_on_state_change(
-    grpc_exec_ctx *exec_ctx, grpc_subchannel *c,
-    grpc_pollset_set *interested_parties, grpc_connectivity_state *state,
-    grpc_closure *notify) {
-  external_state_watcher *w;
+    grpc_exec_ctx* exec_ctx, grpc_subchannel* c,
+    grpc_pollset_set* interested_parties, grpc_connectivity_state* state,
+    grpc_closure* notify) {
+  external_state_watcher* w;
 
-  if (state == NULL) {
+  if (state == nullptr) {
     gpr_mu_lock(&c->mu);
     for (w = c->root_external_state_watcher.next;
          w != &c->root_external_state_watcher; w = w->next) {
       if (w->notify == notify) {
         grpc_connectivity_state_notify_on_state_change(
-            exec_ctx, &c->state_tracker, NULL, &w->closure);
+            exec_ctx, &c->state_tracker, nullptr, &w->closure);
       }
     }
     gpr_mu_unlock(&c->mu);
   } else {
-    w = (external_state_watcher *)gpr_malloc(sizeof(*w));
+    w = (external_state_watcher*)gpr_malloc(sizeof(*w));
     w->subchannel = c;
     w->pollset_set = interested_parties;
     w->notify = notify;
     GRPC_CLOSURE_INIT(&w->closure, on_external_state_watcher_done, w,
                       grpc_schedule_on_exec_ctx);
-    if (interested_parties != NULL) {
+    if (interested_parties != nullptr) {
       grpc_pollset_set_add_pollset_set(exec_ctx, c->pollset_set,
                                        interested_parties);
     }
@@ -528,18 +524,18 @@ void grpc_subchannel_notify_on_state_change(
 }
 
 void grpc_connected_subchannel_process_transport_op(
-    grpc_exec_ctx *exec_ctx, grpc_connected_subchannel *con,
-    grpc_transport_op *op) {
-  grpc_channel_stack *channel_stack = CHANNEL_STACK_FROM_CONNECTION(con);
-  grpc_channel_element *top_elem = grpc_channel_stack_element(channel_stack, 0);
+    grpc_exec_ctx* exec_ctx, grpc_connected_subchannel* con,
+    grpc_transport_op* op) {
+  grpc_channel_stack* channel_stack = CHANNEL_STACK_FROM_CONNECTION(con);
+  grpc_channel_element* top_elem = grpc_channel_stack_element(channel_stack, 0);
   top_elem->filter->start_transport_op(exec_ctx, top_elem, op);
 }
 
-static void subchannel_on_child_state_changed(grpc_exec_ctx *exec_ctx, void *p,
-                                              grpc_error *error) {
-  state_watcher *sw = (state_watcher *)p;
-  grpc_subchannel *c = sw->subchannel;
-  gpr_mu *mu = &c->mu;
+static void subchannel_on_child_state_changed(grpc_exec_ctx* exec_ctx, void* p,
+                                              grpc_error* error) {
+  state_watcher* sw = (state_watcher*)p;
+  grpc_subchannel* c = sw->subchannel;
+  gpr_mu* mu = &c->mu;
 
   gpr_mu_lock(mu);
 
@@ -553,10 +549,10 @@ static void subchannel_on_child_state_changed(grpc_exec_ctx *exec_ctx, void *p,
                               "reflect_child");
   if (sw->connectivity_state != GRPC_CHANNEL_SHUTDOWN) {
     grpc_connected_subchannel_notify_on_state_change(
-        exec_ctx, GET_CONNECTED_SUBCHANNEL(c, no_barrier), NULL,
+        exec_ctx, GET_CONNECTED_SUBCHANNEL(c, no_barrier), nullptr,
         &sw->connectivity_state, &sw->closure);
     GRPC_SUBCHANNEL_WEAK_REF(c, "state_watcher");
-    sw = NULL;
+    sw = nullptr;
   }
 
   gpr_mu_unlock(mu);
@@ -564,13 +560,13 @@ static void subchannel_on_child_state_changed(grpc_exec_ctx *exec_ctx, void *p,
   gpr_free(sw);
 }
 
-static void connected_subchannel_state_op(grpc_exec_ctx *exec_ctx,
-                                          grpc_connected_subchannel *con,
-                                          grpc_pollset_set *interested_parties,
-                                          grpc_connectivity_state *state,
-                                          grpc_closure *closure) {
-  grpc_transport_op *op = grpc_make_transport_op(NULL);
-  grpc_channel_element *elem;
+static void connected_subchannel_state_op(grpc_exec_ctx* exec_ctx,
+                                          grpc_connected_subchannel* con,
+                                          grpc_pollset_set* interested_parties,
+                                          grpc_connectivity_state* state,
+                                          grpc_closure* closure) {
+  grpc_transport_op* op = grpc_make_transport_op(nullptr);
+  grpc_channel_element* elem;
   op->connectivity_state = state;
   op->on_connectivity_state_change = closure;
   op->bind_pollset_set = interested_parties;
@@ -579,31 +575,31 @@ static void connected_subchannel_state_op(grpc_exec_ctx *exec_ctx,
 }
 
 void grpc_connected_subchannel_notify_on_state_change(
-    grpc_exec_ctx *exec_ctx, grpc_connected_subchannel *con,
-    grpc_pollset_set *interested_parties, grpc_connectivity_state *state,
-    grpc_closure *closure) {
+    grpc_exec_ctx* exec_ctx, grpc_connected_subchannel* con,
+    grpc_pollset_set* interested_parties, grpc_connectivity_state* state,
+    grpc_closure* closure) {
   connected_subchannel_state_op(exec_ctx, con, interested_parties, state,
                                 closure);
 }
 
-void grpc_connected_subchannel_ping(grpc_exec_ctx *exec_ctx,
-                                    grpc_connected_subchannel *con,
-                                    grpc_closure *closure) {
-  grpc_transport_op *op = grpc_make_transport_op(NULL);
-  grpc_channel_element *elem;
+void grpc_connected_subchannel_ping(grpc_exec_ctx* exec_ctx,
+                                    grpc_connected_subchannel* con,
+                                    grpc_closure* closure) {
+  grpc_transport_op* op = grpc_make_transport_op(nullptr);
+  grpc_channel_element* elem;
   op->send_ping = closure;
   elem = grpc_channel_stack_element(CHANNEL_STACK_FROM_CONNECTION(con), 0);
   elem->filter->start_transport_op(exec_ctx, elem, op);
 }
 
-static bool publish_transport_locked(grpc_exec_ctx *exec_ctx,
-                                     grpc_subchannel *c) {
-  grpc_connected_subchannel *con;
-  grpc_channel_stack *stk;
-  state_watcher *sw_subchannel;
+static bool publish_transport_locked(grpc_exec_ctx* exec_ctx,
+                                     grpc_subchannel* c) {
+  grpc_connected_subchannel* con;
+  grpc_channel_stack* stk;
+  state_watcher* sw_subchannel;
 
   /* construct channel stack */
-  grpc_channel_stack_builder *builder = grpc_channel_stack_builder_create();
+  grpc_channel_stack_builder* builder = grpc_channel_stack_builder_create();
   grpc_channel_stack_builder_set_channel_arguments(
       exec_ctx, builder, c->connecting_result.channel_args);
   grpc_channel_stack_builder_set_transport(builder,
@@ -614,8 +610,8 @@ static bool publish_transport_locked(grpc_exec_ctx *exec_ctx,
     grpc_channel_stack_builder_destroy(exec_ctx, builder);
     return false;
   }
-  grpc_error *error = grpc_channel_stack_builder_finish(
-      exec_ctx, builder, 0, 1, connection_destroy, NULL, (void **)&con);
+  grpc_error* error = grpc_channel_stack_builder_finish(
+      exec_ctx, builder, 0, 1, connection_destroy, nullptr, (void**)&con);
   if (error != GRPC_ERROR_NONE) {
     grpc_transport_destroy(exec_ctx, c->connecting_result.transport);
     gpr_log(GPR_ERROR, "error initializing subchannel stack: %s",
@@ -627,7 +623,7 @@ static bool publish_transport_locked(grpc_exec_ctx *exec_ctx,
   memset(&c->connecting_result, 0, sizeof(c->connecting_result));
 
   /* initialize state watcher */
-  sw_subchannel = (state_watcher *)gpr_malloc(sizeof(*sw_subchannel));
+  sw_subchannel = (state_watcher*)gpr_malloc(sizeof(*sw_subchannel));
   sw_subchannel->subchannel = c;
   sw_subchannel->connectivity_state = GRPC_CHANNEL_READY;
   GRPC_CLOSURE_INIT(&sw_subchannel->closure, subchannel_on_child_state_changed,
@@ -662,15 +658,15 @@ static bool publish_transport_locked(grpc_exec_ctx *exec_ctx,
   return true;
 }
 
-static void subchannel_connected(grpc_exec_ctx *exec_ctx, void *arg,
-                                 grpc_error *error) {
-  grpc_subchannel *c = (grpc_subchannel *)arg;
-  grpc_channel_args *delete_channel_args = c->connecting_result.channel_args;
+static void subchannel_connected(grpc_exec_ctx* exec_ctx, void* arg,
+                                 grpc_error* error) {
+  grpc_subchannel* c = (grpc_subchannel*)arg;
+  grpc_channel_args* delete_channel_args = c->connecting_result.channel_args;
 
   GRPC_SUBCHANNEL_WEAK_REF(c, "connected");
   gpr_mu_lock(&c->mu);
   c->connecting = false;
-  if (c->connecting_result.transport != NULL &&
+  if (c->connecting_result.transport != nullptr &&
       publish_transport_locked(exec_ctx, c)) {
     /* do nothing, transport was published */
   } else if (c->disconnected) {
@@ -683,7 +679,7 @@ static void subchannel_connected(grpc_exec_ctx *exec_ctx, void *arg,
                            GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE),
         "connect_failed");
 
-    const char *errmsg = grpc_error_string(error);
+    const char* errmsg = grpc_error_string(error);
     gpr_log(GPR_INFO, "Connect failed: %s", errmsg);
 
     maybe_start_connecting_locked(exec_ctx, c);
@@ -698,79 +694,80 @@ static void subchannel_connected(grpc_exec_ctx *exec_ctx, void *arg,
  * grpc_subchannel_call implementation
  */
 
-static void subchannel_call_destroy(grpc_exec_ctx *exec_ctx, void *call,
-                                    grpc_error *error) {
-  grpc_subchannel_call *c = (grpc_subchannel_call *)call;
-  GPR_ASSERT(c->schedule_closure_after_destroy != NULL);
+static void subchannel_call_destroy(grpc_exec_ctx* exec_ctx, void* call,
+                                    grpc_error* error) {
+  grpc_subchannel_call* c = (grpc_subchannel_call*)call;
+  GPR_ASSERT(c->schedule_closure_after_destroy != nullptr);
   GPR_TIMER_BEGIN("grpc_subchannel_call_unref.destroy", 0);
-  grpc_connected_subchannel *connection = c->connection;
-  grpc_call_stack_destroy(exec_ctx, SUBCHANNEL_CALL_TO_CALL_STACK(c), NULL,
+  grpc_connected_subchannel* connection = c->connection;
+  grpc_call_stack_destroy(exec_ctx, SUBCHANNEL_CALL_TO_CALL_STACK(c), nullptr,
                           c->schedule_closure_after_destroy);
   GRPC_CONNECTED_SUBCHANNEL_UNREF(exec_ctx, connection, "subchannel_call");
   GPR_TIMER_END("grpc_subchannel_call_unref.destroy", 0);
 }
 
-void grpc_subchannel_call_set_cleanup_closure(grpc_subchannel_call *call,
-                                              grpc_closure *closure) {
-  GPR_ASSERT(call->schedule_closure_after_destroy == NULL);
-  GPR_ASSERT(closure != NULL);
+void grpc_subchannel_call_set_cleanup_closure(grpc_subchannel_call* call,
+                                              grpc_closure* closure) {
+  GPR_ASSERT(call->schedule_closure_after_destroy == nullptr);
+  GPR_ASSERT(closure != nullptr);
   call->schedule_closure_after_destroy = closure;
 }
 
 void grpc_subchannel_call_ref(
-    grpc_subchannel_call *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+    grpc_subchannel_call* c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
   GRPC_CALL_STACK_REF(SUBCHANNEL_CALL_TO_CALL_STACK(c), REF_REASON);
 }
 
-void grpc_subchannel_call_unref(grpc_exec_ctx *exec_ctx,
-                                grpc_subchannel_call *c
+void grpc_subchannel_call_unref(grpc_exec_ctx* exec_ctx,
+                                grpc_subchannel_call* c
                                     GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
   GRPC_CALL_STACK_UNREF(exec_ctx, SUBCHANNEL_CALL_TO_CALL_STACK(c), REF_REASON);
 }
 
-void grpc_subchannel_call_process_op(grpc_exec_ctx *exec_ctx,
-                                     grpc_subchannel_call *call,
-                                     grpc_transport_stream_op_batch *batch) {
+void grpc_subchannel_call_process_op(grpc_exec_ctx* exec_ctx,
+                                     grpc_subchannel_call* call,
+                                     grpc_transport_stream_op_batch* batch) {
   GPR_TIMER_BEGIN("grpc_subchannel_call_process_op", 0);
-  grpc_call_stack *call_stack = SUBCHANNEL_CALL_TO_CALL_STACK(call);
-  grpc_call_element *top_elem = grpc_call_stack_element(call_stack, 0);
+  grpc_call_stack* call_stack = SUBCHANNEL_CALL_TO_CALL_STACK(call);
+  grpc_call_element* top_elem = grpc_call_stack_element(call_stack, 0);
   GRPC_CALL_LOG_OP(GPR_INFO, top_elem, batch);
   top_elem->filter->start_transport_stream_op_batch(exec_ctx, top_elem, batch);
   GPR_TIMER_END("grpc_subchannel_call_process_op", 0);
 }
 
-grpc_connected_subchannel *grpc_subchannel_get_connected_subchannel(
-    grpc_subchannel *c) {
+grpc_connected_subchannel* grpc_subchannel_get_connected_subchannel(
+    grpc_subchannel* c) {
   return GET_CONNECTED_SUBCHANNEL(c, acq);
 }
 
-const grpc_subchannel_key *grpc_subchannel_get_key(
-    const grpc_subchannel *subchannel) {
+const grpc_subchannel_key* grpc_subchannel_get_key(
+    const grpc_subchannel* subchannel) {
   return subchannel->key;
 }
 
-grpc_error *grpc_connected_subchannel_create_call(
-    grpc_exec_ctx *exec_ctx, grpc_connected_subchannel *con,
-    const grpc_connected_subchannel_call_args *args,
-    grpc_subchannel_call **call) {
-  grpc_channel_stack *chanstk = CHANNEL_STACK_FROM_CONNECTION(con);
-  *call = (grpc_subchannel_call *)gpr_arena_alloc(
+grpc_error* grpc_connected_subchannel_create_call(
+    grpc_exec_ctx* exec_ctx, grpc_connected_subchannel* con,
+    const grpc_connected_subchannel_call_args* args,
+    grpc_subchannel_call** call) {
+  grpc_channel_stack* chanstk = CHANNEL_STACK_FROM_CONNECTION(con);
+  *call = (grpc_subchannel_call*)gpr_arena_alloc(
       args->arena, sizeof(grpc_subchannel_call) + chanstk->call_stack_size);
-  grpc_call_stack *callstk = SUBCHANNEL_CALL_TO_CALL_STACK(*call);
+  grpc_call_stack* callstk = SUBCHANNEL_CALL_TO_CALL_STACK(*call);
   (*call)->connection = GRPC_CONNECTED_SUBCHANNEL_REF(con, "subchannel_call");
   const grpc_call_element_args call_args = {
-      .call_stack = callstk,
-      .server_transport_data = NULL,
-      .context = args->context,
-      .path = args->path,
-      .start_time = args->start_time,
-      .deadline = args->deadline,
-      .arena = args->arena,
-      .call_combiner = args->call_combiner};
-  grpc_error *error = grpc_call_stack_init(
+      callstk,            /* call_stack */
+      nullptr,            /* server_transport_data */
+      args->context,      /* context */
+      args->path,         /* path */
+      args->start_time,   /* start_time */
+      args->deadline,     /* deadline */
+      args->arena,        /* arena */
+      args->call_combiner /* call_combiner */
+  };
+  grpc_error* error = grpc_call_stack_init(
       exec_ctx, chanstk, 1, subchannel_call_destroy, *call, &call_args);
   if (error != GRPC_ERROR_NONE) {
-    const char *error_string = grpc_error_string(error);
+    const char* error_string = grpc_error_string(error);
     gpr_log(GPR_ERROR, "error: %s", error_string);
     return error;
   }
@@ -778,39 +775,39 @@ grpc_error *grpc_connected_subchannel_create_call(
   return GRPC_ERROR_NONE;
 }
 
-grpc_call_stack *grpc_subchannel_call_get_call_stack(
-    grpc_subchannel_call *subchannel_call) {
+grpc_call_stack* grpc_subchannel_call_get_call_stack(
+    grpc_subchannel_call* subchannel_call) {
   return SUBCHANNEL_CALL_TO_CALL_STACK(subchannel_call);
 }
 
-static void grpc_uri_to_sockaddr(grpc_exec_ctx *exec_ctx, const char *uri_str,
-                                 grpc_resolved_address *addr) {
-  grpc_uri *uri = grpc_uri_parse(exec_ctx, uri_str, 0 /* suppress_errors */);
-  GPR_ASSERT(uri != NULL);
+static void grpc_uri_to_sockaddr(grpc_exec_ctx* exec_ctx, const char* uri_str,
+                                 grpc_resolved_address* addr) {
+  grpc_uri* uri = grpc_uri_parse(exec_ctx, uri_str, 0 /* suppress_errors */);
+  GPR_ASSERT(uri != nullptr);
   if (!grpc_parse_uri(uri, addr)) memset(addr, 0, sizeof(*addr));
   grpc_uri_destroy(uri);
 }
 
-void grpc_get_subchannel_address_arg(grpc_exec_ctx *exec_ctx,
-                                     const grpc_channel_args *args,
-                                     grpc_resolved_address *addr) {
-  const char *addr_uri_str = grpc_get_subchannel_address_uri_arg(args);
+void grpc_get_subchannel_address_arg(grpc_exec_ctx* exec_ctx,
+                                     const grpc_channel_args* args,
+                                     grpc_resolved_address* addr) {
+  const char* addr_uri_str = grpc_get_subchannel_address_uri_arg(args);
   memset(addr, 0, sizeof(*addr));
   if (*addr_uri_str != '\0') {
     grpc_uri_to_sockaddr(exec_ctx, addr_uri_str, addr);
   }
 }
 
-const char *grpc_get_subchannel_address_uri_arg(const grpc_channel_args *args) {
-  const grpc_arg *addr_arg =
+const char* grpc_get_subchannel_address_uri_arg(const grpc_channel_args* args) {
+  const grpc_arg* addr_arg =
       grpc_channel_args_find(args, GRPC_ARG_SUBCHANNEL_ADDRESS);
-  GPR_ASSERT(addr_arg != NULL);  // Should have been set by LB policy.
+  GPR_ASSERT(addr_arg != nullptr);  // Should have been set by LB policy.
   GPR_ASSERT(addr_arg->type == GRPC_ARG_STRING);
   return addr_arg->value.string;
 }
 
-grpc_arg grpc_create_subchannel_address_arg(const grpc_resolved_address *addr) {
+grpc_arg grpc_create_subchannel_address_arg(const grpc_resolved_address* addr) {
   return grpc_channel_arg_string_create(
-      (char *)GRPC_ARG_SUBCHANNEL_ADDRESS,
+      (char*)GRPC_ARG_SUBCHANNEL_ADDRESS,
       addr->len > 0 ? grpc_sockaddr_to_uri(addr) : gpr_strdup(""));
 }