grpc 1.7.3 → 1.8.0

data/src/core/ext/filters/client_channel/backup_poller.cc

@@ -0,0 +1,165 @@
+/*
+ *
+ * Copyright 2015 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/ext/filters/client_channel/backup_poller.h"
+
+#include <grpc/grpc.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include "src/core/ext/filters/client_channel/client_channel.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/pollset.h"
+#include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/support/env.h"
+#include "src/core/lib/support/string.h"
+#include "src/core/lib/surface/channel.h"
+#include "src/core/lib/surface/completion_queue.h"
+
+#define DEFAULT_POLL_INTERVAL_MS 5000
+
+typedef struct backup_poller {
+  grpc_timer polling_timer;
+  grpc_closure run_poller_closure;
+  grpc_closure shutdown_closure;
+  gpr_mu* pollset_mu;
+  grpc_pollset* pollset;  // guarded by pollset_mu
+  bool shutting_down;     // guarded by pollset_mu
+  gpr_refcount refs;
+  gpr_refcount shutdown_refs;
+} backup_poller;
+
+static gpr_once g_once = GPR_ONCE_INIT;
+static gpr_mu g_poller_mu;
+static backup_poller* g_poller = nullptr;  // guarded by g_poller_mu
+// g_poll_interval_ms is set only once at the first time
+// grpc_client_channel_start_backup_polling() is called, after that it is
+// treated as const.
+static int g_poll_interval_ms = DEFAULT_POLL_INTERVAL_MS;
+
+static void init_globals() {
+  gpr_mu_init(&g_poller_mu);
+  char* env = gpr_getenv("GRPC_CLIENT_CHANNEL_BACKUP_POLL_INTERVAL_MS");
+  if (env != nullptr) {
+    int poll_interval_ms = gpr_parse_nonnegative_int(env);
+    if (poll_interval_ms == -1) {
+      gpr_log(GPR_ERROR,
+              "Invalid GRPC_CLIENT_CHANNEL_BACKUP_POLL_INTERVAL_MS: %s, "
+              "default value %d will be used.",
+              env, g_poll_interval_ms);
+    } else {
+      g_poll_interval_ms = poll_interval_ms;
+    }
+  }
+  gpr_free(env);
+}
+
+static void backup_poller_shutdown_unref(grpc_exec_ctx* exec_ctx,
+                                         backup_poller* p) {
+  if (gpr_unref(&p->shutdown_refs)) {
+    grpc_pollset_destroy(exec_ctx, p->pollset);
+    gpr_free(p->pollset);
+    gpr_free(p);
+  }
+}
+
+static void done_poller(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  backup_poller_shutdown_unref(exec_ctx, (backup_poller*)arg);
+}
+
+static void g_poller_unref(grpc_exec_ctx* exec_ctx) {
+  if (gpr_unref(&g_poller->refs)) {
+    gpr_mu_lock(&g_poller_mu);
+    backup_poller* p = g_poller;
+    g_poller = nullptr;
+    gpr_mu_unlock(&g_poller_mu);
+    gpr_mu_lock(p->pollset_mu);
+    p->shutting_down = true;
+    grpc_pollset_shutdown(exec_ctx, p->pollset,
+                          GRPC_CLOSURE_INIT(&p->shutdown_closure, done_poller,
+                                            p, grpc_schedule_on_exec_ctx));
+    gpr_mu_unlock(p->pollset_mu);
+    grpc_timer_cancel(exec_ctx, &p->polling_timer);
+  }
+}
+
+static void run_poller(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  backup_poller* p = (backup_poller*)arg;
+  if (error != GRPC_ERROR_NONE) {
+    if (error != GRPC_ERROR_CANCELLED) {
+      GRPC_LOG_IF_ERROR("run_poller", GRPC_ERROR_REF(error));
+    }
+    backup_poller_shutdown_unref(exec_ctx, p);
+    return;
+  }
+  gpr_mu_lock(p->pollset_mu);
+  if (p->shutting_down) {
+    gpr_mu_unlock(p->pollset_mu);
+    backup_poller_shutdown_unref(exec_ctx, p);
+    return;
+  }
+  grpc_error* err = grpc_pollset_work(exec_ctx, p->pollset, nullptr,
+                                      grpc_exec_ctx_now(exec_ctx));
+  gpr_mu_unlock(p->pollset_mu);
+  GRPC_LOG_IF_ERROR("Run client channel backup poller", err);
+  grpc_timer_init(exec_ctx, &p->polling_timer,
+                  grpc_exec_ctx_now(exec_ctx) + g_poll_interval_ms,
+                  &p->run_poller_closure);
+}
+
+void grpc_client_channel_start_backup_polling(
+    grpc_exec_ctx* exec_ctx, grpc_pollset_set* interested_parties) {
+  gpr_once_init(&g_once, init_globals);
+  if (g_poll_interval_ms == 0) {
+    return;
+  }
+  gpr_mu_lock(&g_poller_mu);
+  if (g_poller == nullptr) {
+    g_poller = (backup_poller*)gpr_zalloc(sizeof(backup_poller));
+    g_poller->pollset = (grpc_pollset*)gpr_zalloc(grpc_pollset_size());
+    g_poller->shutting_down = false;
+    grpc_pollset_init(g_poller->pollset, &g_poller->pollset_mu);
+    gpr_ref_init(&g_poller->refs, 0);
+    // one for timer cancellation, one for pollset shutdown
+    gpr_ref_init(&g_poller->shutdown_refs, 2);
+    GRPC_CLOSURE_INIT(&g_poller->run_poller_closure, run_poller, g_poller,
+                      grpc_schedule_on_exec_ctx);
+    grpc_timer_init(exec_ctx, &g_poller->polling_timer,
+                    grpc_exec_ctx_now(exec_ctx) + g_poll_interval_ms,
+                    &g_poller->run_poller_closure);
+  }
+
+  gpr_ref(&g_poller->refs);
+  /* Get a reference to g_poller->pollset before releasing g_poller_mu to make
+   * TSAN happy. Otherwise, reading from g_poller (i.e g_poller->pollset) after
+   * releasing the lock and setting g_poller to NULL in g_poller_unref() is
+   * being flagged as a data-race by TSAN */
+  grpc_pollset* pollset = g_poller->pollset;
+  gpr_mu_unlock(&g_poller_mu);
+
+  grpc_pollset_set_add_pollset(exec_ctx, interested_parties, pollset);
+}
+
+void grpc_client_channel_stop_backup_polling(
+    grpc_exec_ctx* exec_ctx, grpc_pollset_set* interested_parties) {
+  if (g_poll_interval_ms == 0) {
+    return;
+  }
+  grpc_pollset_set_del_pollset(exec_ctx, interested_parties, g_poller->pollset);
+  g_poller_unref(exec_ctx);
+}

data/src/core/ext/{census/grpc_filter.h → filters/client_channel/backup_poller.h}

@@ -16,14 +16,19 @@
  *
  */
 
-#ifndef GRPC_CORE_EXT_CENSUS_GRPC_FILTER_H
-#define GRPC_CORE_EXT_CENSUS_GRPC_FILTER_H
+#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_BACKUP_POLLER_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_BACKUP_POLLER_H
 
+#include <grpc/grpc.h>
 #include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 
-/* Census filters: provides tracing and stats collection functionalities. It
-   needs to reside right below the surface filter in the channel stack. */
-extern const grpc_channel_filter grpc_client_census_filter;
-extern const grpc_channel_filter grpc_server_census_filter;
+/* Start polling \a interested_parties periodically in the timer thread  */
+void grpc_client_channel_start_backup_polling(
+    grpc_exec_ctx* exec_ctx, grpc_pollset_set* interested_parties);
 
-#endif /* GRPC_CORE_EXT_CENSUS_GRPC_FILTER_H */
+/* Stop polling \a interested_parties */
+void grpc_client_channel_stop_backup_polling(
+    grpc_exec_ctx* exec_ctx, grpc_pollset_set* interested_parties);
+
+#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_BACKUP_POLLER_H */

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

@@ -18,6 +18,8 @@
 
 #include "src/core/lib/surface/channel.h"
 
