grpc 1.8.7 → 1.9.0.pre1

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

@@ -28,10 +28,9 @@ void grpc_resolver_factory_unref(grpc_resolver_factory* factory) {
 
 /** Create a resolver instance for a name */
 grpc_resolver* grpc_resolver_factory_create_resolver(
-    grpc_exec_ctx* exec_ctx, grpc_resolver_factory* factory,
-    grpc_resolver_args* args) {
+    grpc_resolver_factory* factory, grpc_resolver_args* args) {
   if (factory == nullptr) return nullptr;
-  return factory->vtable->create_resolver(exec_ctx, factory, args);
+  return factory->vtable->create_resolver(factory, args);
 }
 
 char* grpc_resolver_factory_get_default_authority(

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

@@ -24,10 +24,6 @@
 #include "src/core/ext/filters/client_channel/uri_parser.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 typedef struct grpc_resolver_factory grpc_resolver_factory;
 typedef struct grpc_resolver_factory_vtable grpc_resolver_factory_vtable;
 
@@ -47,8 +43,7 @@ struct grpc_resolver_factory_vtable {
   void (*unref)(grpc_resolver_factory* factory);
 
   /** Implementation of grpc_resolver_factory_create_resolver */
-  grpc_resolver* (*create_resolver)(grpc_exec_ctx* exec_ctx,
-                                    grpc_resolver_factory* factory,
+  grpc_resolver* (*create_resolver)(grpc_resolver_factory* factory,
                                     grpc_resolver_args* args);
 
   /** Implementation of grpc_resolver_factory_get_default_authority */
@@ -63,16 +58,11 @@ void grpc_resolver_factory_unref(grpc_resolver_factory* resolver);
 
 /** Create a resolver instance for a name */
 grpc_resolver* grpc_resolver_factory_create_resolver(
-    grpc_exec_ctx* exec_ctx, grpc_resolver_factory* factory,
-    grpc_resolver_args* args);
+    grpc_resolver_factory* factory, grpc_resolver_args* args);
 
 /** Return a (freshly allocated with gpr_malloc) string representing
     the default authority to use for this scheme. */
 char* grpc_resolver_factory_get_default_authority(
     grpc_resolver_factory* factory, grpc_uri* uri);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FACTORY_H */

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

@@ -92,23 +92,22 @@ static grpc_resolver_factory* lookup_factory_by_uri(grpc_uri* uri) {
   return lookup_factory(uri->scheme);
 }
 
-static grpc_resolver_factory* resolve_factory(grpc_exec_ctx* exec_ctx,
-                                              const char* target,
+static grpc_resolver_factory* resolve_factory(const char* target,
                                               grpc_uri** uri,
                                               char** canonical_target) {
   grpc_resolver_factory* factory = nullptr;
 
   GPR_ASSERT(uri != nullptr);
-  *uri = grpc_uri_parse(exec_ctx, target, 1);
+  *uri = grpc_uri_parse(target, 1);
   factory = lookup_factory_by_uri(*uri);
   if (factory == nullptr) {
     grpc_uri_destroy(*uri);
     gpr_asprintf(canonical_target, "%s%s", g_default_resolver_prefix, target);
-    *uri = grpc_uri_parse(exec_ctx, *canonical_target, 1);
+    *uri = grpc_uri_parse(*canonical_target, 1);
     factory = lookup_factory_by_uri(*uri);
     if (factory == nullptr) {
-      grpc_uri_destroy(grpc_uri_parse(exec_ctx, target, 0));
-      grpc_uri_destroy(grpc_uri_parse(exec_ctx, *canonical_target, 0));
+      grpc_uri_destroy(grpc_uri_parse(target, 0));
+      grpc_uri_destroy(grpc_uri_parse(*canonical_target, 0));
       gpr_log(GPR_ERROR, "don't know how to resolve '%s' or '%s'", target,
               *canonical_target);
     }
@@ -116,14 +115,14 @@ static grpc_resolver_factory* resolve_factory(grpc_exec_ctx* exec_ctx,
   return factory;
 }
 
-grpc_resolver* grpc_resolver_create(grpc_exec_ctx* exec_ctx, const char* target,
+grpc_resolver* grpc_resolver_create(const char* target,
                                     const grpc_channel_args* args,
                                     grpc_pollset_set* pollset_set,
                                     grpc_combiner* combiner) {
   grpc_uri* uri = nullptr;
   char* canonical_target = nullptr;
   grpc_resolver_factory* factory =
-      resolve_factory(exec_ctx, target, &uri, &canonical_target);
+      resolve_factory(target, &uri, &canonical_target);
   grpc_resolver* resolver;
   grpc_resolver_args resolver_args;
   memset(&resolver_args, 0, sizeof(resolver_args));
@@ -131,29 +130,27 @@ grpc_resolver* grpc_resolver_create(grpc_exec_ctx* exec_ctx, const char* target,
   resolver_args.args = args;
   resolver_args.pollset_set = pollset_set;
   resolver_args.combiner = combiner;
-  resolver =
-      grpc_resolver_factory_create_resolver(exec_ctx, factory, &resolver_args);
+  resolver = grpc_resolver_factory_create_resolver(factory, &resolver_args);
   grpc_uri_destroy(uri);
   gpr_free(canonical_target);
   return resolver;
 }
 
-char* grpc_get_default_authority(grpc_exec_ctx* exec_ctx, const char* target) {
+char* grpc_get_default_authority(const char* target) {
   grpc_uri* uri = nullptr;
   char* canonical_target = nullptr;
   grpc_resolver_factory* factory =
-      resolve_factory(exec_ctx, target, &uri, &canonical_target);
+      resolve_factory(target, &uri, &canonical_target);
   char* authority = grpc_resolver_factory_get_default_authority(factory, uri);
   grpc_uri_destroy(uri);
   gpr_free(canonical_target);
   return authority;
 }
 
-char* grpc_resolver_factory_add_default_prefix_if_needed(
-    grpc_exec_ctx* exec_ctx, const char* target) {
+char* grpc_resolver_factory_add_default_prefix_if_needed(const char* target) {
   grpc_uri* uri = nullptr;
   char* canonical_target = nullptr;
-  resolve_factory(exec_ctx, target, &uri, &canonical_target);
+  resolve_factory(target, &uri, &canonical_target);
   grpc_uri_destroy(uri);
   return canonical_target == nullptr ? gpr_strdup(target) : canonical_target;
 }

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

@@ -22,10 +22,6 @@
 #include "src/core/ext/filters/client_channel/resolver_factory.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 void grpc_resolver_registry_init();
 void grpc_resolver_registry_shutdown(void);
 
@@ -52,7 +48,7 @@ void grpc_register_resolver_type(grpc_resolver_factory* factory);
     (typically the set of arguments passed in from the client API).
     \a pollset_set is used to drive IO in the name resolution process, it
     should not be NULL. */
-grpc_resolver* grpc_resolver_create(grpc_exec_ctx* exec_ctx, const char* target,
+grpc_resolver* grpc_resolver_create(const char* target,
                                     const grpc_channel_args* args,
                                     grpc_pollset_set* pollset_set,
                                     grpc_combiner* combiner);
@@ -63,15 +59,10 @@ grpc_resolver_factory* grpc_resolver_factory_lookup(const char* name);
 
 /** Given a target, return a (freshly allocated with gpr_malloc) string
     representing the default authority to pass from a client. */
-char* grpc_get_default_authority(grpc_exec_ctx* exec_ctx, const char* target);
+char* grpc_get_default_authority(const char* target);
 
 /** Returns a newly allocated string containing \a target, adding the
     default prefix if needed. */
-char* grpc_resolver_factory_add_default_prefix_if_needed(
-    grpc_exec_ctx* exec_ctx, const char* target);
-
-#ifdef __cplusplus
-}
-#endif
+char* grpc_resolver_factory_add_default_prefix_if_needed(const char* target);
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_REGISTRY_H */

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

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

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

@@ -20,7 +20,9 @@
 
 #include <inttypes.h>
 #include <limits.h>
-#include <string.h>
+
+#include <algorithm>
+#include <cstring>
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/avl.h>
@@ -35,6 +37,8 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/connected_channel.h"
 #include "src/core/lib/debug/stats.h"
+#include "src/core/lib/gpr++/debug_location.h"
+#include "src/core/lib/gpr++/manual_constructor.h"
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/profiling/timers.h"
@@ -48,19 +52,17 @@
 
 #define GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS 1
 #define GRPC_SUBCHANNEL_RECONNECT_BACKOFF_MULTIPLIER 1.6
-#define GRPC_SUBCHANNEL_RECONNECT_MIN_BACKOFF_SECONDS 20
+#define GRPC_SUBCHANNEL_RECONNECT_MIN_TIMEOUT_SECONDS 20
 #define GRPC_SUBCHANNEL_RECONNECT_MAX_BACKOFF_SECONDS 120
 #define GRPC_SUBCHANNEL_RECONNECT_JITTER 0.2
 
-#define GET_CONNECTED_SUBCHANNEL(subchannel, barrier)     \
-  ((grpc_connected_subchannel*)(gpr_atm_##barrier##_load( \
-      &(subchannel)->connected_subchannel)))
-
-typedef struct {
+namespace {
+struct state_watcher {
   grpc_closure closure;
   grpc_subchannel* subchannel;
   grpc_connectivity_state connectivity_state;
-} state_watcher;
+};
+}  // namespace
 
 typedef struct external_state_watcher {
   grpc_subchannel* subchannel;
@@ -93,7 +95,7 @@ struct grpc_subchannel {
   grpc_connect_out_args connecting_result;
 
   /** callback for connection finishing */
-  grpc_closure connected;
+  grpc_closure on_connected;
 
   /** callback for our alarm */
   grpc_closure on_alarm;
@@ -102,12 +104,13 @@ struct grpc_subchannel {
       being setup */
   grpc_pollset_set* pollset_set;
 
-  /** active connection, or null; of type grpc_connected_subchannel */
-  gpr_atm connected_subchannel;
-
   /** mutex protecting remaining elements */
   gpr_mu mu;
 
+  /** active connection, or null; of type grpc_core::ConnectedSubchannel
+   */
+  grpc_core::RefCountedPtr<grpc_core::ConnectedSubchannel> connected_subchannel;
+
   /** have we seen a disconnection? */
   bool disconnected;
   /** are we connecting */
@@ -118,8 +121,9 @@ struct grpc_subchannel {
   external_state_watcher root_external_state_watcher;
 
   /** backoff state */
-  grpc_backoff backoff_state;
-  grpc_backoff_result backoff_result;
+  grpc_core::ManualConstructor<grpc_core::BackOff> backoff;
+  grpc_millis next_attempt_deadline;
+  grpc_millis min_connect_timeout_ms;
 
   /** do we have an active alarm? */
   bool have_alarm;
@@ -130,17 +134,15 @@ struct grpc_subchannel {
 };
 
 struct grpc_subchannel_call {
-  grpc_connected_subchannel* connection;
+  grpc_core::ConnectedSubchannel* connection;
   grpc_closure* schedule_closure_after_destroy;
 };
 
 #define SUBCHANNEL_CALL_TO_CALL_STACK(call) ((grpc_call_stack*)((call) + 1))
-#define CHANNEL_STACK_FROM_CONNECTION(con) ((grpc_channel_stack*)(con))
 #define CALLSTACK_TO_SUBCHANNEL_CALL(callstack) \
   (((grpc_subchannel_call*)(callstack)) - 1)
 
-static void subchannel_connected(grpc_exec_ctx* exec_ctx, void* subchannel,
-                                 grpc_error* error);
+static void on_subchannel_connected(void* subchannel, grpc_error* error);
 
 #ifndef NDEBUG
 #define REF_REASON reason
@@ -157,39 +159,24 @@ static void subchannel_connected(grpc_exec_ctx* exec_ctx, void* subchannel,
  * connection implementation
  */
 
-static void connection_destroy(grpc_exec_ctx* exec_ctx, void* arg,
-                               grpc_error* error) {
-  grpc_connected_subchannel* c = (grpc_connected_subchannel*)arg;
-  grpc_channel_stack_destroy(exec_ctx, CHANNEL_STACK_FROM_CONNECTION(c));
-  gpr_free(c);
-}
-
-grpc_connected_subchannel* grpc_connected_subchannel_ref(
-    grpc_connected_subchannel* c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
-  GRPC_CHANNEL_STACK_REF(CHANNEL_STACK_FROM_CONNECTION(c), REF_REASON);
-  return c;
-}
-
-void grpc_connected_subchannel_unref(grpc_exec_ctx* exec_ctx,
-                                     grpc_connected_subchannel* c
-                                         GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
-  GRPC_CHANNEL_STACK_UNREF(exec_ctx, CHANNEL_STACK_FROM_CONNECTION(c),
-                           REF_REASON);
+static void connection_destroy(void* arg, grpc_error* error) {
+  grpc_channel_stack* stk = (grpc_channel_stack*)arg;
+  grpc_channel_stack_destroy(stk);
+  gpr_free(stk);
 }
 
 /*
  * grpc_subchannel implementation
  */
 
-static void subchannel_destroy(grpc_exec_ctx* exec_ctx, void* arg,
-                               grpc_error* error) {
+static void subchannel_destroy(void* arg, grpc_error* error) {
   grpc_subchannel* c = (grpc_subchannel*)arg;
   gpr_free((void*)c->filters);
-  grpc_channel_args_destroy(exec_ctx, c->args);
-  grpc_connectivity_state_destroy(exec_ctx, &c->state_tracker);
-  grpc_connector_unref(exec_ctx, c->connector);
-  grpc_pollset_set_destroy(exec_ctx, c->pollset_set);
-  grpc_subchannel_key_destroy(exec_ctx, c->key);
+  grpc_channel_args_destroy(c->args);
+  grpc_connectivity_state_destroy(&c->state_tracker);
+  grpc_connector_unref(c->connector);
+  grpc_pollset_set_destroy(c->pollset_set);
+  grpc_subchannel_key_destroy(c->key);
   gpr_mu_destroy(&c->mu);
   gpr_free(c);
 }
@@ -241,59 +228,97 @@ grpc_subchannel* grpc_subchannel_ref_from_weak_ref(
   }
 }
 
-static void disconnect(grpc_exec_ctx* exec_ctx, grpc_subchannel* c) {
-  grpc_connected_subchannel* con;
-  grpc_subchannel_index_unregister(exec_ctx, c->key, c);
+static void disconnect(grpc_subchannel* c) {
+  grpc_subchannel_index_unregister(c->key, c);
   gpr_mu_lock(&c->mu);
   GPR_ASSERT(!c->disconnected);
   c->disconnected = true;
-  grpc_connector_shutdown(
-      exec_ctx, c->connector,
-      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Subchannel disconnected"));
-  con = GET_CONNECTED_SUBCHANNEL(c, no_barrier);
-  if (con != nullptr) {
-    GRPC_CONNECTED_SUBCHANNEL_UNREF(exec_ctx, con, "connection");
-    gpr_atm_no_barrier_store(&c->connected_subchannel, (gpr_atm)0xdeadbeef);
-  }
+  grpc_connector_shutdown(c->connector, GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                                            "Subchannel disconnected"));
+  c->connected_subchannel.reset();
   gpr_mu_unlock(&c->mu);
 }
 
-void grpc_subchannel_unref(grpc_exec_ctx* exec_ctx,
-                           grpc_subchannel* c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+void grpc_subchannel_unref(grpc_subchannel* c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
   gpr_atm old_refs;
   // add a weak ref and subtract a strong ref (atomically)
   old_refs = ref_mutate(c, (gpr_atm)1 - (gpr_atm)(1 << INTERNAL_REF_BITS),
                         1 REF_MUTATE_PURPOSE("STRONG_UNREF"));
   if ((old_refs & STRONG_REF_MASK) == (1 << INTERNAL_REF_BITS)) {
-    disconnect(exec_ctx, c);
+    disconnect(c);
   }
-  GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, c, "strong-unref");
+  GRPC_SUBCHANNEL_WEAK_UNREF(c, "strong-unref");
 }
 
-void grpc_subchannel_weak_unref(grpc_exec_ctx* exec_ctx,
-                                grpc_subchannel* c
-                                    GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+void grpc_subchannel_weak_unref(
+    grpc_subchannel* c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
   gpr_atm old_refs;
   old_refs = ref_mutate(c, -(gpr_atm)1, 1 REF_MUTATE_PURPOSE("WEAK_UNREF"));
   if (old_refs == 1) {
     GRPC_CLOSURE_SCHED(
-        exec_ctx,
         GRPC_CLOSURE_CREATE(subchannel_destroy, c, grpc_schedule_on_exec_ctx),
         GRPC_ERROR_NONE);
   }
 }
 
-grpc_subchannel* grpc_subchannel_create(grpc_exec_ctx* exec_ctx,
-                                        grpc_connector* connector,
+static void parse_args_for_backoff_values(
+    const grpc_channel_args* args, grpc_core::BackOff::Options* backoff_options,
+    grpc_millis* min_connect_timeout_ms) {
+  grpc_millis initial_backoff_ms =
+      GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS * 1000;
+  *min_connect_timeout_ms =
+      GRPC_SUBCHANNEL_RECONNECT_MIN_TIMEOUT_SECONDS * 1000;
+  grpc_millis max_backoff_ms =
+      GRPC_SUBCHANNEL_RECONNECT_MAX_BACKOFF_SECONDS * 1000;
+  bool fixed_reconnect_backoff = false;
+  if (args != nullptr) {
+    for (size_t i = 0; i < args->num_args; i++) {
+      if (0 == strcmp(args->args[i].key,
+                      "grpc.testing.fixed_reconnect_backoff_ms")) {
+        fixed_reconnect_backoff = true;
+        initial_backoff_ms = *min_connect_timeout_ms = max_backoff_ms =
+            grpc_channel_arg_get_integer(
+                &args->args[i],
+                {static_cast<int>(initial_backoff_ms), 100, INT_MAX});
+      } else if (0 ==
+                 strcmp(args->args[i].key, GRPC_ARG_MIN_RECONNECT_BACKOFF_MS)) {
+        fixed_reconnect_backoff = false;
+        *min_connect_timeout_ms = grpc_channel_arg_get_integer(
+            &args->args[i],
+            {static_cast<int>(*min_connect_timeout_ms), 100, INT_MAX});
+      } else if (0 ==
+                 strcmp(args->args[i].key, GRPC_ARG_MAX_RECONNECT_BACKOFF_MS)) {
+        fixed_reconnect_backoff = false;
+        max_backoff_ms = grpc_channel_arg_get_integer(
+            &args->args[i], {static_cast<int>(max_backoff_ms), 100, INT_MAX});
+      } else if (0 == strcmp(args->args[i].key,
+                             GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS)) {
+        fixed_reconnect_backoff = false;
+        initial_backoff_ms = grpc_channel_arg_get_integer(
+            &args->args[i],
+            {static_cast<int>(initial_backoff_ms), 100, INT_MAX});
+      }
+    }
+  }
+  backoff_options->set_initial_backoff(initial_backoff_ms)
+      .set_multiplier(fixed_reconnect_backoff
+                          ? 1.0
+                          : GRPC_SUBCHANNEL_RECONNECT_BACKOFF_MULTIPLIER)
+      .set_jitter(fixed_reconnect_backoff ? 0.0
+                                          : GRPC_SUBCHANNEL_RECONNECT_JITTER)
+      .set_max_backoff(max_backoff_ms);
+}
+
+grpc_subchannel* grpc_subchannel_create(grpc_connector* connector,
                                         const grpc_subchannel_args* args) {
   grpc_subchannel_key* key = grpc_subchannel_key_create(args);
-  grpc_subchannel* c = grpc_subchannel_index_find(exec_ctx, key);
+  grpc_subchannel* c = grpc_subchannel_index_find(key);
   if (c) {
-    grpc_subchannel_key_destroy(exec_ctx, key);
+    grpc_subchannel_key_destroy(key);
     return c;
   }
 
-  GRPC_STATS_INC_CLIENT_SUBCHANNELS_CREATED(exec_ctx);
+  GRPC_STATS_INC_CLIENT_SUBCHANNELS_CREATED();
   c = (grpc_subchannel*)gpr_zalloc(sizeof(*c));
   c->key = key;
   gpr_atm_no_barrier_store(&c->ref_pair, 1 << INTERNAL_REF_BITS);
@@ -311,10 +336,10 @@ grpc_subchannel* grpc_subchannel_create(grpc_exec_ctx* exec_ctx,
   c->pollset_set = grpc_pollset_set_create();
   grpc_resolved_address* addr =
       (grpc_resolved_address*)gpr_malloc(sizeof(*addr));
-  grpc_get_subchannel_address_arg(exec_ctx, args->args, addr);
+  grpc_get_subchannel_address_arg(args->args, addr);
   grpc_resolved_address* new_address = nullptr;
   grpc_channel_args* new_args = nullptr;
-  if (grpc_proxy_mappers_map_address(exec_ctx, addr, args->args, &new_address,
+  if (grpc_proxy_mappers_map_address(addr, args->args, &new_address,
                                      &new_args)) {
     GPR_ASSERT(new_address != nullptr);
     gpr_free(addr);
@@ -327,68 +352,34 @@ grpc_subchannel* grpc_subchannel_create(grpc_exec_ctx* exec_ctx,
       new_args != nullptr ? new_args : args->args, keys_to_remove,
       GPR_ARRAY_SIZE(keys_to_remove), &new_arg, 1);
   gpr_free(new_arg.value.string);
-  if (new_args != nullptr) grpc_channel_args_destroy(exec_ctx, new_args);
+  if (new_args != nullptr) grpc_channel_args_destroy(new_args);
   c->root_external_state_watcher.next = c->root_external_state_watcher.prev =
       &c->root_external_state_watcher;
-  GRPC_CLOSURE_INIT(&c->connected, subchannel_connected, c,
+  GRPC_CLOSURE_INIT(&c->on_connected, on_subchannel_connected, c,
                     grpc_schedule_on_exec_ctx);
   grpc_connectivity_state_init(&c->state_tracker, GRPC_CHANNEL_IDLE,
                                "subchannel");
-  int initial_backoff_ms =
-      GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS * 1000;
-  int min_backoff_ms = GRPC_SUBCHANNEL_RECONNECT_MIN_BACKOFF_SECONDS * 1000;
-  int max_backoff_ms = GRPC_SUBCHANNEL_RECONNECT_MAX_BACKOFF_SECONDS * 1000;
-  bool fixed_reconnect_backoff = false;
-  if (c->args) {
-    for (size_t i = 0; i < c->args->num_args; i++) {
-      if (0 == strcmp(c->args->args[i].key,
-                      "grpc.testing.fixed_reconnect_backoff_ms")) {
-        fixed_reconnect_backoff = true;
-        initial_backoff_ms = min_backoff_ms = max_backoff_ms =
-            grpc_channel_arg_get_integer(&c->args->args[i],
-                                         {initial_backoff_ms, 100, INT_MAX});
-      } else if (0 == strcmp(c->args->args[i].key,
-                             GRPC_ARG_MIN_RECONNECT_BACKOFF_MS)) {
-        fixed_reconnect_backoff = false;
-        min_backoff_ms = grpc_channel_arg_get_integer(
-            &c->args->args[i], {min_backoff_ms, 100, INT_MAX});
-      } else if (0 == strcmp(c->args->args[i].key,
-                             GRPC_ARG_MAX_RECONNECT_BACKOFF_MS)) {
-        fixed_reconnect_backoff = false;
-        max_backoff_ms = grpc_channel_arg_get_integer(
-            &c->args->args[i], {max_backoff_ms, 100, INT_MAX});
-      } else if (0 == strcmp(c->args->args[i].key,
-                             GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS)) {
-        fixed_reconnect_backoff = false;
-        initial_backoff_ms = grpc_channel_arg_get_integer(
-            &c->args->args[i], {initial_backoff_ms, 100, INT_MAX});
-      }
-    }
-  }
-  grpc_backoff_init(
-      &c->backoff_state, initial_backoff_ms,
-      fixed_reconnect_backoff ? 1.0
-                              : GRPC_SUBCHANNEL_RECONNECT_BACKOFF_MULTIPLIER,
-      fixed_reconnect_backoff ? 0.0 : GRPC_SUBCHANNEL_RECONNECT_JITTER,
-      min_backoff_ms, max_backoff_ms);
+  grpc_core::BackOff::Options backoff_options;
+  parse_args_for_backoff_values(args->args, &backoff_options,
+                                &c->min_connect_timeout_ms);
+  c->backoff.Init(backoff_options);
   gpr_mu_init(&c->mu);
 
-  return grpc_subchannel_index_register(exec_ctx, key, c);
+  return grpc_subchannel_index_register(key, c);
 }
 
-static void continue_connect_locked(grpc_exec_ctx* exec_ctx,
-                                    grpc_subchannel* c) {
+static void continue_connect_locked(grpc_subchannel* c) {
   grpc_connect_in_args args;
-
   args.interested_parties = c->pollset_set;
-  args.deadline = c->backoff_result.current_deadline;
+  const grpc_millis min_deadline =
+      c->min_connect_timeout_ms + grpc_core::ExecCtx::Get()->Now();
+  c->next_attempt_deadline = c->backoff->NextAttemptTime();
+  args.deadline = std::max(c->next_attempt_deadline, min_deadline);
   args.channel_args = c->args;
-
-  grpc_connectivity_state_set(exec_ctx, &c->state_tracker,
-                              GRPC_CHANNEL_CONNECTING, GRPC_ERROR_NONE,
-                              "state_change");
-  grpc_connector_connect(exec_ctx, c->connector, &args, &c->connecting_result,
-                         &c->connected);
+  grpc_connectivity_state_set(&c->state_tracker, GRPC_CHANNEL_CONNECTING,
+                              GRPC_ERROR_NONE, "state_change");
+  grpc_connector_connect(c->connector, &args, &c->connecting_result,
+                         &c->on_connected);
 }
 
 grpc_connectivity_state grpc_subchannel_check_connectivity(grpc_subchannel* c,
@@ -400,24 +391,23 @@ grpc_connectivity_state grpc_subchannel_check_connectivity(grpc_subchannel* c,
   return state;
 }
 
-static void on_external_state_watcher_done(grpc_exec_ctx* exec_ctx, void* arg,
-                                           grpc_error* error) {
+static void on_external_state_watcher_done(void* arg, grpc_error* error) {
   external_state_watcher* w = (external_state_watcher*)arg;
   grpc_closure* follow_up = w->notify;
   if (w->pollset_set != nullptr) {
-    grpc_pollset_set_del_pollset_set(exec_ctx, w->subchannel->pollset_set,
+    grpc_pollset_set_del_pollset_set(w->subchannel->pollset_set,
                                      w->pollset_set);
   }
   gpr_mu_lock(&w->subchannel->mu);
   w->next->prev = w->prev;
   w->prev->next = w->next;
   gpr_mu_unlock(&w->subchannel->mu);
-  GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, w->subchannel, "external_state_watcher");
+  GRPC_SUBCHANNEL_WEAK_UNREF(w->subchannel, "external_state_watcher");
   gpr_free(w);
-  GRPC_CLOSURE_RUN(exec_ctx, follow_up, GRPC_ERROR_REF(error));
+  GRPC_CLOSURE_RUN(follow_up, GRPC_ERROR_REF(error));
 }
 
-static void on_alarm(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+static void on_alarm(void* arg, grpc_error* error) {
   grpc_subchannel* c = (grpc_subchannel*)arg;
   gpr_mu_lock(&c->mu);
   c->have_alarm = false;
@@ -429,18 +419,16 @@ static void on_alarm(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
   }
   if (error == GRPC_ERROR_NONE) {
     gpr_log(GPR_INFO, "Failed to connect to channel, retrying");
-    c->backoff_result = grpc_backoff_step(exec_ctx, &c->backoff_state);
-    continue_connect_locked(exec_ctx, c);
+    continue_connect_locked(c);
     gpr_mu_unlock(&c->mu);
   } else {
     gpr_mu_unlock(&c->mu);
-    GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, c, "connecting");
+    GRPC_SUBCHANNEL_WEAK_UNREF(c, "connecting");
   }
   GRPC_ERROR_UNREF(error);
 }
 
-static void maybe_start_connecting_locked(grpc_exec_ctx* exec_ctx,
-                                          grpc_subchannel* c) {
+static void maybe_start_connecting_locked(grpc_subchannel* c) {
   if (c->disconnected) {
     /* Don't try to connect if we're already disconnected */
     return;
@@ -451,7 +439,7 @@ static void maybe_start_connecting_locked(grpc_exec_ctx* exec_ctx,
     return;
   }
 
-  if (GET_CONNECTED_SUBCHANNEL(c, no_barrier) != nullptr) {
+  if (c->connected_subchannel != nullptr) {
     /* Already connected: don't restart */
     return;
   }
@@ -466,28 +454,26 @@ static void maybe_start_connecting_locked(grpc_exec_ctx* exec_ctx,
 
   if (!c->backoff_begun) {
     c->backoff_begun = true;
-    c->backoff_result = grpc_backoff_begin(exec_ctx, &c->backoff_state);
-    continue_connect_locked(exec_ctx, c);
+    continue_connect_locked(c);
   } else {
     GPR_ASSERT(!c->have_alarm);
     c->have_alarm = true;
     const grpc_millis time_til_next =
-        c->backoff_result.next_attempt_start_time - grpc_exec_ctx_now(exec_ctx);
+        c->next_attempt_deadline - grpc_core::ExecCtx::Get()->Now();
     if (time_til_next <= 0) {
-      gpr_log(GPR_INFO, "Retry immediately");
+      gpr_log(GPR_INFO, "Subchannel %p: Retry immediately", c);
     } else {
-      gpr_log(GPR_INFO, "Retry in %" PRIdPTR " milliseconds", time_til_next);
+      gpr_log(GPR_INFO, "Subchannel %p: Retry in %" PRIdPTR " milliseconds", c,
+              time_til_next);
     }
     GRPC_CLOSURE_INIT(&c->on_alarm, on_alarm, c, grpc_schedule_on_exec_ctx);
-    grpc_timer_init(exec_ctx, &c->alarm,
-                    c->backoff_result.next_attempt_start_time, &c->on_alarm);
+    grpc_timer_init(&c->alarm, c->next_attempt_deadline, &c->on_alarm);
   }
 }
 
 void grpc_subchannel_notify_on_state_change(
-    grpc_exec_ctx* exec_ctx, grpc_subchannel* c,
-    grpc_pollset_set* interested_parties, grpc_connectivity_state* state,
-    grpc_closure* notify) {
+    grpc_subchannel* c, grpc_pollset_set* interested_parties,
+    grpc_connectivity_state* state, grpc_closure* notify) {
   external_state_watcher* w;
 
   if (state == nullptr) {
@@ -495,8 +481,8 @@ void grpc_subchannel_notify_on_state_change(
     for (w = c->root_external_state_watcher.next;
          w != &c->root_external_state_watcher; w = w->next) {
       if (w->notify == notify) {
-        grpc_connectivity_state_notify_on_state_change(
-            exec_ctx, &c->state_tracker, nullptr, &w->closure);
+        grpc_connectivity_state_notify_on_state_change(&c->state_tracker,
+                                                       nullptr, &w->closure);
       }
     }
     gpr_mu_unlock(&c->mu);
@@ -508,172 +494,144 @@ void grpc_subchannel_notify_on_state_change(
     GRPC_CLOSURE_INIT(&w->closure, on_external_state_watcher_done, w,
                       grpc_schedule_on_exec_ctx);
     if (interested_parties != nullptr) {
-      grpc_pollset_set_add_pollset_set(exec_ctx, c->pollset_set,
-                                       interested_parties);
+      grpc_pollset_set_add_pollset_set(c->pollset_set, interested_parties);
     }
     GRPC_SUBCHANNEL_WEAK_REF(c, "external_state_watcher");
     gpr_mu_lock(&c->mu);
     w->next = &c->root_external_state_watcher;
     w->prev = w->next->prev;
     w->next->prev = w->prev->next = w;
-    grpc_connectivity_state_notify_on_state_change(exec_ctx, &c->state_tracker,
-                                                   state, &w->closure);
-    maybe_start_connecting_locked(exec_ctx, c);
+    grpc_connectivity_state_notify_on_state_change(&c->state_tracker, state,
+                                                   &w->closure);
+    maybe_start_connecting_locked(c);
     gpr_mu_unlock(&c->mu);
   }
 }
 
-void grpc_connected_subchannel_process_transport_op(
-    grpc_exec_ctx* exec_ctx, grpc_connected_subchannel* con,
-    grpc_transport_op* op) {
-  grpc_channel_stack* channel_stack = CHANNEL_STACK_FROM_CONNECTION(con);
-  grpc_channel_element* top_elem = grpc_channel_stack_element(channel_stack, 0);
-  top_elem->filter->start_transport_op(exec_ctx, top_elem, op);
-}
-
-static void subchannel_on_child_state_changed(grpc_exec_ctx* exec_ctx, void* p,
-                                              grpc_error* error) {
-  state_watcher* sw = (state_watcher*)p;
-  grpc_subchannel* c = sw->subchannel;
+static void on_connected_subchannel_connectivity_changed(void* p,
+                                                         grpc_error* error) {
+  state_watcher* connected_subchannel_watcher = (state_watcher*)p;
+  grpc_subchannel* c = connected_subchannel_watcher->subchannel;
   gpr_mu* mu = &c->mu;
 
   gpr_mu_lock(mu);
 
-  /* if we failed just leave this closure */
-  if (sw->connectivity_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-    /* any errors on a subchannel ==> we're done, create a new one */
-    sw->connectivity_state = GRPC_CHANNEL_SHUTDOWN;
-  }
-  grpc_connectivity_state_set(exec_ctx, &c->state_tracker,
-                              sw->connectivity_state, GRPC_ERROR_REF(error),
-                              "reflect_child");
-  if (sw->connectivity_state != GRPC_CHANNEL_SHUTDOWN) {
-    grpc_connected_subchannel_notify_on_state_change(
-        exec_ctx, GET_CONNECTED_SUBCHANNEL(c, no_barrier), nullptr,
-        &sw->connectivity_state, &sw->closure);
-    GRPC_SUBCHANNEL_WEAK_REF(c, "state_watcher");
-    sw = nullptr;
+  switch (connected_subchannel_watcher->connectivity_state) {
+    case GRPC_CHANNEL_TRANSIENT_FAILURE:
+    case GRPC_CHANNEL_SHUTDOWN: {
+      if (!c->disconnected && c->connected_subchannel != nullptr) {
+        if (grpc_trace_stream_refcount.enabled()) {
+          gpr_log(GPR_INFO,
+                  "Connected subchannel %p of subchannel %p has gone into %s. "
+                  "Attempting to reconnect.",
+                  c->connected_subchannel.get(), c,
+                  grpc_connectivity_state_name(
+                      connected_subchannel_watcher->connectivity_state));
+        }
+        c->connected_subchannel.reset();
+        grpc_connectivity_state_set(&c->state_tracker,
+                                    GRPC_CHANNEL_TRANSIENT_FAILURE,
+                                    GRPC_ERROR_REF(error), "reflect_child");
+        c->backoff_begun = false;
+        c->backoff->Reset();
+        maybe_start_connecting_locked(c);
+      } else {
+        connected_subchannel_watcher->connectivity_state =
+            GRPC_CHANNEL_SHUTDOWN;
+      }
+      break;
+    }
+    default: {
+      grpc_connectivity_state_set(
+          &c->state_tracker, connected_subchannel_watcher->connectivity_state,
+          GRPC_ERROR_REF(error), "reflect_child");
+      GRPC_SUBCHANNEL_WEAK_REF(c, "state_watcher");
+      c->connected_subchannel->NotifyOnStateChange(
+          nullptr, &connected_subchannel_watcher->connectivity_state,
+          &connected_subchannel_watcher->closure);
+      connected_subchannel_watcher = nullptr;
+    }
   }
-
   gpr_mu_unlock(mu);
-  GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, c, "state_watcher");
-  gpr_free(sw);
-}
-
-static void connected_subchannel_state_op(grpc_exec_ctx* exec_ctx,
-                                          grpc_connected_subchannel* con,
-                                          grpc_pollset_set* interested_parties,
-                                          grpc_connectivity_state* state,
-                                          grpc_closure* closure) {
-  grpc_transport_op* op = grpc_make_transport_op(nullptr);
-  grpc_channel_element* elem;
-  op->connectivity_state = state;
-  op->on_connectivity_state_change = closure;
-  op->bind_pollset_set = interested_parties;
-  elem = grpc_channel_stack_element(CHANNEL_STACK_FROM_CONNECTION(con), 0);
-  elem->filter->start_transport_op(exec_ctx, elem, op);
-}
-
-void grpc_connected_subchannel_notify_on_state_change(
-    grpc_exec_ctx* exec_ctx, grpc_connected_subchannel* con,
-    grpc_pollset_set* interested_parties, grpc_connectivity_state* state,
-    grpc_closure* closure) {
-  connected_subchannel_state_op(exec_ctx, con, interested_parties, state,
-                                closure);
+  GRPC_SUBCHANNEL_WEAK_UNREF(c, "state_watcher");
+  gpr_free(connected_subchannel_watcher);
 }
 
-void grpc_connected_subchannel_ping(grpc_exec_ctx* exec_ctx,
-                                    grpc_connected_subchannel* con,
-                                    grpc_closure* closure) {
-  grpc_transport_op* op = grpc_make_transport_op(nullptr);
-  grpc_channel_element* elem;
-  op->send_ping = closure;
-  elem = grpc_channel_stack_element(CHANNEL_STACK_FROM_CONNECTION(con), 0);
-  elem->filter->start_transport_op(exec_ctx, elem, op);
-}
-
-static bool publish_transport_locked(grpc_exec_ctx* exec_ctx,
-                                     grpc_subchannel* c) {
-  grpc_connected_subchannel* con;
-  grpc_channel_stack* stk;
-  state_watcher* sw_subchannel;
-
+static bool publish_transport_locked(grpc_subchannel* c) {
   /* construct channel stack */
   grpc_channel_stack_builder* builder = grpc_channel_stack_builder_create();
   grpc_channel_stack_builder_set_channel_arguments(
-      exec_ctx, builder, c->connecting_result.channel_args);
+      builder, c->connecting_result.channel_args);
   grpc_channel_stack_builder_set_transport(builder,
                                            c->connecting_result.transport);
 
-  if (!grpc_channel_init_create_stack(exec_ctx, builder,
-                                      GRPC_CLIENT_SUBCHANNEL)) {
-    grpc_channel_stack_builder_destroy(exec_ctx, builder);
+  if (!grpc_channel_init_create_stack(builder, GRPC_CLIENT_SUBCHANNEL)) {
+    grpc_channel_stack_builder_destroy(builder);
     return false;
   }
+  grpc_channel_stack* stk;
   grpc_error* error = grpc_channel_stack_builder_finish(
-      exec_ctx, builder, 0, 1, connection_destroy, nullptr, (void**)&con);
+      builder, 0, 1, connection_destroy, nullptr, (void**)&stk);
   if (error != GRPC_ERROR_NONE) {
-    grpc_transport_destroy(exec_ctx, c->connecting_result.transport);
+    grpc_transport_destroy(c->connecting_result.transport);
     gpr_log(GPR_ERROR, "error initializing subchannel stack: %s",
             grpc_error_string(error));
     GRPC_ERROR_UNREF(error);
     return false;
   }
-  stk = CHANNEL_STACK_FROM_CONNECTION(con);
   memset(&c->connecting_result, 0, sizeof(c->connecting_result));
 
   /* initialize state watcher */
-  sw_subchannel = (state_watcher*)gpr_malloc(sizeof(*sw_subchannel));
-  sw_subchannel->subchannel = c;
-  sw_subchannel->connectivity_state = GRPC_CHANNEL_READY;
-  GRPC_CLOSURE_INIT(&sw_subchannel->closure, subchannel_on_child_state_changed,
-                    sw_subchannel, grpc_schedule_on_exec_ctx);
+  state_watcher* connected_subchannel_watcher =
+      (state_watcher*)gpr_zalloc(sizeof(*connected_subchannel_watcher));
+  connected_subchannel_watcher->subchannel = c;
+  connected_subchannel_watcher->connectivity_state = GRPC_CHANNEL_READY;
+  GRPC_CLOSURE_INIT(&connected_subchannel_watcher->closure,
+                    on_connected_subchannel_connectivity_changed,
+                    connected_subchannel_watcher, grpc_schedule_on_exec_ctx);
 
   if (c->disconnected) {
-    gpr_free(sw_subchannel);
-    grpc_channel_stack_destroy(exec_ctx, stk);
-    gpr_free(con);
+    gpr_free(connected_subchannel_watcher);
+    grpc_channel_stack_destroy(stk);
+    gpr_free(stk);
     return false;
   }
 
   /* publish */
-  /* TODO(ctiller): this full barrier seems to clear up a TSAN failure.
-                    I'd have expected the rel_cas below to be enough, but
-                    seemingly it's not.
-                    Re-evaluate if we really need this. */
-  gpr_atm_full_barrier();
-  GPR_ASSERT(gpr_atm_rel_cas(&c->connected_subchannel, 0, (gpr_atm)con));
+  c->connected_subchannel.reset(
+      grpc_core::New<grpc_core::ConnectedSubchannel>(stk));
+  gpr_log(GPR_INFO, "New connected subchannel at %p for subchannel %p",
+          c->connected_subchannel.get(), c);
 
   /* setup subchannel watching connected subchannel for changes; subchannel
      ref for connecting is donated to the state watcher */
   GRPC_SUBCHANNEL_WEAK_REF(c, "state_watcher");
-  GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, c, "connecting");
-  grpc_connected_subchannel_notify_on_state_change(
-      exec_ctx, con, c->pollset_set, &sw_subchannel->connectivity_state,
-      &sw_subchannel->closure);
+  GRPC_SUBCHANNEL_WEAK_UNREF(c, "connecting");
+  c->connected_subchannel->NotifyOnStateChange(
+      c->pollset_set, &connected_subchannel_watcher->connectivity_state,
+      &connected_subchannel_watcher->closure);
 
   /* signal completion */
-  grpc_connectivity_state_set(exec_ctx, &c->state_tracker, GRPC_CHANNEL_READY,
+  grpc_connectivity_state_set(&c->state_tracker, GRPC_CHANNEL_READY,
                               GRPC_ERROR_NONE, "connected");
   return true;
 }
 
-static void subchannel_connected(grpc_exec_ctx* exec_ctx, void* arg,
-                                 grpc_error* error) {
+static void on_subchannel_connected(void* arg, grpc_error* error) {
   grpc_subchannel* c = (grpc_subchannel*)arg;
   grpc_channel_args* delete_channel_args = c->connecting_result.channel_args;
 
-  GRPC_SUBCHANNEL_WEAK_REF(c, "connected");
+  GRPC_SUBCHANNEL_WEAK_REF(c, "on_subchannel_connected");
   gpr_mu_lock(&c->mu);
   c->connecting = false;
   if (c->connecting_result.transport != nullptr &&
-      publish_transport_locked(exec_ctx, c)) {
+      publish_transport_locked(c)) {
     /* do nothing, transport was published */
   } else if (c->disconnected) {
-    GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, c, "connecting");
+    GRPC_SUBCHANNEL_WEAK_UNREF(c, "connecting");
   } else {
     grpc_connectivity_state_set(
-        exec_ctx, &c->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE,
+        &c->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE,
         grpc_error_set_int(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                                "Connect Failed", &error, 1),
                            GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE),
@@ -682,27 +640,26 @@ static void subchannel_connected(grpc_exec_ctx* exec_ctx, void* arg,
     const char* errmsg = grpc_error_string(error);
     gpr_log(GPR_INFO, "Connect failed: %s", errmsg);
 
-    maybe_start_connecting_locked(exec_ctx, c);
-    GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, c, "connecting");
+    maybe_start_connecting_locked(c);
+    GRPC_SUBCHANNEL_WEAK_UNREF(c, "connecting");
   }
   gpr_mu_unlock(&c->mu);
-  GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, c, "connected");
-  grpc_channel_args_destroy(exec_ctx, delete_channel_args);
+  GRPC_SUBCHANNEL_WEAK_UNREF(c, "connected");
+  grpc_channel_args_destroy(delete_channel_args);
 }
 
 /*
  * grpc_subchannel_call implementation
  */
 
-static void subchannel_call_destroy(grpc_exec_ctx* exec_ctx, void* call,
-                                    grpc_error* error) {
+static void subchannel_call_destroy(void* call, grpc_error* error) {
   grpc_subchannel_call* c = (grpc_subchannel_call*)call;
   GPR_ASSERT(c->schedule_closure_after_destroy != nullptr);
   GPR_TIMER_BEGIN("grpc_subchannel_call_unref.destroy", 0);
-  grpc_connected_subchannel* connection = c->connection;
-  grpc_call_stack_destroy(exec_ctx, SUBCHANNEL_CALL_TO_CALL_STACK(c), nullptr,
+  grpc_core::ConnectedSubchannel* connection = c->connection;
+  grpc_call_stack_destroy(SUBCHANNEL_CALL_TO_CALL_STACK(c), nullptr,
                           c->schedule_closure_after_destroy);
-  GRPC_CONNECTED_SUBCHANNEL_UNREF(exec_ctx, connection, "subchannel_call");
+  connection->Unref(DEBUG_LOCATION, "subchannel_call");
   GPR_TIMER_END("grpc_subchannel_call_unref.destroy", 0);
 }
 
@@ -718,26 +675,27 @@ void grpc_subchannel_call_ref(
   GRPC_CALL_STACK_REF(SUBCHANNEL_CALL_TO_CALL_STACK(c), REF_REASON);
 }
 
-void grpc_subchannel_call_unref(grpc_exec_ctx* exec_ctx,
-                                grpc_subchannel_call* c
-                                    GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
-  GRPC_CALL_STACK_UNREF(exec_ctx, SUBCHANNEL_CALL_TO_CALL_STACK(c), REF_REASON);
+void grpc_subchannel_call_unref(
+    grpc_subchannel_call* c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+  GRPC_CALL_STACK_UNREF(SUBCHANNEL_CALL_TO_CALL_STACK(c), REF_REASON);
 }
 
-void grpc_subchannel_call_process_op(grpc_exec_ctx* exec_ctx,
-                                     grpc_subchannel_call* call,
+void grpc_subchannel_call_process_op(grpc_subchannel_call* call,
                                      grpc_transport_stream_op_batch* batch) {
   GPR_TIMER_BEGIN("grpc_subchannel_call_process_op", 0);
   grpc_call_stack* call_stack = SUBCHANNEL_CALL_TO_CALL_STACK(call);
   grpc_call_element* top_elem = grpc_call_stack_element(call_stack, 0);
   GRPC_CALL_LOG_OP(GPR_INFO, top_elem, batch);
-  top_elem->filter->start_transport_stream_op_batch(exec_ctx, top_elem, batch);
+  top_elem->filter->start_transport_stream_op_batch(top_elem, batch);
   GPR_TIMER_END("grpc_subchannel_call_process_op", 0);
 }
 
-grpc_connected_subchannel* grpc_subchannel_get_connected_subchannel(
-    grpc_subchannel* c) {
-  return GET_CONNECTED_SUBCHANNEL(c, acq);
+grpc_core::RefCountedPtr<grpc_core::ConnectedSubchannel>
+grpc_subchannel_get_connected_subchannel(grpc_subchannel* c) {
+  gpr_mu_lock(&c->mu);
+  auto copy = c->connected_subchannel;
+  gpr_mu_unlock(&c->mu);
+  return copy;
 }
 
 const grpc_subchannel_key* grpc_subchannel_get_key(
@@ -745,56 +703,25 @@ const grpc_subchannel_key* grpc_subchannel_get_key(
   return subchannel->key;
 }
 
-grpc_error* grpc_connected_subchannel_create_call(
-    grpc_exec_ctx* exec_ctx, grpc_connected_subchannel* con,
-    const grpc_connected_subchannel_call_args* args,
-    grpc_subchannel_call** call) {
-  grpc_channel_stack* chanstk = CHANNEL_STACK_FROM_CONNECTION(con);
-  *call = (grpc_subchannel_call*)gpr_arena_alloc(
-      args->arena, sizeof(grpc_subchannel_call) + chanstk->call_stack_size);
-  grpc_call_stack* callstk = SUBCHANNEL_CALL_TO_CALL_STACK(*call);
-  (*call)->connection = GRPC_CONNECTED_SUBCHANNEL_REF(con, "subchannel_call");
-  const grpc_call_element_args call_args = {
-      callstk,            /* call_stack */
-      nullptr,            /* server_transport_data */
-      args->context,      /* context */
-      args->path,         /* path */
-      args->start_time,   /* start_time */
-      args->deadline,     /* deadline */
-      args->arena,        /* arena */
-      args->call_combiner /* call_combiner */
-  };
-  grpc_error* error = grpc_call_stack_init(
-      exec_ctx, chanstk, 1, subchannel_call_destroy, *call, &call_args);
-  if (error != GRPC_ERROR_NONE) {
-    const char* error_string = grpc_error_string(error);
-    gpr_log(GPR_ERROR, "error: %s", error_string);
-    return error;
-  }
-  grpc_call_stack_set_pollset_or_pollset_set(exec_ctx, callstk, args->pollent);
-  return GRPC_ERROR_NONE;
-}
-
 grpc_call_stack* grpc_subchannel_call_get_call_stack(
     grpc_subchannel_call* subchannel_call) {
   return SUBCHANNEL_CALL_TO_CALL_STACK(subchannel_call);
 }
 
-static void grpc_uri_to_sockaddr(grpc_exec_ctx* exec_ctx, const char* uri_str,
+static void grpc_uri_to_sockaddr(const char* uri_str,
                                  grpc_resolved_address* addr) {
-  grpc_uri* uri = grpc_uri_parse(exec_ctx, uri_str, 0 /* suppress_errors */);
+  grpc_uri* uri = grpc_uri_parse(uri_str, 0 /* suppress_errors */);
   GPR_ASSERT(uri != nullptr);
   if (!grpc_parse_uri(uri, addr)) memset(addr, 0, sizeof(*addr));
   grpc_uri_destroy(uri);
 }
 
-void grpc_get_subchannel_address_arg(grpc_exec_ctx* exec_ctx,
-                                     const grpc_channel_args* args,
+void grpc_get_subchannel_address_arg(const grpc_channel_args* args,
                                      grpc_resolved_address* addr) {
   const char* addr_uri_str = grpc_get_subchannel_address_uri_arg(args);
   memset(addr, 0, sizeof(*addr));
   if (*addr_uri_str != '\0') {
-    grpc_uri_to_sockaddr(exec_ctx, addr_uri_str, addr);
+    grpc_uri_to_sockaddr(addr_uri_str, addr);
   }
 }
 
@@ -811,3 +738,64 @@ grpc_arg grpc_create_subchannel_address_arg(const grpc_resolved_address* addr) {
       (char*)GRPC_ARG_SUBCHANNEL_ADDRESS,
       addr->len > 0 ? grpc_sockaddr_to_uri(addr) : gpr_strdup(""));
 }
+
+namespace grpc_core {
+ConnectedSubchannel::ConnectedSubchannel(grpc_channel_stack* channel_stack)
+    : grpc_core::RefCountedWithTracing(&grpc_trace_stream_refcount),
+      channel_stack_(channel_stack) {}
+
+ConnectedSubchannel::~ConnectedSubchannel() {
+  GRPC_CHANNEL_STACK_UNREF(channel_stack_, "connected_subchannel_dtor");
+}
+
+void ConnectedSubchannel::NotifyOnStateChange(
+    grpc_pollset_set* interested_parties, grpc_connectivity_state* state,
+    grpc_closure* closure) {
+  grpc_transport_op* op = grpc_make_transport_op(nullptr);
+  grpc_channel_element* elem;
+  op->connectivity_state = state;
+  op->on_connectivity_state_change = closure;
+  op->bind_pollset_set = interested_parties;
+  elem = grpc_channel_stack_element(channel_stack_, 0);
+  elem->filter->start_transport_op(elem, op);
+}
+
+void ConnectedSubchannel::Ping(grpc_closure* on_initiate,
+                               grpc_closure* on_ack) {
+  grpc_transport_op* op = grpc_make_transport_op(nullptr);
+  grpc_channel_element* elem;
+  op->send_ping.on_initiate = on_initiate;
+  op->send_ping.on_ack = on_ack;
+  elem = grpc_channel_stack_element(channel_stack_, 0);
+  elem->filter->start_transport_op(elem, op);
+}
+
+grpc_error* ConnectedSubchannel::CreateCall(const CallArgs& args,
+                                            grpc_subchannel_call** call) {
+  *call = (grpc_subchannel_call*)gpr_arena_alloc(
+      args.arena,
+      sizeof(grpc_subchannel_call) + channel_stack_->call_stack_size);
+  grpc_call_stack* callstk = SUBCHANNEL_CALL_TO_CALL_STACK(*call);
+  Ref(DEBUG_LOCATION, "subchannel_call");
+  (*call)->connection = this;
+  const grpc_call_element_args call_args = {
+      callstk,           /* call_stack */
+      nullptr,           /* server_transport_data */
+      args.context,      /* context */
+      args.path,         /* path */
+      args.start_time,   /* start_time */
+      args.deadline,     /* deadline */
+      args.arena,        /* arena */
+      args.call_combiner /* call_combiner */
+  };
+  grpc_error* error = grpc_call_stack_init(
+      channel_stack_, 1, subchannel_call_destroy, *call, &call_args);
+  if (error != GRPC_ERROR_NONE) {
+    const char* error_string = grpc_error_string(error);
+    gpr_log(GPR_ERROR, "error: %s", error_string);
+    return error;
+  }
+  grpc_call_stack_set_pollset_or_pollset_set(callstk, args.pollent);
+  return GRPC_ERROR_NONE;
+}
+}  // namespace grpc_core