+#include <inttypes.h>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
@@ -27,9 +29,9 @@
 #include "src/core/lib/surface/completion_queue.h"
 
 grpc_connectivity_state grpc_channel_check_connectivity_state(
-    grpc_channel *channel, int try_to_connect) {
+    grpc_channel* channel, int try_to_connect) {
   /* forward through to the underlying client channel */
-  grpc_channel_element *client_channel_elem =
+  grpc_channel_element* client_channel_elem =
       grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_connectivity_state state;
@@ -64,15 +66,15 @@ typedef struct {
   grpc_closure watcher_timer_init;
   grpc_timer alarm;
   grpc_connectivity_state state;
-  grpc_completion_queue *cq;
+  grpc_completion_queue* cq;
   grpc_cq_completion completion_storage;
-  grpc_channel *channel;
-  grpc_error *error;
-  void *tag;
+  grpc_channel* channel;
+  grpc_error* error;
+  void* tag;
 } state_watcher;
 
-static void delete_state_watcher(grpc_exec_ctx *exec_ctx, state_watcher *w) {
-  grpc_channel_element *client_channel_elem = grpc_channel_stack_last_element(
+static void delete_state_watcher(grpc_exec_ctx* exec_ctx, state_watcher* w) {
+  grpc_channel_element* client_channel_elem = grpc_channel_stack_last_element(
       grpc_channel_get_channel_stack(w->channel));
   if (client_channel_elem->filter == &grpc_client_channel_filter) {
     GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, w->channel,
@@ -84,10 +86,10 @@ static void delete_state_watcher(grpc_exec_ctx *exec_ctx, state_watcher *w) {
   gpr_free(w);
 }
 
-static void finished_completion(grpc_exec_ctx *exec_ctx, void *pw,
-                                grpc_cq_completion *ignored) {
+static void finished_completion(grpc_exec_ctx* exec_ctx, void* pw,
+                                grpc_cq_completion* ignored) {
   bool should_delete = false;
-  state_watcher *w = (state_watcher *)pw;
+  state_watcher* w = (state_watcher*)pw;
   gpr_mu_lock(&w->mu);
   switch (w->phase) {
     case WAITING:
@@ -104,23 +106,23 @@ static void finished_completion(grpc_exec_ctx *exec_ctx, void *pw,
   }
 }
 
-static void partly_done(grpc_exec_ctx *exec_ctx, state_watcher *w,
-                        bool due_to_completion, grpc_error *error) {
+static void partly_done(grpc_exec_ctx* exec_ctx, state_watcher* w,
+                        bool due_to_completion, grpc_error* error) {
   if (due_to_completion) {
     grpc_timer_cancel(exec_ctx, &w->alarm);
   } else {
-    grpc_channel_element *client_channel_elem = grpc_channel_stack_last_element(
+    grpc_channel_element* client_channel_elem = grpc_channel_stack_last_element(
         grpc_channel_get_channel_stack(w->channel));
     grpc_client_channel_watch_connectivity_state(
         exec_ctx, client_channel_elem,
-        grpc_polling_entity_create_from_pollset(grpc_cq_pollset(w->cq)), NULL,
-        &w->on_complete, NULL);
+        grpc_polling_entity_create_from_pollset(grpc_cq_pollset(w->cq)),
+        nullptr, &w->on_complete, nullptr);
   }
 
   gpr_mu_lock(&w->mu);
 
   if (due_to_completion) {
-    if (GRPC_TRACER_ON(grpc_trace_operation_failures)) {
+    if (grpc_trace_operation_failures.enabled()) {
       GRPC_LOG_IF_ERROR("watch_completion_error", GRPC_ERROR_REF(error));
     }
     GRPC_ERROR_UNREF(error);
@@ -159,51 +161,51 @@ static void partly_done(grpc_exec_ctx *exec_ctx, state_watcher *w,
   GRPC_ERROR_UNREF(error);
 }
 
-static void watch_complete(grpc_exec_ctx *exec_ctx, void *pw,
-                           grpc_error *error) {
-  partly_done(exec_ctx, (state_watcher *)pw, true, GRPC_ERROR_REF(error));
+static void watch_complete(grpc_exec_ctx* exec_ctx, void* pw,
+                           grpc_error* error) {
+  partly_done(exec_ctx, (state_watcher*)pw, true, GRPC_ERROR_REF(error));
 }
 
-static void timeout_complete(grpc_exec_ctx *exec_ctx, void *pw,
-                             grpc_error *error) {
-  partly_done(exec_ctx, (state_watcher *)pw, false, GRPC_ERROR_REF(error));
+static void timeout_complete(grpc_exec_ctx* exec_ctx, void* pw,
+                             grpc_error* error) {
+  partly_done(exec_ctx, (state_watcher*)pw, false, GRPC_ERROR_REF(error));
 }
 
-int grpc_channel_num_external_connectivity_watchers(grpc_channel *channel) {
-  grpc_channel_element *client_channel_elem =
+int grpc_channel_num_external_connectivity_watchers(grpc_channel* channel) {
+  grpc_channel_element* client_channel_elem =
       grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel));
   return grpc_client_channel_num_external_connectivity_watchers(
       client_channel_elem);
 }
 
 typedef struct watcher_timer_init_arg {
-  state_watcher *w;
+  state_watcher* w;
   gpr_timespec deadline;
 } watcher_timer_init_arg;
 
-static void watcher_timer_init(grpc_exec_ctx *exec_ctx, void *arg,
-                               grpc_error *error_ignored) {
-  watcher_timer_init_arg *wa = (watcher_timer_init_arg *)arg;
+static void watcher_timer_init(grpc_exec_ctx* exec_ctx, void* arg,
+                               grpc_error* error_ignored) {
+  watcher_timer_init_arg* wa = (watcher_timer_init_arg*)arg;
 
   grpc_timer_init(exec_ctx, &wa->w->alarm,
-                  gpr_convert_clock_type(wa->deadline, GPR_CLOCK_MONOTONIC),
-                  &wa->w->on_timeout, gpr_now(GPR_CLOCK_MONOTONIC));
+                  grpc_timespec_to_millis_round_up(wa->deadline),
+                  &wa->w->on_timeout);
   gpr_free(wa);
 }
 
-int grpc_channel_support_connectivity_watcher(grpc_channel *channel) {
-  grpc_channel_element *client_channel_elem =
+int grpc_channel_support_connectivity_watcher(grpc_channel* channel) {
+  grpc_channel_element* client_channel_elem =
       grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel));
   return client_channel_elem->filter != &grpc_client_channel_filter ? 0 : 1;
 }
 
 void grpc_channel_watch_connectivity_state(
-    grpc_channel *channel, grpc_connectivity_state last_observed_state,
-    gpr_timespec deadline, grpc_completion_queue *cq, void *tag) {
-  grpc_channel_element *client_channel_elem =
+    grpc_channel* channel, grpc_connectivity_state last_observed_state,
+    gpr_timespec deadline, grpc_completion_queue* cq, void* tag) {
+  grpc_channel_element* client_channel_elem =
       grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  state_watcher *w = (state_watcher *)gpr_malloc(sizeof(*w));
+  state_watcher* w = (state_watcher*)gpr_malloc(sizeof(*w));
 
   GRPC_API_TRACE(
       "grpc_channel_watch_connectivity_state("
@@ -211,8 +213,9 @@ void grpc_channel_watch_connectivity_state(
       "deadline=gpr_timespec { tv_sec: %" PRId64
       ", tv_nsec: %d, clock_type: %d }, "
       "cq=%p, tag=%p)",
-      7, (channel, (int)last_observed_state, deadline.tv_sec, deadline.tv_nsec,
-          (int)deadline.clock_type, cq, tag));
+      7,
+      (channel, (int)last_observed_state, deadline.tv_sec, deadline.tv_nsec,
+       (int)deadline.clock_type, cq, tag));
 
   GPR_ASSERT(grpc_cq_begin_op(cq, tag));
 
@@ -226,10 +229,10 @@ void grpc_channel_watch_connectivity_state(
   w->cq = cq;
   w->tag = tag;
   w->channel = channel;
-  w->error = NULL;
+  w->error = nullptr;
 
-  watcher_timer_init_arg *wa =
-      (watcher_timer_init_arg *)gpr_malloc(sizeof(watcher_timer_init_arg));
+  watcher_timer_init_arg* wa =
+      (watcher_timer_init_arg*)gpr_malloc(sizeof(watcher_timer_init_arg));
   wa->w = w;
   wa->deadline = deadline;
   GRPC_CLOSURE_INIT(&w->watcher_timer_init, watcher_timer_init, wa,

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

@@ -16,8 +16,11 @@
  *
  */
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/ext/filters/client_channel/client_channel.h"
 
+#include <inttypes.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
@@ -28,6 +31,7 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/useful.h>
 
+#include "src/core/ext/filters/client_channel/backup_poller.h"
 #include "src/core/ext/filters/client_channel/http_connect_handshaker.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
 #include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
@@ -52,8 +56,7 @@
 
 /* Client channel implementation */
 
-grpc_tracer_flag grpc_client_channel_trace =
-    GRPC_TRACER_INITIALIZER(false, "client_channel");
+grpc_core::TraceFlag grpc_client_channel_trace(false, "client_channel");
 
 /*************************************************************************
  * METHOD-CONFIG TABLE
@@ -68,28 +71,33 @@ typedef enum {
 
 typedef struct {
   gpr_refcount refs;
-  gpr_timespec timeout;
+  grpc_millis timeout;
   wait_for_ready_value wait_for_ready;
 } method_parameters;
 
-static method_parameters *method_parameters_ref(
-    method_parameters *method_params) {
+static method_parameters* method_parameters_ref(
+    method_parameters* method_params) {
   gpr_ref(&method_params->refs);
   return method_params;
 }
 
-static void method_parameters_unref(method_parameters *method_params) {
+static void method_parameters_unref(method_parameters* method_params) {
   if (gpr_unref(&method_params->refs)) {
     gpr_free(method_params);
   }
 }
 
-static void method_parameters_free(grpc_exec_ctx *exec_ctx, void *value) {
-  method_parameters_unref((method_parameters *)value);
+// Wrappers to pass to grpc_service_config_create_method_config_table().
+static void* method_parameters_ref_wrapper(void* value) {
+  return method_parameters_ref((method_parameters*)value);
+}
+static void method_parameters_unref_wrapper(grpc_exec_ctx* exec_ctx,
+                                            void* value) {
+  method_parameters_unref((method_parameters*)value);
 }
 
-static bool parse_wait_for_ready(grpc_json *field,
-                                 wait_for_ready_value *wait_for_ready) {
+static bool parse_wait_for_ready(grpc_json* field,
+                                 wait_for_ready_value* wait_for_ready) {
   if (field->type != GRPC_JSON_TRUE && field->type != GRPC_JSON_FALSE) {
     return false;
   }
@@ -98,58 +106,52 @@ static bool parse_wait_for_ready(grpc_json *field,
   return true;
 }
 
-static bool parse_timeout(grpc_json *field, gpr_timespec *timeout) {
+static bool parse_timeout(grpc_json* field, grpc_millis* timeout) {
   if (field->type != GRPC_JSON_STRING) return false;
   size_t len = strlen(field->value);
   if (field->value[len - 1] != 's') return false;
-  char *buf = gpr_strdup(field->value);
+  char* buf = gpr_strdup(field->value);
   buf[len - 1] = '\0';  // Remove trailing 's'.
-  char *decimal_point = strchr(buf, '.');
-  if (decimal_point != NULL) {
+  char* decimal_point = strchr(buf, '.');
+  int nanos = 0;
+  if (decimal_point != nullptr) {
     *decimal_point = '\0';
-    timeout->tv_nsec = gpr_parse_nonnegative_int(decimal_point + 1);
-    if (timeout->tv_nsec == -1) {
+    nanos = gpr_parse_nonnegative_int(decimal_point + 1);
+    if (nanos == -1) {
+      gpr_free(buf);
+      return false;
+    }
+    int num_digits = (int)strlen(decimal_point + 1);
+    if (num_digits > 9) {  // We don't accept greater precision than nanos.
       gpr_free(buf);
       return false;
     }
-    // There should always be exactly 3, 6, or 9 fractional digits.
-    int multiplier = 1;
-    switch (strlen(decimal_point + 1)) {
-      case 9:
-        break;
-      case 6:
-        multiplier *= 1000;
-        break;
-      case 3:
-        multiplier *= 1000000;
-        break;
-      default:  // Unsupported number of digits.
-        gpr_free(buf);
-        return false;
+    for (int i = 0; i < (9 - num_digits); ++i) {
+      nanos *= 10;
     }
-    timeout->tv_nsec *= multiplier;
   }
-  timeout->tv_sec = gpr_parse_nonnegative_int(buf);
+  int seconds = decimal_point == buf ? 0 : gpr_parse_nonnegative_int(buf);
   gpr_free(buf);
-  if (timeout->tv_sec == -1) return false;
+  if (seconds == -1) return false;
+  *timeout = seconds * GPR_MS_PER_SEC + nanos / GPR_NS_PER_MS;
   return true;
 }
 
-static void *method_parameters_create_from_json(const grpc_json *json) {
+static void* method_parameters_create_from_json(const grpc_json* json) {
   wait_for_ready_value wait_for_ready = WAIT_FOR_READY_UNSET;
-  gpr_timespec timeout = {0, 0, GPR_TIMESPAN};
-  for (grpc_json *field = json->child; field != NULL; field = field->next) {
-    if (field->key == NULL) continue;
+  grpc_millis timeout = 0;
+  for (grpc_json* field = json->child; field != nullptr; field = field->next) {
+    if (field->key == nullptr) continue;
     if (strcmp(field->key, "waitForReady") == 0) {
-      if (wait_for_ready != WAIT_FOR_READY_UNSET) return NULL;  // Duplicate.
-      if (!parse_wait_for_ready(field, &wait_for_ready)) return NULL;
+      if (wait_for_ready != WAIT_FOR_READY_UNSET) return nullptr;  // Duplicate.
+      if (!parse_wait_for_ready(field, &wait_for_ready)) return nullptr;
     } else if (strcmp(field->key, "timeout") == 0) {
-      if (timeout.tv_sec > 0 || timeout.tv_nsec > 0) return NULL;  // Duplicate.
-      if (!parse_timeout(field, &timeout)) return NULL;
+      if (timeout > 0) return nullptr;  // Duplicate.
+      if (!parse_timeout(field, &timeout)) return nullptr;
     }
   }
-  method_parameters *value =
-      (method_parameters *)gpr_malloc(sizeof(method_parameters));
+  method_parameters* value =
+      (method_parameters*)gpr_malloc(sizeof(method_parameters));
   gpr_ref_init(&value->refs, 1);
   value->timeout = timeout;
   value->wait_for_ready = wait_for_ready;
@@ -164,24 +166,24 @@ struct external_connectivity_watcher;
 
 typedef struct client_channel_channel_data {
   /** resolver for this channel */
-  grpc_resolver *resolver;
+  grpc_resolver* resolver;
   /** have we started resolving this channel */
   bool started_resolving;
   /** is deadline checking enabled? */
   bool deadline_checking_enabled;
   /** client channel factory */
-  grpc_client_channel_factory *client_channel_factory;
+  grpc_client_channel_factory* client_channel_factory;
 
   /** combiner protecting all variables below in this data structure */
-  grpc_combiner *combiner;
+  grpc_combiner* combiner;
   /** currently active load balancer */
-  grpc_lb_policy *lb_policy;
+  grpc_lb_policy* lb_policy;
   /** retry throttle data */
-  grpc_server_retry_throttle_data *retry_throttle_data;
+  grpc_server_retry_throttle_data* retry_throttle_data;
   /** maps method names to method_parameters structs */
-  grpc_slice_hash_table *method_params_table;
+  grpc_slice_hash_table* method_params_table;
   /** incoming resolver result - set by resolver.next() */
-  grpc_channel_args *resolver_result;
+  grpc_channel_args* resolver_result;
   /** a list of closures that are all waiting for resolver result to come in */
   grpc_closure_list waiting_for_resolver_result_closures;
   /** resolver callback */
@@ -191,47 +193,47 @@ typedef struct client_channel_channel_data {
   /** when an lb_policy arrives, should we try to exit idle */
   bool exit_idle_when_lb_policy_arrives;
   /** owning stack */
-  grpc_channel_stack *owning_stack;
+  grpc_channel_stack* owning_stack;
   /** interested parties (owned) */
-  grpc_pollset_set *interested_parties;
+  grpc_pollset_set* interested_parties;
 
   /* external_connectivity_watcher_list head is guarded by its own mutex, since
    * counts need to be grabbed immediately without polling on a cq */
   gpr_mu external_connectivity_watcher_list_mu;
-  struct external_connectivity_watcher *external_connectivity_watcher_list_head;
+  struct external_connectivity_watcher* external_connectivity_watcher_list_head;
 
   /* the following properties are guarded by a mutex since API's require them
      to be instantaneously available */
   gpr_mu info_mu;
-  char *info_lb_policy_name;
+  char* info_lb_policy_name;
   /** service config in JSON form */
-  char *info_service_config_json;
+  char* info_service_config_json;
 } channel_data;
 
 /** We create one watcher for each new lb_policy that is returned from a
     resolver, to watch for state changes from the lb_policy. When a state
     change is seen, we update the channel, and create a new watcher. */
 typedef struct {
-  channel_data *chand;
+  channel_data* chand;
   grpc_closure on_changed;
   grpc_connectivity_state state;
-  grpc_lb_policy *lb_policy;
+  grpc_lb_policy* lb_policy;
 } lb_policy_connectivity_watcher;
 
-static void watch_lb_policy_locked(grpc_exec_ctx *exec_ctx, channel_data *chand,
-                                   grpc_lb_policy *lb_policy,
+static void watch_lb_policy_locked(grpc_exec_ctx* exec_ctx, channel_data* chand,
+                                   grpc_lb_policy* lb_policy,
                                    grpc_connectivity_state current_state);
 
-static void set_channel_connectivity_state_locked(grpc_exec_ctx *exec_ctx,
-                                                  channel_data *chand,
+static void set_channel_connectivity_state_locked(grpc_exec_ctx* exec_ctx,
+                                                  channel_data* chand,
                                                   grpc_connectivity_state state,
-                                                  grpc_error *error,
-                                                  const char *reason) {
+                                                  grpc_error* error,
+                                                  const char* reason) {
   /* TODO: Improve failure handling:
    * - Make it possible for policies to return GRPC_CHANNEL_TRANSIENT_FAILURE.
    * - Hand over pending picks from old policies during the switch that happens
    *   when resolver provides an update. */
-  if (chand->lb_policy != NULL) {
+  if (chand->lb_policy != nullptr) {
     if (state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
       /* cancel picks with wait_for_ready=false */
       grpc_lb_policy_cancel_picks_locked(
@@ -245,7 +247,7 @@ static void set_channel_connectivity_state_locked(grpc_exec_ctx *exec_ctx,
                                          GRPC_ERROR_REF(error));
     }
   }
-  if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+  if (grpc_client_channel_trace.enabled()) {
     gpr_log(GPR_DEBUG, "chand=%p: setting connectivity state to %s", chand,
             grpc_connectivity_state_name(state));
   }
@@ -253,21 +255,22 @@ static void set_channel_connectivity_state_locked(grpc_exec_ctx *exec_ctx,
                               reason);
 }
 
-static void on_lb_policy_state_changed_locked(grpc_exec_ctx *exec_ctx,
-                                              void *arg, grpc_error *error) {
-  lb_policy_connectivity_watcher *w = (lb_policy_connectivity_watcher *)arg;
+static void on_lb_policy_state_changed_locked(grpc_exec_ctx* exec_ctx,
+                                              void* arg, grpc_error* error) {
+  lb_policy_connectivity_watcher* w = (lb_policy_connectivity_watcher*)arg;
   grpc_connectivity_state publish_state = w->state;
   /* check if the notification is for the latest policy */
   if (w->lb_policy == w->chand->lb_policy) {
-    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+    if (grpc_client_channel_trace.enabled()) {
       gpr_log(GPR_DEBUG, "chand=%p: lb_policy=%p state changed to %s", w->chand,
               w->lb_policy, grpc_connectivity_state_name(w->state));
     }
-    if (publish_state == GRPC_CHANNEL_SHUTDOWN && w->chand->resolver != NULL) {
+    if (publish_state == GRPC_CHANNEL_SHUTDOWN &&
+        w->chand->resolver != nullptr) {
       publish_state = GRPC_CHANNEL_TRANSIENT_FAILURE;
       grpc_resolver_channel_saw_error_locked(exec_ctx, w->chand->resolver);
       GRPC_LB_POLICY_UNREF(exec_ctx, w->chand->lb_policy, "channel");
-      w->chand->lb_policy = NULL;
+      w->chand->lb_policy = nullptr;
     }
     set_channel_connectivity_state_locked(exec_ctx, w->chand, publish_state,
                                           GRPC_ERROR_REF(error), "lb_changed");
@@ -279,11 +282,11 @@ static void on_lb_policy_state_changed_locked(grpc_exec_ctx *exec_ctx,
   gpr_free(w);
 }
 
-static void watch_lb_policy_locked(grpc_exec_ctx *exec_ctx, channel_data *chand,
-                                   grpc_lb_policy *lb_policy,
+static void watch_lb_policy_locked(grpc_exec_ctx* exec_ctx, channel_data* chand,
+                                   grpc_lb_policy* lb_policy,
                                    grpc_connectivity_state current_state) {
-  lb_policy_connectivity_watcher *w =
-      (lb_policy_connectivity_watcher *)gpr_malloc(sizeof(*w));
+  lb_policy_connectivity_watcher* w =
+      (lb_policy_connectivity_watcher*)gpr_malloc(sizeof(*w));
   GRPC_CHANNEL_STACK_REF(chand->owning_stack, "watch_lb_policy");
   w->chand = chand;
   GRPC_CLOSURE_INIT(&w->on_changed, on_lb_policy_state_changed_locked, w,
@@ -294,9 +297,9 @@ static void watch_lb_policy_locked(grpc_exec_ctx *exec_ctx, channel_data *chand,
                                                &w->on_changed);
 }
 
-static void start_resolving_locked(grpc_exec_ctx *exec_ctx,
-                                   channel_data *chand) {
-  if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+static void start_resolving_locked(grpc_exec_ctx* exec_ctx,
+                                   channel_data* chand) {
+  if (grpc_client_channel_trace.enabled()) {
     gpr_log(GPR_DEBUG, "chand=%p: starting name resolution", chand);
   }
   GPR_ASSERT(!chand->started_resolving);
@@ -307,21 +310,21 @@ static void start_resolving_locked(grpc_exec_ctx *exec_ctx,
 }
 
 typedef struct {
-  char *server_name;
-  grpc_server_retry_throttle_data *retry_throttle_data;
+  char* server_name;
+  grpc_server_retry_throttle_data* retry_throttle_data;
 } service_config_parsing_state;
 
-static void parse_retry_throttle_params(const grpc_json *field, void *arg) {
-  service_config_parsing_state *parsing_state =
-      (service_config_parsing_state *)arg;
+static void parse_retry_throttle_params(const grpc_json* field, void* arg) {
+  service_config_parsing_state* parsing_state =
+      (service_config_parsing_state*)arg;
   if (strcmp(field->key, "retryThrottling") == 0) {
-    if (parsing_state->retry_throttle_data != NULL) return;  // Duplicate.
+    if (parsing_state->retry_throttle_data != nullptr) return;  // Duplicate.
     if (field->type != GRPC_JSON_OBJECT) return;
     int max_milli_tokens = 0;
     int milli_token_ratio = 0;
-    for (grpc_json *sub_field = field->child; sub_field != NULL;
+    for (grpc_json* sub_field = field->child; sub_field != nullptr;
          sub_field = sub_field->next) {
-      if (sub_field->key == NULL) return;
+      if (sub_field->key == nullptr) return;
       if (strcmp(sub_field->key, "maxTokens") == 0) {
         if (max_milli_tokens != 0) return;  // Duplicate.
         if (sub_field->type != GRPC_JSON_NUMBER) return;
@@ -335,8 +338,8 @@ static void parse_retry_throttle_params(const grpc_json *field, void *arg) {
         size_t whole_len = strlen(sub_field->value);
         uint32_t multiplier = 1;
         uint32_t decimal_value = 0;
-        const char *decimal_point = strchr(sub_field->value, '.');
-        if (decimal_point != NULL) {
+        const char* decimal_point = strchr(sub_field->value, '.');
+        if (decimal_point != nullptr) {
           whole_len = (size_t)(decimal_point - sub_field->value);
           multiplier = 1000;
           size_t decimal_len = strlen(decimal_point + 1);
@@ -366,27 +369,27 @@ static void parse_retry_throttle_params(const grpc_json *field, void *arg) {
   }
 }
 
-static void on_resolver_result_changed_locked(grpc_exec_ctx *exec_ctx,
-                                              void *arg, grpc_error *error) {
-  channel_data *chand = (channel_data *)arg;
-  if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+static void on_resolver_result_changed_locked(grpc_exec_ctx* exec_ctx,
+                                              void* arg, grpc_error* error) {
+  channel_data* chand = (channel_data*)arg;
+  if (grpc_client_channel_trace.enabled()) {
     gpr_log(GPR_DEBUG, "chand=%p: got resolver result: error=%s", chand,
             grpc_error_string(error));
   }
   // Extract the following fields from the resolver result, if non-NULL.
   bool lb_policy_updated = false;
-  char *lb_policy_name_dup = NULL;
+  char* lb_policy_name_dup = nullptr;
   bool lb_policy_name_changed = false;
-  grpc_lb_policy *new_lb_policy = NULL;
-  char *service_config_json = NULL;
-  grpc_server_retry_throttle_data *retry_throttle_data = NULL;
-  grpc_slice_hash_table *method_params_table = NULL;
-  if (chand->resolver_result != NULL) {
+  grpc_lb_policy* new_lb_policy = nullptr;
+  char* service_config_json = nullptr;
+  grpc_server_retry_throttle_data* retry_throttle_data = nullptr;
+  grpc_slice_hash_table* method_params_table = nullptr;
+  if (chand->resolver_result != nullptr) {
     // Find LB policy name.
-    const char *lb_policy_name = NULL;
-    const grpc_arg *channel_arg =
+    const char* lb_policy_name = nullptr;
+    const grpc_arg* channel_arg =
         grpc_channel_args_find(chand->resolver_result, GRPC_ARG_LB_POLICY_NAME);
-    if (channel_arg != NULL) {
+    if (channel_arg != nullptr) {
       GPR_ASSERT(channel_arg->type == GRPC_ARG_STRING);
       lb_policy_name = channel_arg->value.string;
     }
@@ -394,9 +397,9 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx *exec_ctx,
     // the grpclb policy, regardless of what the resolver actually specified.
     channel_arg =
         grpc_channel_args_find(chand->resolver_result, GRPC_ARG_LB_ADDRESSES);
-    if (channel_arg != NULL && channel_arg->type == GRPC_ARG_POINTER) {
-      grpc_lb_addresses *addresses =
-          (grpc_lb_addresses *)channel_arg->value.pointer.p;
+    if (channel_arg != nullptr && channel_arg->type == GRPC_ARG_POINTER) {
+      grpc_lb_addresses* addresses =
+          (grpc_lb_addresses*)channel_arg->value.pointer.p;
       bool found_balancer_address = false;
       for (size_t i = 0; i < addresses->num_addresses; ++i) {
         if (addresses->addresses[i].is_balancer) {
@@ -405,7 +408,8 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx *exec_ctx,
         }
       }
       if (found_balancer_address) {
-        if (lb_policy_name != NULL && strcmp(lb_policy_name, "grpclb") != 0) {
+        if (lb_policy_name != nullptr &&
+            strcmp(lb_policy_name, "grpclb") != 0) {
           gpr_log(GPR_INFO,
                   "resolver requested LB policy %s but provided at least one "
                   "balancer address -- forcing use of grpclb LB policy",
@@ -416,7 +420,7 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx *exec_ctx,
     }
     // Use pick_first if nothing was specified and we didn't select grpclb
     // above.
-    if (lb_policy_name == NULL) lb_policy_name = "pick_first";
+    if (lb_policy_name == nullptr) lb_policy_name = "pick_first";
     grpc_lb_policy_args lb_policy_args;
     lb_policy_args.args = chand->resolver_result;
     lb_policy_args.client_channel_factory = chand->client_channel_factory;
@@ -427,9 +431,9 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx *exec_ctx,
     // only thing that modifies its value, and it can only be invoked
     // once at any given time.
     lb_policy_name_changed =
-        chand->info_lb_policy_name == NULL ||
+        chand->info_lb_policy_name == nullptr ||
         strcmp(chand->info_lb_policy_name, lb_policy_name) != 0;
-    if (chand->lb_policy != NULL && !lb_policy_name_changed) {
+    if (chand->lb_policy != nullptr && !lb_policy_name_changed) {
       // Continue using the same LB policy.  Update with new addresses.
       lb_policy_updated = true;
       grpc_lb_policy_update_locked(exec_ctx, chand->lb_policy, &lb_policy_args);
@@ -437,24 +441,24 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx *exec_ctx,
       // Instantiate new LB policy.
       new_lb_policy =
           grpc_lb_policy_create(exec_ctx, lb_policy_name, &lb_policy_args);
-      if (new_lb_policy == NULL) {
+      if (new_lb_policy == nullptr) {
         gpr_log(GPR_ERROR, "could not create LB policy \"%s\"", lb_policy_name);
       }
     }
     // Find service config.
     channel_arg =
         grpc_channel_args_find(chand->resolver_result, GRPC_ARG_SERVICE_CONFIG);
-    if (channel_arg != NULL) {
+    if (channel_arg != nullptr) {
       GPR_ASSERT(channel_arg->type == GRPC_ARG_STRING);
       service_config_json = gpr_strdup(channel_arg->value.string);
-      grpc_service_config *service_config =
+      grpc_service_config* service_config =
           grpc_service_config_create(service_config_json);
-      if (service_config != NULL) {
+      if (service_config != nullptr) {
         channel_arg =
             grpc_channel_args_find(chand->resolver_result, GRPC_ARG_SERVER_URI);
-        GPR_ASSERT(channel_arg != NULL);
+        GPR_ASSERT(channel_arg != nullptr);
         GPR_ASSERT(channel_arg->type == GRPC_ARG_STRING);
-        grpc_uri *uri =
+        grpc_uri* uri =
             grpc_uri_parse(exec_ctx, channel_arg->value.string, true);
         GPR_ASSERT(uri->path[0] != '\0');
         service_config_parsing_state parsing_state;
@@ -467,7 +471,7 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx *exec_ctx,
         retry_throttle_data = parsing_state.retry_throttle_data;
         method_params_table = grpc_service_config_create_method_config_table(
             exec_ctx, service_config, method_parameters_create_from_json,
-            method_parameters_free);
+            method_parameters_ref_wrapper, method_parameters_unref_wrapper);
         grpc_service_config_destroy(service_config);
       }
     }
@@ -476,9 +480,9 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx *exec_ctx,
     // The copy will be saved in chand->lb_policy_name below.
     lb_policy_name_dup = gpr_strdup(lb_policy_name);
     grpc_channel_args_destroy(exec_ctx, chand->resolver_result);
-    chand->resolver_result = NULL;
+    chand->resolver_result = nullptr;
   }
-  if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+  if (grpc_client_channel_trace.enabled()) {
     gpr_log(GPR_DEBUG,
             "chand=%p: resolver result: lb_policy_name=\"%s\"%s, "
             "service_config=\"%s\"",
@@ -491,22 +495,22 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx *exec_ctx,
   //
   // First, swap out the data used by cc_get_channel_info().
   gpr_mu_lock(&chand->info_mu);
-  if (lb_policy_name_dup != NULL) {
+  if (lb_policy_name_dup != nullptr) {
     gpr_free(chand->info_lb_policy_name);
     chand->info_lb_policy_name = lb_policy_name_dup;
   }
-  if (service_config_json != NULL) {
+  if (service_config_json != nullptr) {
     gpr_free(chand->info_service_config_json);
     chand->info_service_config_json = service_config_json;
   }
   gpr_mu_unlock(&chand->info_mu);
   // Swap out the retry throttle data.
-  if (chand->retry_throttle_data != NULL) {
+  if (chand->retry_throttle_data != nullptr) {
     grpc_server_retry_throttle_data_unref(chand->retry_throttle_data);
   }
   chand->retry_throttle_data = retry_throttle_data;
   // Swap out the method params table.
-  if (chand->method_params_table != NULL) {
+  if (chand->method_params_table != nullptr) {
     grpc_slice_hash_table_unref(exec_ctx, chand->method_params_table);
   }
   chand->method_params_table = method_params_table;
@@ -516,10 +520,10 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx *exec_ctx,
   // Note that we do NOT do this if either (a) we updated the existing
   // LB policy above or (b) we failed to create the new LB policy (in
   // which case we want to continue using the most recent one we had).
-  if (new_lb_policy != NULL || error != GRPC_ERROR_NONE ||
-      chand->resolver == NULL) {
-    if (chand->lb_policy != NULL) {
-      if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+  if (new_lb_policy != nullptr || error != GRPC_ERROR_NONE ||
+      chand->resolver == nullptr) {
+    if (chand->lb_policy != nullptr) {
+      if (grpc_client_channel_trace.enabled()) {
         gpr_log(GPR_DEBUG, "chand=%p: unreffing lb_policy=%p", chand,
                 chand->lb_policy);
       }
@@ -532,17 +536,17 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx *exec_ctx,
   }
   // Now that we've swapped out the relevant fields of chand, check for
   // error or shutdown.
-  if (error != GRPC_ERROR_NONE || chand->resolver == NULL) {
-    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+  if (error != GRPC_ERROR_NONE || chand->resolver == nullptr) {
+    if (grpc_client_channel_trace.enabled()) {
       gpr_log(GPR_DEBUG, "chand=%p: shutting down", chand);
     }
-    if (chand->resolver != NULL) {
-      if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+    if (chand->resolver != nullptr) {
+      if (grpc_client_channel_trace.enabled()) {
         gpr_log(GPR_DEBUG, "chand=%p: shutting down resolver", chand);
       }
       grpc_resolver_shutdown_locked(exec_ctx, chand->resolver);
       GRPC_RESOLVER_UNREF(exec_ctx, chand->resolver, "channel");
-      chand->resolver = NULL;
+      chand->resolver = nullptr;
     }
     set_channel_connectivity_state_locked(
         exec_ctx, chand, GRPC_CHANNEL_SHUTDOWN,
@@ -557,10 +561,10 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx *exec_ctx,
                             &chand->waiting_for_resolver_result_closures);
   } else {  // Not shutting down.
     grpc_connectivity_state state = GRPC_CHANNEL_TRANSIENT_FAILURE;
-    grpc_error *state_error =
+    grpc_error* state_error =
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("No load balancing policy");
-    if (new_lb_policy != NULL) {
-      if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+    if (new_lb_policy != nullptr) {
+      if (grpc_client_channel_trace.enabled()) {
         gpr_log(GPR_DEBUG, "chand=%p: initializing new LB policy", chand);
       }
       GRPC_ERROR_UNREF(state_error);
@@ -589,53 +593,53 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx *exec_ctx,
   }
 }
 
-static void start_transport_op_locked(grpc_exec_ctx *exec_ctx, void *arg,
-                                      grpc_error *error_ignored) {
-  grpc_transport_op *op = (grpc_transport_op *)arg;
-  grpc_channel_element *elem =
-      (grpc_channel_element *)op->handler_private.extra_arg;
-  channel_data *chand = (channel_data *)elem->channel_data;
+static void start_transport_op_locked(grpc_exec_ctx* exec_ctx, void* arg,
+                                      grpc_error* error_ignored) {
+  grpc_transport_op* op = (grpc_transport_op*)arg;
+  grpc_channel_element* elem =
+      (grpc_channel_element*)op->handler_private.extra_arg;
+  channel_data* chand = (channel_data*)elem->channel_data;
 
-  if (op->on_connectivity_state_change != NULL) {
+  if (op->on_connectivity_state_change != nullptr) {
     grpc_connectivity_state_notify_on_state_change(
         exec_ctx, &chand->state_tracker, op->connectivity_state,
         op->on_connectivity_state_change);
-    op->on_connectivity_state_change = NULL;
-    op->connectivity_state = NULL;
+    op->on_connectivity_state_change = nullptr;
+    op->connectivity_state = nullptr;
   }
 
-  if (op->send_ping != NULL) {
-    if (chand->lb_policy == NULL) {
+  if (op->send_ping != nullptr) {
+    if (chand->lb_policy == nullptr) {
       GRPC_CLOSURE_SCHED(
           exec_ctx, op->send_ping,
           GRPC_ERROR_CREATE_FROM_STATIC_STRING("Ping with no load balancing"));
     } else {
       grpc_lb_policy_ping_one_locked(exec_ctx, chand->lb_policy, op->send_ping);
-      op->bind_pollset = NULL;
+      op->bind_pollset = nullptr;
     }
-    op->send_ping = NULL;
+    op->send_ping = nullptr;
   }
 
   if (op->disconnect_with_error != GRPC_ERROR_NONE) {
-    if (chand->resolver != NULL) {
+    if (chand->resolver != nullptr) {
       set_channel_connectivity_state_locked(
           exec_ctx, chand, GRPC_CHANNEL_SHUTDOWN,
           GRPC_ERROR_REF(op->disconnect_with_error), "disconnect");
       grpc_resolver_shutdown_locked(exec_ctx, chand->resolver);
       GRPC_RESOLVER_UNREF(exec_ctx, chand->resolver, "channel");
-      chand->resolver = NULL;
+      chand->resolver = nullptr;
       if (!chand->started_resolving) {
         grpc_closure_list_fail_all(&chand->waiting_for_resolver_result_closures,
                                    GRPC_ERROR_REF(op->disconnect_with_error));
         GRPC_CLOSURE_LIST_SCHED(exec_ctx,
                                 &chand->waiting_for_resolver_result_closures);
       }
-      if (chand->lb_policy != NULL) {
+      if (chand->lb_policy != nullptr) {
         grpc_pollset_set_del_pollset_set(exec_ctx,
                                          chand->lb_policy->interested_parties,
                                          chand->interested_parties);
         GRPC_LB_POLICY_UNREF(exec_ctx, chand->lb_policy, "channel");
-        chand->lb_policy = NULL;
+        chand->lb_policy = nullptr;
       }
     }
     GRPC_ERROR_UNREF(op->disconnect_with_error);
@@ -645,13 +649,13 @@ static void start_transport_op_locked(grpc_exec_ctx *exec_ctx, void *arg,
   GRPC_CLOSURE_SCHED(exec_ctx, op->on_consumed, GRPC_ERROR_NONE);
 }
 
-static void cc_start_transport_op(grpc_exec_ctx *exec_ctx,
-                                  grpc_channel_element *elem,
-                                  grpc_transport_op *op) {
-  channel_data *chand = (channel_data *)elem->channel_data;
+static void cc_start_transport_op(grpc_exec_ctx* exec_ctx,
+                                  grpc_channel_element* elem,
+                                  grpc_transport_op* op) {
+  channel_data* chand = (channel_data*)elem->channel_data;
 
   GPR_ASSERT(op->set_accept_stream == false);
-  if (op->bind_pollset != NULL) {
+  if (op->bind_pollset != nullptr) {
     grpc_pollset_set_add_pollset(exec_ctx, chand->interested_parties,
                                  op->bind_pollset);
   }
@@ -665,30 +669,30 @@ static void cc_start_transport_op(grpc_exec_ctx *exec_ctx,
       GRPC_ERROR_NONE);
 }
 
-static void cc_get_channel_info(grpc_exec_ctx *exec_ctx,
-                                grpc_channel_element *elem,
-                                const grpc_channel_info *info) {
-  channel_data *chand = (channel_data *)elem->channel_data;
+static void cc_get_channel_info(grpc_exec_ctx* exec_ctx,
+                                grpc_channel_element* elem,
+                                const grpc_channel_info* info) {
+  channel_data* chand = (channel_data*)elem->channel_data;
   gpr_mu_lock(&chand->info_mu);
-  if (info->lb_policy_name != NULL) {
-    *info->lb_policy_name = chand->info_lb_policy_name == NULL
-                                ? NULL
+  if (info->lb_policy_name != nullptr) {
+    *info->lb_policy_name = chand->info_lb_policy_name == nullptr
+                                ? nullptr
                                 : gpr_strdup(chand->info_lb_policy_name);
   }
-  if (info->service_config_json != NULL) {
+  if (info->service_config_json != nullptr) {
     *info->service_config_json =
-        chand->info_service_config_json == NULL
-            ? NULL
+        chand->info_service_config_json == nullptr
+            ? nullptr
             : gpr_strdup(chand->info_service_config_json);
   }
   gpr_mu_unlock(&chand->info_mu);
 }
 
 /* Constructor for channel_data */
-static grpc_error *cc_init_channel_elem(grpc_exec_ctx *exec_ctx,
-                                        grpc_channel_element *elem,
-                                        grpc_channel_element_args *args) {
-  channel_data *chand = (channel_data *)elem->channel_data;
+static grpc_error* cc_init_channel_elem(grpc_exec_ctx* exec_ctx,
+                                        grpc_channel_element* elem,
+                                        grpc_channel_element_args* args) {
+  channel_data* chand = (channel_data*)elem->channel_data;
   GPR_ASSERT(args->is_last);
   GPR_ASSERT(elem->filter == &grpc_client_channel_filter);
   // Initialize data members.
@@ -697,7 +701,7 @@ static grpc_error *cc_init_channel_elem(grpc_exec_ctx *exec_ctx,
   gpr_mu_init(&chand->external_connectivity_watcher_list_mu);
 
   gpr_mu_lock(&chand->external_connectivity_watcher_list_mu);
-  chand->external_connectivity_watcher_list_head = NULL;
+  chand->external_connectivity_watcher_list_head = nullptr;
   gpr_mu_unlock(&chand->external_connectivity_watcher_list_mu);
 
   chand->owning_stack = args->channel_stack;
@@ -707,10 +711,11 @@ static grpc_error *cc_init_channel_elem(grpc_exec_ctx *exec_ctx,
   chand->interested_parties = grpc_pollset_set_create();
   grpc_connectivity_state_init(&chand->state_tracker, GRPC_CHANNEL_IDLE,
                                "client_channel");
+  grpc_client_channel_start_backup_polling(exec_ctx, chand->interested_parties);
   // Record client channel factory.
-  const grpc_arg *arg = grpc_channel_args_find(args->channel_args,
+  const grpc_arg* arg = grpc_channel_args_find(args->channel_args,
                                                GRPC_ARG_CLIENT_CHANNEL_FACTORY);
-  if (arg == NULL) {
+  if (arg == nullptr) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Missing client channel factory in args for client channel filter");
   }
@@ -719,12 +724,12 @@ static grpc_error *cc_init_channel_elem(grpc_exec_ctx *exec_ctx,
         "client channel factory arg must be a pointer");
   }
   grpc_client_channel_factory_ref(
-      (grpc_client_channel_factory *)arg->value.pointer.p);
+      (grpc_client_channel_factory*)arg->value.pointer.p);
   chand->client_channel_factory =
-      (grpc_client_channel_factory *)arg->value.pointer.p;
+      (grpc_client_channel_factory*)arg->value.pointer.p;
   // Get server name to resolve, using proxy mapper if needed.
   arg = grpc_channel_args_find(args->channel_args, GRPC_ARG_SERVER_URI);
-  if (arg == NULL) {
+  if (arg == nullptr) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Missing server uri in args for client channel filter");
   }
@@ -732,18 +737,18 @@ static grpc_error *cc_init_channel_elem(grpc_exec_ctx *exec_ctx,
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "server uri arg must be a string");
   }
-  char *proxy_name = NULL;
-  grpc_channel_args *new_args = NULL;
+  char* proxy_name = nullptr;
+  grpc_channel_args* new_args = nullptr;
   grpc_proxy_mappers_map_name(exec_ctx, arg->value.string, args->channel_args,
                               &proxy_name, &new_args);
   // Instantiate resolver.
   chand->resolver = grpc_resolver_create(
-      exec_ctx, proxy_name != NULL ? proxy_name : arg->value.string,
-      new_args != NULL ? new_args : args->channel_args,
+      exec_ctx, proxy_name != nullptr ? proxy_name : arg->value.string,
+      new_args != nullptr ? new_args : args->channel_args,
       chand->interested_parties, chand->combiner);
-  if (proxy_name != NULL) gpr_free(proxy_name);
-  if (new_args != NULL) grpc_channel_args_destroy(exec_ctx, new_args);
-  if (chand->resolver == NULL) {
+  if (proxy_name != nullptr) gpr_free(proxy_name);
+  if (new_args != nullptr) grpc_channel_args_destroy(exec_ctx, new_args);
+  if (chand->resolver == nullptr) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("resolver creation failed");
   }
   chand->deadline_checking_enabled =
@@ -751,27 +756,28 @@ static grpc_error *cc_init_channel_elem(grpc_exec_ctx *exec_ctx,
   return GRPC_ERROR_NONE;
 }
 
-static void shutdown_resolver_locked(grpc_exec_ctx *exec_ctx, void *arg,
-                                     grpc_error *error) {
-  grpc_resolver *resolver = (grpc_resolver *)arg;
+static void shutdown_resolver_locked(grpc_exec_ctx* exec_ctx, void* arg,
+                                     grpc_error* error) {
+  grpc_resolver* resolver = (grpc_resolver*)arg;
   grpc_resolver_shutdown_locked(exec_ctx, resolver);
   GRPC_RESOLVER_UNREF(exec_ctx, resolver, "channel");
 }
 
 /* Destructor for channel_data */
-static void cc_destroy_channel_elem(grpc_exec_ctx *exec_ctx,
-                                    grpc_channel_element *elem) {
-  channel_data *chand = (channel_data *)elem->channel_data;
-  if (chand->resolver != NULL) {
+static void cc_destroy_channel_elem(grpc_exec_ctx* exec_ctx,
+                                    grpc_channel_element* elem) {
+  channel_data* chand = (channel_data*)elem->channel_data;
+  if (chand->resolver != nullptr) {
     GRPC_CLOSURE_SCHED(
-        exec_ctx, GRPC_CLOSURE_CREATE(shutdown_resolver_locked, chand->resolver,
-                                      grpc_combiner_scheduler(chand->combiner)),
+        exec_ctx,
+        GRPC_CLOSURE_CREATE(shutdown_resolver_locked, chand->resolver,
+                            grpc_combiner_scheduler(chand->combiner)),
         GRPC_ERROR_NONE);
   }
-  if (chand->client_channel_factory != NULL) {
+  if (chand->client_channel_factory != nullptr) {
     grpc_client_channel_factory_unref(exec_ctx, chand->client_channel_factory);
   }
-  if (chand->lb_policy != NULL) {
+  if (chand->lb_policy != nullptr) {
     grpc_pollset_set_del_pollset_set(exec_ctx,
                                      chand->lb_policy->interested_parties,
                                      chand->interested_parties);
@@ -779,12 +785,13 @@ static void cc_destroy_channel_elem(grpc_exec_ctx *exec_ctx,
   }
   gpr_free(chand->info_lb_policy_name);
   gpr_free(chand->info_service_config_json);
-  if (chand->retry_throttle_data != NULL) {
+  if (chand->retry_throttle_data != nullptr) {
     grpc_server_retry_throttle_data_unref(chand->retry_throttle_data);
   }
-  if (chand->method_params_table != NULL) {
+  if (chand->method_params_table != nullptr) {
     grpc_slice_hash_table_unref(exec_ctx, chand->method_params_table);
   }
+  grpc_client_channel_stop_backup_polling(exec_ctx, chand->interested_parties);
   grpc_connectivity_state_destroy(exec_ctx, &chand->state_tracker);
   grpc_pollset_set_destroy(exec_ctx, chand->interested_parties);
   GRPC_COMBINER_UNREF(exec_ctx, chand->combiner, "client_channel");
@@ -823,48 +830,48 @@ typedef struct client_channel_call_data {
 
   grpc_slice path;  // Request path.
   gpr_timespec call_start_time;
-  gpr_timespec deadline;
-  gpr_arena *arena;
-  grpc_call_stack *owning_call;
-  grpc_call_combiner *call_combiner;
+  grpc_millis deadline;
+  gpr_arena* arena;
+  grpc_call_stack* owning_call;
+  grpc_call_combiner* call_combiner;
 
-  grpc_server_retry_throttle_data *retry_throttle_data;
-  method_parameters *method_params;
+  grpc_server_retry_throttle_data* retry_throttle_data;
+  method_parameters* method_params;
 
-  grpc_subchannel_call *subchannel_call;
-  grpc_error *error;
+  grpc_subchannel_call* subchannel_call;
+  grpc_error* error;
 
-  grpc_lb_policy *lb_policy;  // Holds ref while LB pick is pending.
+  grpc_lb_policy* lb_policy;  // Holds ref while LB pick is pending.
   grpc_closure lb_pick_closure;
   grpc_closure lb_pick_cancel_closure;
 
-  grpc_connected_subchannel *connected_subchannel;
+  grpc_connected_subchannel* connected_subchannel;
   grpc_call_context_element subchannel_call_context[GRPC_CONTEXT_COUNT];
-  grpc_polling_entity *pollent;
+  grpc_polling_entity* pollent;
 
-  grpc_transport_stream_op_batch *waiting_for_pick_batches[MAX_WAITING_BATCHES];
+  grpc_transport_stream_op_batch* waiting_for_pick_batches[MAX_WAITING_BATCHES];
   size_t waiting_for_pick_batches_count;
   grpc_closure handle_pending_batch_in_call_combiner[MAX_WAITING_BATCHES];
 
-  grpc_transport_stream_op_batch *initial_metadata_batch;
+  grpc_transport_stream_op_batch* initial_metadata_batch;
 
   grpc_linked_mdelem lb_token_mdelem;
 
   grpc_closure on_complete;
-  grpc_closure *original_on_complete;
+  grpc_closure* original_on_complete;
 } call_data;
 
-grpc_subchannel_call *grpc_client_channel_get_subchannel_call(
-    grpc_call_element *elem) {
-  call_data *calld = (call_data *)elem->call_data;
+grpc_subchannel_call* grpc_client_channel_get_subchannel_call(
+    grpc_call_element* elem) {
+  call_data* calld = (call_data*)elem->call_data;
   return calld->subchannel_call;
 }
 
 // This is called via the call combiner, so access to calld is synchronized.
 static void waiting_for_pick_batches_add(
-    call_data *calld, grpc_transport_stream_op_batch *batch) {
+    call_data* calld, grpc_transport_stream_op_batch* batch) {
   if (batch->send_initial_metadata) {
-    GPR_ASSERT(calld->initial_metadata_batch == NULL);
+    GPR_ASSERT(calld->initial_metadata_batch == nullptr);
     calld->initial_metadata_batch = batch;
   } else {
     GPR_ASSERT(calld->waiting_for_pick_batches_count < MAX_WAITING_BATCHES);
@@ -874,9 +881,9 @@ static void waiting_for_pick_batches_add(
 }
 
 // This is called via the call combiner, so access to calld is synchronized.
-static void fail_pending_batch_in_call_combiner(grpc_exec_ctx *exec_ctx,
-                                                void *arg, grpc_error *error) {
-  call_data *calld = (call_data *)arg;
+static void fail_pending_batch_in_call_combiner(grpc_exec_ctx* exec_ctx,
+                                                void* arg, grpc_error* error) {
+  call_data* calld = (call_data*)arg;
   if (calld->waiting_for_pick_batches_count > 0) {
     --calld->waiting_for_pick_batches_count;
     grpc_transport_stream_op_batch_finish_with_failure(
@@ -887,13 +894,13 @@ static void fail_pending_batch_in_call_combiner(grpc_exec_ctx *exec_ctx,
 }
 
 // This is called via the call combiner, so access to calld is synchronized.
-static void waiting_for_pick_batches_fail(grpc_exec_ctx *exec_ctx,
-                                          grpc_call_element *elem,
-                                          grpc_error *error) {
-  call_data *calld = (call_data *)elem->call_data;
-  if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+static void waiting_for_pick_batches_fail(grpc_exec_ctx* exec_ctx,
+                                          grpc_call_element* elem,
+                                          grpc_error* error) {
+  call_data* calld = (call_data*)elem->call_data;
+  if (grpc_client_channel_trace.enabled()) {
     gpr_log(GPR_DEBUG,
-            "chand=%p calld=%p: failing %" PRIdPTR " pending batches: %s",
+            "chand=%p calld=%p: failing %" PRIuPTR " pending batches: %s",
             elem->channel_data, calld, calld->waiting_for_pick_batches_count,
             grpc_error_string(error));
   }
@@ -906,7 +913,7 @@ static void waiting_for_pick_batches_fail(grpc_exec_ctx *exec_ctx,
                              GRPC_ERROR_REF(error),
                              "waiting_for_pick_batches_fail");
   }
-  if (calld->initial_metadata_batch != NULL) {
+  if (calld->initial_metadata_batch != nullptr) {
     grpc_transport_stream_op_batch_finish_with_failure(
         exec_ctx, calld->initial_metadata_batch, GRPC_ERROR_REF(error),
         calld->call_combiner);
@@ -918,9 +925,9 @@ static void waiting_for_pick_batches_fail(grpc_exec_ctx *exec_ctx,
 }
 
 // This is called via the call combiner, so access to calld is synchronized.
-static void run_pending_batch_in_call_combiner(grpc_exec_ctx *exec_ctx,
-                                               void *arg, grpc_error *ignored) {
-  call_data *calld = (call_data *)arg;
+static void run_pending_batch_in_call_combiner(grpc_exec_ctx* exec_ctx,
+                                               void* arg, grpc_error* ignored) {
+  call_data* calld = (call_data*)arg;
   if (calld->waiting_for_pick_batches_count > 0) {
     --calld->waiting_for_pick_batches_count;
     grpc_subchannel_call_process_op(
@@ -930,13 +937,14 @@ static void run_pending_batch_in_call_combiner(grpc_exec_ctx *exec_ctx,
 }
 
 // This is called via the call combiner, so access to calld is synchronized.
-static void waiting_for_pick_batches_resume(grpc_exec_ctx *exec_ctx,
-                                            grpc_call_element *elem) {
-  channel_data *chand = (channel_data *)elem->channel_data;
-  call_data *calld = (call_data *)elem->call_data;
-  if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
-    gpr_log(GPR_DEBUG, "chand=%p calld=%p: sending %" PRIdPTR
-                       " pending batches to subchannel_call=%p",
+static void waiting_for_pick_batches_resume(grpc_exec_ctx* exec_ctx,
+                                            grpc_call_element* elem) {
+  channel_data* chand = (channel_data*)elem->channel_data;
+  call_data* calld = (call_data*)elem->call_data;
+  if (grpc_client_channel_trace.enabled()) {
+    gpr_log(GPR_DEBUG,
+            "chand=%p calld=%p: sending %" PRIuPTR
+            " pending batches to subchannel_call=%p",
             chand, calld, calld->waiting_for_pick_batches_count,
             calld->subchannel_call);
   }
@@ -949,38 +957,38 @@ static void waiting_for_pick_batches_resume(grpc_exec_ctx *exec_ctx,
                              GRPC_ERROR_NONE,
                              "waiting_for_pick_batches_resume");
   }
-  GPR_ASSERT(calld->initial_metadata_batch != NULL);
+  GPR_ASSERT(calld->initial_metadata_batch != nullptr);
   grpc_subchannel_call_process_op(exec_ctx, calld->subchannel_call,
                                   calld->initial_metadata_batch);
 }
 
 // Applies service config to the call.  Must be invoked once we know
 // that the resolver has returned results to the channel.
-static void apply_service_config_to_call_locked(grpc_exec_ctx *exec_ctx,
-                                                grpc_call_element *elem) {
-  channel_data *chand = (channel_data *)elem->channel_data;
-  call_data *calld = (call_data *)elem->call_data;
-  if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+static void apply_service_config_to_call_locked(grpc_exec_ctx* exec_ctx,
+                                                grpc_call_element* elem) {
+  channel_data* chand = (channel_data*)elem->channel_data;
+  call_data* calld = (call_data*)elem->call_data;
+  if (grpc_client_channel_trace.enabled()) {
     gpr_log(GPR_DEBUG, "chand=%p calld=%p: applying service config to call",
             chand, calld);
   }
-  if (chand->retry_throttle_data != NULL) {
+  if (chand->retry_throttle_data != nullptr) {
     calld->retry_throttle_data =
         grpc_server_retry_throttle_data_ref(chand->retry_throttle_data);
   }
-  if (chand->method_params_table != NULL) {
-    calld->method_params = (method_parameters *)grpc_method_config_table_get(
+  if (chand->method_params_table != nullptr) {
+    calld->method_params = (method_parameters*)grpc_method_config_table_get(
         exec_ctx, chand->method_params_table, calld->path);
-    if (calld->method_params != NULL) {
+    if (calld->method_params != nullptr) {
       method_parameters_ref(calld->method_params);
       // If the deadline from the service config is shorter than the one
       // from the client API, reset the deadline timer.
       if (chand->deadline_checking_enabled &&
-          gpr_time_cmp(calld->method_params->timeout,
-                       gpr_time_0(GPR_TIMESPAN)) != 0) {
-        const gpr_timespec per_method_deadline =
-            gpr_time_add(calld->call_start_time, calld->method_params->timeout);
-        if (gpr_time_cmp(per_method_deadline, calld->deadline) < 0) {
+          calld->method_params->timeout != 0) {
+        const grpc_millis per_method_deadline =
+            grpc_timespec_to_millis_round_up(calld->call_start_time) +
+            calld->method_params->timeout;
+        if (per_method_deadline < calld->deadline) {
           calld->deadline = per_method_deadline;
           grpc_deadline_state_reset(exec_ctx, elem, calld->deadline);
         }
@@ -989,23 +997,24 @@ static void apply_service_config_to_call_locked(grpc_exec_ctx *exec_ctx,
   }
 }
 
-static void create_subchannel_call_locked(grpc_exec_ctx *exec_ctx,
-                                          grpc_call_element *elem,
-                                          grpc_error *error) {
-  channel_data *chand = (channel_data *)elem->channel_data;
-  call_data *calld = (call_data *)elem->call_data;
+static void create_subchannel_call_locked(grpc_exec_ctx* exec_ctx,
+                                          grpc_call_element* elem,
+                                          grpc_error* error) {
+  channel_data* chand = (channel_data*)elem->channel_data;
+  call_data* calld = (call_data*)elem->call_data;
   const grpc_connected_subchannel_call_args call_args = {
-      .pollent = calld->pollent,
-      .path = calld->path,
-      .start_time = calld->call_start_time,
-      .deadline = calld->deadline,
-      .arena = calld->arena,
-      .context = calld->subchannel_call_context,
-      .call_combiner = calld->call_combiner};
-  grpc_error *new_error = grpc_connected_subchannel_create_call(
+      calld->pollent,                  // pollent
+      calld->path,                     // path
+      calld->call_start_time,          // start_time
+      calld->deadline,                 // deadline
+      calld->arena,                    // arena
+      calld->subchannel_call_context,  // context
+      calld->call_combiner             // call_combiner
+  };
+  grpc_error* new_error = grpc_connected_subchannel_create_call(
       exec_ctx, calld->connected_subchannel, &call_args,
       &calld->subchannel_call);
-  if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+  if (grpc_client_channel_trace.enabled()) {
     gpr_log(GPR_DEBUG, "chand=%p calld=%p: create subchannel_call=%p: error=%s",
             chand, calld, calld->subchannel_call, grpc_error_string(new_error));
   }
@@ -1019,11 +1028,11 @@ static void create_subchannel_call_locked(grpc_exec_ctx *exec_ctx,
 }
 
 // Invoked when a pick is completed, on both success or failure.
-static void pick_done_locked(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-                             grpc_error *error) {
-  call_data *calld = (call_data *)elem->call_data;
-  channel_data *chand = (channel_data *)elem->channel_data;
-  if (calld->connected_subchannel == NULL) {
+static void pick_done_locked(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+                             grpc_error* error) {
+  call_data* calld = (call_data*)elem->call_data;
+  channel_data* chand = (channel_data*)elem->channel_data;
+  if (calld->connected_subchannel == nullptr) {
     // Failed to create subchannel.
     GRPC_ERROR_UNREF(calld->error);
     calld->error = error == GRPC_ERROR_NONE
@@ -1031,7 +1040,7 @@ static void pick_done_locked(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
                              "Call dropped by load balancing policy")
                        : GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                              "Failed to create subchannel", &error, 1);
-    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+    if (grpc_client_channel_trace.enabled()) {
       gpr_log(GPR_DEBUG,
               "chand=%p calld=%p: failed to create subchannel: error=%s", chand,
               calld, grpc_error_string(calld->error));
@@ -1048,10 +1057,10 @@ static void pick_done_locked(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
 // either (a) the pick was deferred pending a resolver result or (b) the
 // pick was done asynchronously.  Removes the call's polling entity from
 // chand->interested_parties before invoking pick_done_locked().
-static void async_pick_done_locked(grpc_exec_ctx *exec_ctx,
-                                   grpc_call_element *elem, grpc_error *error) {
-  channel_data *chand = (channel_data *)elem->channel_data;
-  call_data *calld = (call_data *)elem->call_data;
+static void async_pick_done_locked(grpc_exec_ctx* exec_ctx,
+                                   grpc_call_element* elem, grpc_error* error) {
+  channel_data* chand = (channel_data*)elem->channel_data;
+  call_data* calld = (call_data*)elem->call_data;
   grpc_polling_entity_del_from_pollset_set(exec_ctx, calld->pollent,
                                            chand->interested_parties);
   pick_done_locked(exec_ctx, elem, error);
@@ -1059,13 +1068,13 @@ static void async_pick_done_locked(grpc_exec_ctx *exec_ctx,
 
 // Note: This runs under the client_channel combiner, but will NOT be
 // holding the call combiner.
-static void pick_callback_cancel_locked(grpc_exec_ctx *exec_ctx, void *arg,
-                                        grpc_error *error) {
-  grpc_call_element *elem = (grpc_call_element *)arg;
-  channel_data *chand = (channel_data *)elem->channel_data;
-  call_data *calld = (call_data *)elem->call_data;
-  if (calld->lb_policy != NULL) {
-    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+static void pick_callback_cancel_locked(grpc_exec_ctx* exec_ctx, void* arg,
+                                        grpc_error* error) {
+  grpc_call_element* elem = (grpc_call_element*)arg;
+  channel_data* chand = (channel_data*)elem->channel_data;
+  call_data* calld = (call_data*)elem->call_data;
+  if (calld->lb_policy != nullptr) {
+    if (grpc_client_channel_trace.enabled()) {
       gpr_log(GPR_DEBUG, "chand=%p calld=%p: cancelling pick from LB policy %p",
               chand, calld, calld->lb_policy);
     }
@@ -1078,29 +1087,29 @@ static void pick_callback_cancel_locked(grpc_exec_ctx *exec_ctx, void *arg,
 
 // Callback invoked by grpc_lb_policy_pick_locked() for async picks.
 // Unrefs the LB policy and invokes async_pick_done_locked().
-static void pick_callback_done_locked(grpc_exec_ctx *exec_ctx, void *arg,
-                                      grpc_error *error) {
-  grpc_call_element *elem = (grpc_call_element *)arg;
-  channel_data *chand = (channel_data *)elem->channel_data;
-  call_data *calld = (call_data *)elem->call_data;
-  if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+static void pick_callback_done_locked(grpc_exec_ctx* exec_ctx, void* arg,
+                                      grpc_error* error) {
+  grpc_call_element* elem = (grpc_call_element*)arg;
+  channel_data* chand = (channel_data*)elem->channel_data;
+  call_data* calld = (call_data*)elem->call_data;
+  if (grpc_client_channel_trace.enabled()) {
     gpr_log(GPR_DEBUG, "chand=%p calld=%p: pick completed asynchronously",
             chand, calld);
   }
-  GPR_ASSERT(calld->lb_policy != NULL);
+  GPR_ASSERT(calld->lb_policy != nullptr);
   GRPC_LB_POLICY_UNREF(exec_ctx, calld->lb_policy, "pick_subchannel");
-  calld->lb_policy = NULL;
+  calld->lb_policy = nullptr;
   async_pick_done_locked(exec_ctx, elem, GRPC_ERROR_REF(error));
 }
 
 // Takes a ref to chand->lb_policy and calls grpc_lb_policy_pick_locked().
 // If the pick was completed synchronously, unrefs the LB policy and
 // returns true.
-static bool pick_callback_start_locked(grpc_exec_ctx *exec_ctx,
-                                       grpc_call_element *elem) {
-  channel_data *chand = (channel_data *)elem->channel_data;
-  call_data *calld = (call_data *)elem->call_data;
-  if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+static bool pick_callback_start_locked(grpc_exec_ctx* exec_ctx,
+                                       grpc_call_element* elem) {
+  channel_data* chand = (channel_data*)elem->channel_data;
+  call_data* calld = (call_data*)elem->call_data;
+  if (grpc_client_channel_trace.enabled()) {
     gpr_log(GPR_DEBUG, "chand=%p calld=%p: starting pick on lb_policy=%p",
             chand, calld, chand->lb_policy);
   }
@@ -1115,7 +1124,7 @@ static bool pick_callback_start_locked(grpc_exec_ctx *exec_ctx,
       initial_metadata_flags &
       GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET;
   const bool wait_for_ready_set_from_service_config =
-      calld->method_params != NULL &&
+      calld->method_params != nullptr &&
       calld->method_params->wait_for_ready != WAIT_FOR_READY_UNSET;
   if (!wait_for_ready_set_from_api && wait_for_ready_set_from_service_config) {
     if (calld->method_params->wait_for_ready == WAIT_FOR_READY_TRUE) {
@@ -1135,15 +1144,15 @@ static bool pick_callback_start_locked(grpc_exec_ctx *exec_ctx,
                     grpc_combiner_scheduler(chand->combiner));
   const bool pick_done = grpc_lb_policy_pick_locked(
       exec_ctx, chand->lb_policy, &inputs, &calld->connected_subchannel,
-      calld->subchannel_call_context, NULL, &calld->lb_pick_closure);
+      calld->subchannel_call_context, nullptr, &calld->lb_pick_closure);
   if (pick_done) {
     /* synchronous grpc_lb_policy_pick call. Unref the LB policy. */
-    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+    if (grpc_client_channel_trace.enabled()) {
       gpr_log(GPR_DEBUG, "chand=%p calld=%p: pick completed synchronously",
               chand, calld);
     }
     GRPC_LB_POLICY_UNREF(exec_ctx, calld->lb_policy, "pick_subchannel");
-    calld->lb_policy = NULL;
+    calld->lb_policy = nullptr;
   } else {
     GRPC_CALL_STACK_REF(calld->owning_call, "pick_callback_cancel");
     grpc_call_combiner_set_notify_on_cancel(
@@ -1156,7 +1165,7 @@ static bool pick_callback_start_locked(grpc_exec_ctx *exec_ctx,
 }
 
 typedef struct {
-  grpc_call_element *elem;
+  grpc_call_element* elem;
   bool finished;
   grpc_closure closure;
   grpc_closure cancel_closure;
@@ -1164,11 +1173,10 @@ typedef struct {
 
 // Note: This runs under the client_channel combiner, but will NOT be
 // holding the call combiner.
-static void pick_after_resolver_result_cancel_locked(grpc_exec_ctx *exec_ctx,
-                                                     void *arg,
-                                                     grpc_error *error) {
-  pick_after_resolver_result_args *args =
-      (pick_after_resolver_result_args *)arg;
+static void pick_after_resolver_result_cancel_locked(grpc_exec_ctx* exec_ctx,
+                                                     void* arg,
+                                                     grpc_error* error) {
+  pick_after_resolver_result_args* args = (pick_after_resolver_result_args*)arg;
   if (args->finished) {
     gpr_free(args);
     return;
@@ -1181,10 +1189,10 @@ static void pick_after_resolver_result_cancel_locked(grpc_exec_ctx *exec_ctx,
   // is called, it will be a no-op.  We also immediately invoke
   // async_pick_done_locked() to propagate the error back to the caller.
   args->finished = true;
-  grpc_call_element *elem = args->elem;
-  channel_data *chand = (channel_data *)elem->channel_data;
-  call_data *calld = (call_data *)elem->call_data;
-  if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+  grpc_call_element* elem = args->elem;
+  channel_data* chand = (channel_data*)elem->channel_data;
+  call_data* calld = (call_data*)elem->call_data;
+  if (grpc_client_channel_trace.enabled()) {
     gpr_log(GPR_DEBUG,
             "chand=%p calld=%p: cancelling pick waiting for resolver result",
             chand, calld);
@@ -1199,31 +1207,33 @@ static void pick_after_resolver_result_cancel_locked(grpc_exec_ctx *exec_ctx,
                              "Pick cancelled", &error, 1));
 }
 
-static void pick_after_resolver_result_done_locked(grpc_exec_ctx *exec_ctx,
-                                                   void *arg,
-                                                   grpc_error *error) {
-  pick_after_resolver_result_args *args =
-      (pick_after_resolver_result_args *)arg;
+static void pick_after_resolver_result_start_locked(grpc_exec_ctx* exec_ctx,
+                                                    grpc_call_element* elem);
+
+static void pick_after_resolver_result_done_locked(grpc_exec_ctx* exec_ctx,
+                                                   void* arg,
+                                                   grpc_error* error) {
+  pick_after_resolver_result_args* args = (pick_after_resolver_result_args*)arg;
   if (args->finished) {
     /* cancelled, do nothing */
-    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+    if (grpc_client_channel_trace.enabled()) {
       gpr_log(GPR_DEBUG, "call cancelled before resolver result");
     }
     gpr_free(args);
     return;
   }
   args->finished = true;
-  grpc_call_element *elem = args->elem;
-  channel_data *chand = (channel_data *)elem->channel_data;
-  call_data *calld = (call_data *)elem->call_data;
+  grpc_call_element* elem = args->elem;
+  channel_data* chand = (channel_data*)elem->channel_data;
+  call_data* calld = (call_data*)elem->call_data;
   if (error != GRPC_ERROR_NONE) {
-    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+    if (grpc_client_channel_trace.enabled()) {
       gpr_log(GPR_DEBUG, "chand=%p calld=%p: resolver failed to return data",
               chand, calld);
     }
     async_pick_done_locked(exec_ctx, elem, GRPC_ERROR_REF(error));
-  } else {
-    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+  } else if (chand->lb_policy != nullptr) {
+    if (grpc_client_channel_trace.enabled()) {
       gpr_log(GPR_DEBUG, "chand=%p calld=%p: resolver returned, doing pick",
               chand, calld);
     }
@@ -1236,19 +1246,43 @@ static void pick_after_resolver_result_done_locked(grpc_exec_ctx *exec_ctx,
       async_pick_done_locked(exec_ctx, elem, GRPC_ERROR_NONE);
     }
   }
+  // TODO(roth): It should be impossible for chand->lb_policy to be NULL
+  // here, so the rest of this code should never actually be executed.
+  // However, we have reports of a crash on iOS that triggers this case,
+  // so we are temporarily adding this to restore branches that were
+  // removed in https://github.com/grpc/grpc/pull/12297.  Need to figure
+  // out what is actually causing this to occur and then figure out the
+  // right way to deal with it.
+  else if (chand->resolver != nullptr) {
+    // No LB policy, so try again.
+    if (grpc_client_channel_trace.enabled()) {
+      gpr_log(GPR_DEBUG,
+              "chand=%p calld=%p: resolver returned but no LB policy, "
+              "trying again",
+              chand, calld);
+    }
+    pick_after_resolver_result_start_locked(exec_ctx, elem);
+  } else {
+    if (grpc_client_channel_trace.enabled()) {
+      gpr_log(GPR_DEBUG, "chand=%p calld=%p: resolver disconnected", chand,
+              calld);
+    }
+    async_pick_done_locked(
+        exec_ctx, elem, GRPC_ERROR_CREATE_FROM_STATIC_STRING("Disconnected"));
+  }
 }
 
-static void pick_after_resolver_result_start_locked(grpc_exec_ctx *exec_ctx,
-                                                    grpc_call_element *elem) {
-  channel_data *chand = (channel_data *)elem->channel_data;
-  call_data *calld = (call_data *)elem->call_data;
-  if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+static void pick_after_resolver_result_start_locked(grpc_exec_ctx* exec_ctx,
+                                                    grpc_call_element* elem) {
+  channel_data* chand = (channel_data*)elem->channel_data;
+  call_data* calld = (call_data*)elem->call_data;
+  if (grpc_client_channel_trace.enabled()) {
     gpr_log(GPR_DEBUG,
             "chand=%p calld=%p: deferring pick pending resolver result", chand,
             calld);
   }
-  pick_after_resolver_result_args *args =
-      (pick_after_resolver_result_args *)gpr_zalloc(sizeof(*args));
+  pick_after_resolver_result_args* args =
+      (pick_after_resolver_result_args*)gpr_zalloc(sizeof(*args));
   args->elem = elem;
   GRPC_CLOSURE_INIT(&args->closure, pick_after_resolver_result_done_locked,
                     args, grpc_combiner_scheduler(chand->combiner));
@@ -1261,13 +1295,13 @@ static void pick_after_resolver_result_start_locked(grpc_exec_ctx *exec_ctx,
                         grpc_combiner_scheduler(chand->combiner)));
 }
 
-static void start_pick_locked(grpc_exec_ctx *exec_ctx, void *arg,
-                              grpc_error *ignored) {
-  grpc_call_element *elem = (grpc_call_element *)arg;
-  call_data *calld = (call_data *)elem->call_data;
-  channel_data *chand = (channel_data *)elem->channel_data;
-  GPR_ASSERT(calld->connected_subchannel == NULL);
-  if (chand->lb_policy != NULL) {
+static void start_pick_locked(grpc_exec_ctx* exec_ctx, void* arg,
+                              grpc_error* ignored) {
+  grpc_call_element* elem = (grpc_call_element*)arg;
+  call_data* calld = (call_data*)elem->call_data;
+  channel_data* chand = (channel_data*)elem->channel_data;
+  GPR_ASSERT(calld->connected_subchannel == nullptr);
+  if (chand->lb_policy != nullptr) {
     // We already have an LB policy, so ask it for a pick.
     if (pick_callback_start_locked(exec_ctx, elem)) {
       // Pick completed synchronously.
@@ -1276,7 +1310,7 @@ static void start_pick_locked(grpc_exec_ctx *exec_ctx, void *arg,
     }
   } else {
     // We do not yet have an LB policy, so wait for a resolver result.
-    if (chand->resolver == NULL) {
+    if (chand->resolver == nullptr) {
       pick_done_locked(exec_ctx, elem,
                        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Disconnected"));
       return;
@@ -1295,10 +1329,10 @@ static void start_pick_locked(grpc_exec_ctx *exec_ctx, void *arg,
                                          chand->interested_parties);
 }
 
-static void on_complete(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  grpc_call_element *elem = (grpc_call_element *)arg;
-  call_data *calld = (call_data *)elem->call_data;
-  if (calld->retry_throttle_data != NULL) {
+static void on_complete(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  grpc_call_element* elem = (grpc_call_element*)arg;
+  call_data* calld = (call_data*)elem->call_data;
+  if (calld->retry_throttle_data != nullptr) {
     if (error == GRPC_ERROR_NONE) {
       grpc_server_retry_throttle_data_record_success(
           calld->retry_throttle_data);
@@ -1316,10 +1350,10 @@ static void on_complete(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
 }
 
 static void cc_start_transport_stream_op_batch(
-    grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-    grpc_transport_stream_op_batch *batch) {
-  call_data *calld = (call_data *)elem->call_data;
-  channel_data *chand = (channel_data *)elem->channel_data;
+    grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+    grpc_transport_stream_op_batch* batch) {
+  call_data* calld = (call_data*)elem->call_data;
+  channel_data* chand = (channel_data*)elem->channel_data;
   if (chand->deadline_checking_enabled) {
     grpc_deadline_state_client_start_transport_stream_op_batch(exec_ctx, elem,
                                                                batch);
@@ -1327,7 +1361,7 @@ static void cc_start_transport_stream_op_batch(
   GPR_TIMER_BEGIN("cc_start_transport_stream_op_batch", 0);
   // If we've previously been cancelled, immediately fail any new batches.
   if (calld->error != GRPC_ERROR_NONE) {
-    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+    if (grpc_client_channel_trace.enabled()) {
       gpr_log(GPR_DEBUG, "chand=%p calld=%p: failing batch with error: %s",
               chand, calld, grpc_error_string(calld->error));
     }
@@ -1343,13 +1377,13 @@ static void cc_start_transport_stream_op_batch(
     // error to the caller when the first batch does get passed down.
     GRPC_ERROR_UNREF(calld->error);
     calld->error = GRPC_ERROR_REF(batch->payload->cancel_stream.cancel_error);
-    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+    if (grpc_client_channel_trace.enabled()) {
       gpr_log(GPR_DEBUG, "chand=%p calld=%p: recording cancel_error=%s", chand,
               calld, grpc_error_string(calld->error));
     }
     // If we have a subchannel call, send the cancellation batch down.
     // Otherwise, fail all pending batches.
-    if (calld->subchannel_call != NULL) {
+    if (calld->subchannel_call != nullptr) {
       grpc_subchannel_call_process_op(exec_ctx, calld->subchannel_call, batch);
     } else {
       waiting_for_pick_batches_add(calld, batch);
@@ -1361,7 +1395,7 @@ static void cc_start_transport_stream_op_batch(
   // Intercept on_complete for recv_trailing_metadata so that we can
   // check retry throttle status.
   if (batch->recv_trailing_metadata) {
-    GPR_ASSERT(batch->on_complete != NULL);
+    GPR_ASSERT(batch->on_complete != nullptr);
     calld->original_on_complete = batch->on_complete;
     GRPC_CLOSURE_INIT(&calld->on_complete, on_complete, elem,
                       grpc_schedule_on_exec_ctx);
@@ -1371,8 +1405,8 @@ static void cc_start_transport_stream_op_batch(
   // Note that once we have completed the pick, we do not need to enter
   // the channel combiner, which is more efficient (especially for
   // streaming calls).
-  if (calld->subchannel_call != NULL) {
-    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+  if (calld->subchannel_call != nullptr) {
+    if (grpc_client_channel_trace.enabled()) {
       gpr_log(GPR_DEBUG,
               "chand=%p calld=%p: sending batch to subchannel_call=%p", chand,
               calld, calld->subchannel_call);
@@ -1386,7 +1420,7 @@ static void cc_start_transport_stream_op_batch(
   // For batches containing a send_initial_metadata op, enter the channel
   // combiner to start a pick.
   if (batch->send_initial_metadata) {
-    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+    if (grpc_client_channel_trace.enabled()) {
       gpr_log(GPR_DEBUG, "chand=%p calld=%p: entering client_channel combiner",
               chand, calld);
     }
@@ -1397,7 +1431,7 @@ static void cc_start_transport_stream_op_batch(
         GRPC_ERROR_NONE);
   } else {
     // For all other batches, release the call combiner.
-    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+    if (grpc_client_channel_trace.enabled()) {
       gpr_log(GPR_DEBUG,
               "chand=%p calld=%p: saved batch, yeilding call combiner", chand,
               calld);
@@ -1410,15 +1444,15 @@ done:
 }
 
 /* Constructor for call_data */
-static grpc_error *cc_init_call_elem(grpc_exec_ctx *exec_ctx,
-                                     grpc_call_element *elem,
-                                     const grpc_call_element_args *args) {
-  call_data *calld = (call_data *)elem->call_data;
-  channel_data *chand = (channel_data *)elem->channel_data;
+static grpc_error* cc_init_call_elem(grpc_exec_ctx* exec_ctx,
+                                     grpc_call_element* elem,
+                                     const grpc_call_element_args* args) {
+  call_data* calld = (call_data*)elem->call_data;
+  channel_data* chand = (channel_data*)elem->channel_data;
   // Initialize data members.
   calld->path = grpc_slice_ref_internal(args->path);
   calld->call_start_time = args->start_time;
-  calld->deadline = gpr_convert_clock_type(args->deadline, GPR_CLOCK_MONOTONIC);
+  calld->deadline = args->deadline;
   calld->arena = args->arena;
   calld->owning_call = args->call_stack;
   calld->call_combiner = args->call_combiner;
@@ -1430,35 +1464,35 @@ static grpc_error *cc_init_call_elem(grpc_exec_ctx *exec_ctx,
 }
 
 /* Destructor for call_data */
-static void cc_destroy_call_elem(grpc_exec_ctx *exec_ctx,
-                                 grpc_call_element *elem,
-                                 const grpc_call_final_info *final_info,
-                                 grpc_closure *then_schedule_closure) {
-  call_data *calld = (call_data *)elem->call_data;
-  channel_data *chand = (channel_data *)elem->channel_data;
+static void cc_destroy_call_elem(grpc_exec_ctx* exec_ctx,
+                                 grpc_call_element* elem,
+                                 const grpc_call_final_info* final_info,
+                                 grpc_closure* then_schedule_closure) {
+  call_data* calld = (call_data*)elem->call_data;
+  channel_data* chand = (channel_data*)elem->channel_data;
   if (chand->deadline_checking_enabled) {
     grpc_deadline_state_destroy(exec_ctx, elem);
   }
   grpc_slice_unref_internal(exec_ctx, calld->path);
-  if (calld->method_params != NULL) {
+  if (calld->method_params != nullptr) {
     method_parameters_unref(calld->method_params);
   }
   GRPC_ERROR_UNREF(calld->error);
-  if (calld->subchannel_call != NULL) {
+  if (calld->subchannel_call != nullptr) {
     grpc_subchannel_call_set_cleanup_closure(calld->subchannel_call,
                                              then_schedule_closure);
-    then_schedule_closure = NULL;
+    then_schedule_closure = nullptr;
     GRPC_SUBCHANNEL_CALL_UNREF(exec_ctx, calld->subchannel_call,
                                "client_channel_destroy_call");
   }
-  GPR_ASSERT(calld->lb_policy == NULL);
+  GPR_ASSERT(calld->lb_policy == nullptr);
   GPR_ASSERT(calld->waiting_for_pick_batches_count == 0);
-  if (calld->connected_subchannel != NULL) {
+  if (calld->connected_subchannel != nullptr) {
     GRPC_CONNECTED_SUBCHANNEL_UNREF(exec_ctx, calld->connected_subchannel,
                                     "picked");
   }
   for (size_t i = 0; i < GRPC_CONTEXT_COUNT; ++i) {
-    if (calld->subchannel_call_context[i].value != NULL) {
+    if (calld->subchannel_call_context[i].value != nullptr) {
       calld->subchannel_call_context[i].destroy(
           calld->subchannel_call_context[i].value);
     }
@@ -1466,10 +1500,10 @@ static void cc_destroy_call_elem(grpc_exec_ctx *exec_ctx,
   GRPC_CLOSURE_SCHED(exec_ctx, then_schedule_closure, GRPC_ERROR_NONE);
 }
 
-static void cc_set_pollset_or_pollset_set(grpc_exec_ctx *exec_ctx,
-                                          grpc_call_element *elem,
-                                          grpc_polling_entity *pollent) {
-  call_data *calld = (call_data *)elem->call_data;
+static void cc_set_pollset_or_pollset_set(grpc_exec_ctx* exec_ctx,
+                                          grpc_call_element* elem,
+                                          grpc_polling_entity* pollent) {
+  call_data* calld = (call_data*)elem->call_data;
   calld->pollent = pollent;
 }
 
@@ -1491,14 +1525,14 @@ const grpc_channel_filter grpc_client_channel_filter = {
     "client-channel",
 };
 
-static void try_to_connect_locked(grpc_exec_ctx *exec_ctx, void *arg,
-                                  grpc_error *error_ignored) {
-  channel_data *chand = (channel_data *)arg;
-  if (chand->lb_policy != NULL) {
+static void try_to_connect_locked(grpc_exec_ctx* exec_ctx, void* arg,
+                                  grpc_error* error_ignored) {
+  channel_data* chand = (channel_data*)arg;
+  if (chand->lb_policy != nullptr) {
     grpc_lb_policy_exit_idle_locked(exec_ctx, chand->lb_policy);
   } else {
     chand->exit_idle_when_lb_policy_arrives = true;
-    if (!chand->started_resolving && chand->resolver != NULL) {
+    if (!chand->started_resolving && chand->resolver != nullptr) {
       start_resolving_locked(exec_ctx, chand);
     }
   }
@@ -1506,36 +1540,37 @@ static void try_to_connect_locked(grpc_exec_ctx *exec_ctx, void *arg,
 }
 
 grpc_connectivity_state grpc_client_channel_check_connectivity_state(
-    grpc_exec_ctx *exec_ctx, grpc_channel_element *elem, int try_to_connect) {
-  channel_data *chand = (channel_data *)elem->channel_data;
+    grpc_exec_ctx* exec_ctx, grpc_channel_element* elem, int try_to_connect) {
+  channel_data* chand = (channel_data*)elem->channel_data;
   grpc_connectivity_state out =
       grpc_connectivity_state_check(&chand->state_tracker);
   if (out == GRPC_CHANNEL_IDLE && try_to_connect) {
     GRPC_CHANNEL_STACK_REF(chand->owning_stack, "try_to_connect");
     GRPC_CLOSURE_SCHED(
-        exec_ctx, GRPC_CLOSURE_CREATE(try_to_connect_locked, chand,
-                                      grpc_combiner_scheduler(chand->combiner)),
+        exec_ctx,
+        GRPC_CLOSURE_CREATE(try_to_connect_locked, chand,
+                            grpc_combiner_scheduler(chand->combiner)),
         GRPC_ERROR_NONE);
   }
   return out;
 }
 
 typedef struct external_connectivity_watcher {
-  channel_data *chand;
+  channel_data* chand;
   grpc_polling_entity pollent;
-  grpc_closure *on_complete;
-  grpc_closure *watcher_timer_init;
-  grpc_connectivity_state *state;
+  grpc_closure* on_complete;
+  grpc_closure* watcher_timer_init;
+  grpc_connectivity_state* state;
   grpc_closure my_closure;
-  struct external_connectivity_watcher *next;
+  struct external_connectivity_watcher* next;
 } external_connectivity_watcher;
 
-static external_connectivity_watcher *lookup_external_connectivity_watcher(
-    channel_data *chand, grpc_closure *on_complete) {
+static external_connectivity_watcher* lookup_external_connectivity_watcher(
+    channel_data* chand, grpc_closure* on_complete) {
   gpr_mu_lock(&chand->external_connectivity_watcher_list_mu);
-  external_connectivity_watcher *w =
+  external_connectivity_watcher* w =
       chand->external_connectivity_watcher_list_head;
-  while (w != NULL && w->on_complete != on_complete) {
+  while (w != nullptr && w->on_complete != on_complete) {
     w = w->next;
   }
   gpr_mu_unlock(&chand->external_connectivity_watcher_list_mu);
@@ -1543,7 +1578,7 @@ static external_connectivity_watcher *lookup_external_connectivity_watcher(
 }
 
 static void external_connectivity_watcher_list_append(
-    channel_data *chand, external_connectivity_watcher *w) {
+    channel_data* chand, external_connectivity_watcher* w) {
   GPR_ASSERT(!lookup_external_connectivity_watcher(chand, w->on_complete));
 
   gpr_mu_lock(&w->chand->external_connectivity_watcher_list_mu);
@@ -1554,7 +1589,7 @@ static void external_connectivity_watcher_list_append(
 }
 
 static void external_connectivity_watcher_list_remove(
-    channel_data *chand, external_connectivity_watcher *too_remove) {
+    channel_data* chand, external_connectivity_watcher* too_remove) {
   GPR_ASSERT(
       lookup_external_connectivity_watcher(chand, too_remove->on_complete));
   gpr_mu_lock(&chand->external_connectivity_watcher_list_mu);
@@ -1563,9 +1598,9 @@ static void external_connectivity_watcher_list_remove(
     gpr_mu_unlock(&chand->external_connectivity_watcher_list_mu);
     return;
   }
-  external_connectivity_watcher *w =
+  external_connectivity_watcher* w =
       chand->external_connectivity_watcher_list_head;
-  while (w != NULL) {
+  while (w != nullptr) {
     if (w->next == too_remove) {
       w->next = w->next->next;
       gpr_mu_unlock(&chand->external_connectivity_watcher_list_mu);
@@ -1577,14 +1612,14 @@ static void external_connectivity_watcher_list_remove(
 }
 
 int grpc_client_channel_num_external_connectivity_watchers(
-    grpc_channel_element *elem) {
-  channel_data *chand = (channel_data *)elem->channel_data;
+    grpc_channel_element* elem) {
+  channel_data* chand = (channel_data*)elem->channel_data;
   int count = 0;
 
   gpr_mu_lock(&chand->external_connectivity_watcher_list_mu);
-  external_connectivity_watcher *w =
+  external_connectivity_watcher* w =
       chand->external_connectivity_watcher_list_head;
-  while (w != NULL) {
+  while (w != nullptr) {
     count++;
     w = w->next;
   }
@@ -1593,10 +1628,10 @@ int grpc_client_channel_num_external_connectivity_watchers(
   return count;
 }
 
-static void on_external_watch_complete(grpc_exec_ctx *exec_ctx, void *arg,
-                                       grpc_error *error) {
-  external_connectivity_watcher *w = (external_connectivity_watcher *)arg;
-  grpc_closure *follow_up = w->on_complete;
+static void on_external_watch_complete_locked(grpc_exec_ctx* exec_ctx,
+                                              void* arg, grpc_error* error) {
+  external_connectivity_watcher* w = (external_connectivity_watcher*)arg;
+  grpc_closure* follow_up = w->on_complete;
   grpc_polling_entity_del_from_pollset_set(exec_ctx, &w->pollent,
                                            w->chand->interested_parties);
   GRPC_CHANNEL_STACK_UNREF(exec_ctx, w->chand->owning_stack,
@@ -1606,24 +1641,24 @@ static void on_external_watch_complete(grpc_exec_ctx *exec_ctx, void *arg,
   GRPC_CLOSURE_RUN(exec_ctx, follow_up, GRPC_ERROR_REF(error));
 }
 
-static void watch_connectivity_state_locked(grpc_exec_ctx *exec_ctx, void *arg,
-                                            grpc_error *error_ignored) {
-  external_connectivity_watcher *w = (external_connectivity_watcher *)arg;
-  external_connectivity_watcher *found = NULL;
-  if (w->state != NULL) {
+static void watch_connectivity_state_locked(grpc_exec_ctx* exec_ctx, void* arg,
+                                            grpc_error* error_ignored) {
+  external_connectivity_watcher* w = (external_connectivity_watcher*)arg;
+  external_connectivity_watcher* found = nullptr;
+  if (w->state != nullptr) {
     external_connectivity_watcher_list_append(w->chand, w);
     GRPC_CLOSURE_RUN(exec_ctx, w->watcher_timer_init, GRPC_ERROR_NONE);
-    GRPC_CLOSURE_INIT(&w->my_closure, on_external_watch_complete, w,
-                      grpc_schedule_on_exec_ctx);
+    GRPC_CLOSURE_INIT(&w->my_closure, on_external_watch_complete_locked, w,
+                      grpc_combiner_scheduler(w->chand->combiner));
     grpc_connectivity_state_notify_on_state_change(
         exec_ctx, &w->chand->state_tracker, w->state, &w->my_closure);
   } else {
-    GPR_ASSERT(w->watcher_timer_init == NULL);
+    GPR_ASSERT(w->watcher_timer_init == nullptr);
     found = lookup_external_connectivity_watcher(w->chand, w->on_complete);
     if (found) {
       GPR_ASSERT(found->on_complete == w->on_complete);
       grpc_connectivity_state_notify_on_state_change(
-          exec_ctx, &found->chand->state_tracker, NULL, &found->my_closure);
+          exec_ctx, &found->chand->state_tracker, nullptr, &found->my_closure);
     }
     grpc_polling_entity_del_from_pollset_set(exec_ctx, &w->pollent,
                                              w->chand->interested_parties);
@@ -1634,12 +1669,12 @@ static void watch_connectivity_state_locked(grpc_exec_ctx *exec_ctx, void *arg,
 }
 
 void grpc_client_channel_watch_connectivity_state(
-    grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
-    grpc_polling_entity pollent, grpc_connectivity_state *state,
-    grpc_closure *closure, grpc_closure *watcher_timer_init) {
-  channel_data *chand = (channel_data *)elem->channel_data;
-  external_connectivity_watcher *w =
-      (external_connectivity_watcher *)gpr_zalloc(sizeof(*w));
+    grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+    grpc_polling_entity pollent, grpc_connectivity_state* state,
+    grpc_closure* closure, grpc_closure* watcher_timer_init) {
+  channel_data* chand = (channel_data*)elem->channel_data;
+  external_connectivity_watcher* w =
+      (external_connectivity_watcher*)gpr_zalloc(sizeof(*w));
   w->chand = chand;
   w->pollent = pollent;
   w->on_complete = closure;