grpc 1.25.0 → 1.26.0.pre1

data/src/core/ext/filters/http/server/http_server_filter.cc

@@ -99,8 +99,7 @@ struct channel_data {
 
 }  // namespace
 
-static grpc_error* hs_filter_outgoing_metadata(grpc_call_element* elem,
-                                               grpc_metadata_batch* b) {
+static grpc_error* hs_filter_outgoing_metadata(grpc_metadata_batch* b) {
   if (b->idx.named.grpc_message != nullptr) {
     grpc_slice pct_encoded_msg = grpc_percent_encode_slice(
         GRPC_MDVALUE(b->idx.named.grpc_message->md),
@@ -364,7 +363,8 @@ static void hs_recv_initial_metadata_ready(void* user_data, grpc_error* err) {
                              "resuming hs_recv_trailing_metadata_ready from "
                              "hs_recv_initial_metadata_ready");
   }
-  GRPC_CLOSURE_RUN(calld->original_recv_initial_metadata_ready, err);
+  grpc_core::Closure::Run(DEBUG_LOCATION,
+                          calld->original_recv_initial_metadata_ready, err);
 }
 
 static void hs_recv_message_ready(void* user_data, grpc_error* err) {
@@ -379,7 +379,8 @@ static void hs_recv_message_ready(void* user_data, grpc_error* err) {
       calld->recv_message->reset(calld->read_stream.get());
       calld->have_read_stream = false;
     }
-    GRPC_CLOSURE_RUN(calld->original_recv_message_ready, GRPC_ERROR_REF(err));
+    grpc_core::Closure::Run(DEBUG_LOCATION, calld->original_recv_message_ready,
+                            GRPC_ERROR_REF(err));
   } else {
     // We have not yet seen the recv_initial_metadata callback, so we
     // need to wait to see if this is a GET request.
@@ -405,7 +406,8 @@ static void hs_recv_trailing_metadata_ready(void* user_data, grpc_error* err) {
   err = grpc_error_add_child(
       GRPC_ERROR_REF(err),
       GRPC_ERROR_REF(calld->recv_initial_metadata_ready_error));
-  GRPC_CLOSURE_RUN(calld->original_recv_trailing_metadata_ready, err);
+  grpc_core::Closure::Run(DEBUG_LOCATION,
+                          calld->original_recv_trailing_metadata_ready, err);
 }
 
 static grpc_error* hs_mutate_op(grpc_call_element* elem,
@@ -427,10 +429,9 @@ static grpc_error* hs_mutate_op(grpc_call_element* elem,
                      &calld->content_type,
                      GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC,
                      GRPC_BATCH_CONTENT_TYPE));
-    hs_add_error(
-        error_name, &error,
-        hs_filter_outgoing_metadata(
-            elem, op->payload->send_initial_metadata.send_initial_metadata));
+    hs_add_error(error_name, &error,
+                 hs_filter_outgoing_metadata(
+                     op->payload->send_initial_metadata.send_initial_metadata));
     if (error != GRPC_ERROR_NONE) return error;
   }
 
@@ -463,7 +464,7 @@ static grpc_error* hs_mutate_op(grpc_call_element* elem,
 
   if (op->send_trailing_metadata) {
     grpc_error* error = hs_filter_outgoing_metadata(
-        elem, op->payload->send_trailing_metadata.send_trailing_metadata);
+        op->payload->send_trailing_metadata.send_trailing_metadata);
     if (error != GRPC_ERROR_NONE) return error;
   }
 
@@ -492,8 +493,8 @@ static grpc_error* hs_init_call_elem(grpc_call_element* elem,
 
 /* Destructor for call_data */
 static void hs_destroy_call_elem(grpc_call_element* elem,
-                                 const grpc_call_final_info* final_info,
-                                 grpc_closure* ignored) {
+                                 const grpc_call_final_info* /*final_info*/,
+                                 grpc_closure* /*ignored*/) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->~call_data();
 }
@@ -511,7 +512,7 @@ static grpc_error* hs_init_channel_elem(grpc_channel_element* elem,
 }
 
 /* Destructor for channel data */
-static void hs_destroy_channel_elem(grpc_channel_element* elem) {}
+static void hs_destroy_channel_elem(grpc_channel_element* /*elem*/) {}
 
 const grpc_channel_filter grpc_http_server_filter = {
     hs_start_transport_stream_op_batch,

data/src/core/ext/filters/max_age/max_age_filter.cc

@@ -206,7 +206,7 @@ static void decrease_call_count(channel_data* chand) {
   }
 }
 
-static void start_max_idle_timer_after_init(void* arg, grpc_error* error) {
+static void start_max_idle_timer_after_init(void* arg, grpc_error* /*error*/) {
   channel_data* chand = static_cast<channel_data*>(arg);
   /* Decrease call_count. If there are no active calls at this time,
      max_idle_timer will start here. If the number of active calls is not 0,
@@ -257,7 +257,7 @@ class ConnectivityWatcher : public AsyncConnectivityStateWatcherInterface {
 
 }  // namespace grpc_core
 
-static void start_max_age_timer_after_init(void* arg, grpc_error* error) {
+static void start_max_age_timer_after_init(void* arg, grpc_error* /*error*/) {
   channel_data* chand = static_cast<channel_data*>(arg);
   gpr_mu_lock(&chand->max_age_timer_mu);
   chand->max_age_timer_pending = true;
@@ -267,8 +267,7 @@ static void start_max_age_timer_after_init(void* arg, grpc_error* error) {
                   &chand->close_max_age_channel);
   gpr_mu_unlock(&chand->max_age_timer_mu);
   grpc_transport_op* op = grpc_make_transport_op(nullptr);
-  op->start_connectivity_watch.reset(
-      grpc_core::New<grpc_core::ConnectivityWatcher>(chand));
+  op->start_connectivity_watch.reset(new grpc_core::ConnectivityWatcher(chand));
   op->start_connectivity_watch_state = GRPC_CHANNEL_IDLE;
   grpc_channel_next_op(grpc_channel_stack_element(chand->channel_stack, 0), op);
   GRPC_CHANNEL_STACK_UNREF(chand->channel_stack,
@@ -276,7 +275,7 @@ static void start_max_age_timer_after_init(void* arg, grpc_error* error) {
 }
 
 static void start_max_age_grace_timer_after_goaway_op(void* arg,
-                                                      grpc_error* error) {
+                                                      grpc_error* /*error*/) {
   channel_data* chand = static_cast<channel_data*>(arg);
   gpr_mu_lock(&chand->max_age_timer_mu);
   chand->max_age_grace_timer_pending = true;
@@ -407,17 +406,17 @@ add_random_max_connection_age_jitter_and_convert_to_grpc_millis(int value) {
 }
 
 /* Constructor for call_data. */
-static grpc_error* max_age_init_call_elem(grpc_call_element* elem,
-                                          const grpc_call_element_args* args) {
+static grpc_error* max_age_init_call_elem(
+    grpc_call_element* elem, const grpc_call_element_args* /*args*/) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   increase_call_count(chand);
   return GRPC_ERROR_NONE;
 }
 
 /* Destructor for call_data. */
-static void max_age_destroy_call_elem(grpc_call_element* elem,
-                                      const grpc_call_final_info* final_info,
-                                      grpc_closure* ignored) {
+static void max_age_destroy_call_elem(
+    grpc_call_element* elem, const grpc_call_final_info* /*final_info*/,
+    grpc_closure* /*ignored*/) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   decrease_call_count(chand);
 }
@@ -492,7 +491,9 @@ static grpc_error* max_age_init_channel_elem(grpc_channel_element* elem,
        initialization is done. */
     GRPC_CHANNEL_STACK_REF(chand->channel_stack,
                            "max_age start_max_age_timer_after_init");
-    GRPC_CLOSURE_SCHED(&chand->start_max_age_timer_after_init, GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION,
+                            &chand->start_max_age_timer_after_init,
+                            GRPC_ERROR_NONE);
   }
 
   /* Initialize the number of calls as 1, so that the max_idle_timer will not
@@ -501,8 +502,9 @@ static grpc_error* max_age_init_channel_elem(grpc_channel_element* elem,
   if (chand->max_connection_idle != GRPC_MILLIS_INF_FUTURE) {
     GRPC_CHANNEL_STACK_REF(chand->channel_stack,
                            "max_age start_max_idle_timer_after_init");
-    GRPC_CLOSURE_SCHED(&chand->start_max_idle_timer_after_init,
-                       GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION,
+                            &chand->start_max_idle_timer_after_init,
+                            GRPC_ERROR_NONE);
   }
   return GRPC_ERROR_NONE;
 }
@@ -527,7 +529,7 @@ const grpc_channel_filter grpc_max_age_filter = {
     "max_age"};
 
 static bool maybe_add_max_age_filter(grpc_channel_stack_builder* builder,
-                                     void* arg) {
+                                     void* /*arg*/) {
   const grpc_channel_args* channel_args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
   bool enable =

data/src/core/ext/filters/message_size/message_size_filter.cc

@@ -44,8 +44,9 @@ namespace {
 size_t g_message_size_parser_index;
 }  // namespace
 
-UniquePtr<ServiceConfig::ParsedConfig> MessageSizeParser::ParsePerMethodParams(
-    const grpc_json* json, grpc_error** error) {
+std::unique_ptr<ServiceConfig::ParsedConfig>
+MessageSizeParser::ParsePerMethodParams(const grpc_json* json,
+                                        grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
   int max_request_message_bytes = -1;
   int max_response_message_bytes = -1;
@@ -215,7 +216,7 @@ static void recv_message_ready(void* user_data, grpc_error* error) {
                              calld->recv_trailing_metadata_error,
                              "continue recv_trailing_metadata_ready");
   }
-  GRPC_CLOSURE_RUN(closure, error);
+  grpc_core::Closure::Run(DEBUG_LOCATION, closure, error);
 }
 
 // Callback invoked on completion of recv_trailing_metadata
@@ -234,7 +235,8 @@ static void recv_trailing_metadata_ready(void* user_data, grpc_error* error) {
   error =
       grpc_error_add_child(GRPC_ERROR_REF(error), GRPC_ERROR_REF(calld->error));
   // Invoke the next callback.
-  GRPC_CLOSURE_RUN(calld->original_recv_trailing_metadata_ready, error);
+  grpc_core::Closure::Run(DEBUG_LOCATION,
+                          calld->original_recv_trailing_metadata_ready, error);
 }
 
 // Start transport stream op.
@@ -286,8 +288,8 @@ static grpc_error* message_size_init_call_elem(
 
 // Destructor for call_data.
 static void message_size_destroy_call_elem(
-    grpc_call_element* elem, const grpc_call_final_info* final_info,
-    grpc_closure* ignored) {
+    grpc_call_element* elem, const grpc_call_final_info* /*final_info*/,
+    grpc_closure* /*ignored*/) {
   call_data* calld = (call_data*)elem->call_data;
   calld->~call_data();
 }
@@ -375,7 +377,7 @@ const grpc_channel_filter grpc_message_size_filter = {
 
 // Used for GRPC_CLIENT_SUBCHANNEL
 static bool maybe_add_message_size_filter_subchannel(
-    grpc_channel_stack_builder* builder, void* arg) {
+    grpc_channel_stack_builder* builder, void* /*arg*/) {
   const grpc_channel_args* channel_args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
   if (grpc_channel_args_want_minimal_stack(channel_args)) {
@@ -388,7 +390,7 @@ static bool maybe_add_message_size_filter_subchannel(
 // Used for GRPC_CLIENT_DIRECT_CHANNEL and GRPC_SERVER_CHANNEL. Adds the filter
 // only if message size limits or service config is specified.
 static bool maybe_add_message_size_filter(grpc_channel_stack_builder* builder,
-                                          void* arg) {
+                                          void* /*arg*/) {
   const grpc_channel_args* channel_args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
   bool enable = false;

data/src/core/ext/filters/message_size/message_size_filter.h

@@ -46,7 +46,7 @@ class MessageSizeParsedConfig : public ServiceConfig::ParsedConfig {
 
 class MessageSizeParser : public ServiceConfig::Parser {
  public:
-  UniquePtr<ServiceConfig::ParsedConfig> ParsePerMethodParams(
+  std::unique_ptr<ServiceConfig::ParsedConfig> ParsePerMethodParams(
       const grpc_json* json, grpc_error** error) override;
 
   static void Register();

data/src/core/ext/filters/workarounds/workaround_cronet_compression_filter.cc

@@ -70,8 +70,9 @@ static void recv_initial_metadata_ready(void* user_data, grpc_error* error) {
   }
 
   // Invoke the next callback.
-  GRPC_CLOSURE_RUN(calld->next_recv_initial_metadata_ready,
-                   GRPC_ERROR_REF(error));
+  grpc_core::Closure::Run(DEBUG_LOCATION,
+                          calld->next_recv_initial_metadata_ready,
+                          GRPC_ERROR_REF(error));
 }
 
 // Start transport stream op.
@@ -105,7 +106,7 @@ static void cronet_compression_start_transport_stream_op_batch(
 
 // Constructor for call_data.
 static grpc_error* cronet_compression_init_call_elem(
-    grpc_call_element* elem, const grpc_call_element_args* args) {
+    grpc_call_element* elem, const grpc_call_element_args* /*args*/) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->next_recv_initial_metadata_ready = nullptr;
   calld->workaround_active = false;
@@ -117,18 +118,18 @@ static grpc_error* cronet_compression_init_call_elem(
 
 // Destructor for call_data.
 static void cronet_compression_destroy_call_elem(
-    grpc_call_element* elem, const grpc_call_final_info* final_info,
-    grpc_closure* ignored) {}
+    grpc_call_element* /*elem*/, const grpc_call_final_info* /*final_info*/,
+    grpc_closure* /*ignored*/) {}
 
 // Constructor for channel_data.
 static grpc_error* cronet_compression_init_channel_elem(
-    grpc_channel_element* elem, grpc_channel_element_args* args) {
+    grpc_channel_element* /*elem*/, grpc_channel_element_args* /*args*/) {
   return GRPC_ERROR_NONE;
 }
 
 // Destructor for channel_data.
 static void cronet_compression_destroy_channel_elem(
-    grpc_channel_element* elem) {}
+    grpc_channel_element* /*elem*/) {}
 
 // Parse the user agent
 static bool parse_user_agent(grpc_mdelem md) {
@@ -183,7 +184,7 @@ const grpc_channel_filter grpc_workaround_cronet_compression_filter = {
     "workaround_cronet_compression"};
 
 static bool register_workaround_cronet_compression(
-    grpc_channel_stack_builder* builder, void* arg) {
+    grpc_channel_stack_builder* builder, void* /*arg*/) {
   const grpc_channel_args* channel_args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
   const grpc_arg* a = grpc_channel_args_find(

data/src/core/ext/transport/chttp2/client/chttp2_connector.cc

@@ -38,202 +38,169 @@
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/slice/slice_internal.h"
 
-typedef struct {
-  grpc_connector base;
+namespace grpc_core {
 
-  gpr_mu mu;
-  gpr_refcount refs;
-
-  bool shutdown;
-  bool connecting;
-
-  grpc_closure* notify;
-  grpc_connect_in_args args;
-  grpc_connect_out_args* result;
-
-  grpc_endpoint* endpoint;  // Non-NULL until handshaking starts.
-
-  grpc_closure connected;
-
-  grpc_core::RefCountedPtr<grpc_core::HandshakeManager> handshake_mgr;
-} chttp2_connector;
+Chttp2Connector::Chttp2Connector() {
+  GRPC_CLOSURE_INIT(&connected_, Connected, this, grpc_schedule_on_exec_ctx);
+}
 
-static void chttp2_connector_ref(grpc_connector* con) {
-  chttp2_connector* c = reinterpret_cast<chttp2_connector*>(con);
-  gpr_ref(&c->refs);
+Chttp2Connector::~Chttp2Connector() {
+  if (endpoint_ != nullptr) grpc_endpoint_destroy(endpoint_);
 }
 
-static void chttp2_connector_unref(grpc_connector* con) {
-  chttp2_connector* c = reinterpret_cast<chttp2_connector*>(con);
-  if (gpr_unref(&c->refs)) {
-    gpr_mu_destroy(&c->mu);
-    // If handshaking is not yet in progress, destroy the endpoint.
-    // Otherwise, the handshaker will do this for us.
-    if (c->endpoint != nullptr) grpc_endpoint_destroy(c->endpoint);
-    gpr_free(c);
+void Chttp2Connector::Connect(const Args& args, Result* result,
+                              grpc_closure* notify) {
+  grpc_resolved_address addr;
+  Subchannel::GetAddressFromSubchannelAddressArg(args.channel_args, &addr);
+  grpc_endpoint** ep;
+  {
+    MutexLock lock(&mu_);
+    GPR_ASSERT(notify_ == nullptr);
+    args_ = args;
+    result_ = result;
+    notify_ = notify;
+    GPR_ASSERT(!connecting_);
+    connecting_ = true;
+    GPR_ASSERT(endpoint_ == nullptr);
+    ep = &endpoint_;
   }
+  // In some implementations, the closure can be flushed before
+  // grpc_tcp_client_connect() returns, and since the closure requires access
+  // to mu_, this can result in a deadlock (see
+  // https://github.com/grpc/grpc/issues/16427 for details).
+  // grpc_tcp_client_connect() will fill endpoint_ with proper contents, and we
+  // make sure that we still exist at that point by taking a ref.
+  Ref().release();  // Ref held by callback.
+  grpc_tcp_client_connect(&connected_, ep, args.interested_parties,
+                          args.channel_args, &addr, args.deadline);
 }
 
-static void chttp2_connector_shutdown(grpc_connector* con, grpc_error* why) {
-  chttp2_connector* c = reinterpret_cast<chttp2_connector*>(con);
-  gpr_mu_lock(&c->mu);
-  c->shutdown = true;
-  if (c->handshake_mgr != nullptr) {
-    c->handshake_mgr->Shutdown(GRPC_ERROR_REF(why));
+void Chttp2Connector::Shutdown(grpc_error* error) {
+  MutexLock lock(&mu_);
+  shutdown_ = true;
+  if (handshake_mgr_ != nullptr) {
+    handshake_mgr_->Shutdown(GRPC_ERROR_REF(error));
   }
   // If handshaking is not yet in progress, shutdown the endpoint.
   // Otherwise, the handshaker will do this for us.
-  if (!c->connecting && c->endpoint != nullptr) {
-    grpc_endpoint_shutdown(c->endpoint, GRPC_ERROR_REF(why));
+  if (!connecting_ && endpoint_ != nullptr) {
+    grpc_endpoint_shutdown(endpoint_, GRPC_ERROR_REF(error));
   }
-  gpr_mu_unlock(&c->mu);
-  GRPC_ERROR_UNREF(why);
+  GRPC_ERROR_UNREF(error);
 }
 
-static void on_handshake_done(void* arg, grpc_error* error) {
-  auto* args = static_cast<grpc_core::HandshakerArgs*>(arg);
-  chttp2_connector* c = static_cast<chttp2_connector*>(args->user_data);
-  gpr_mu_lock(&c->mu);
-  if (error != GRPC_ERROR_NONE || c->shutdown) {
-    if (error == GRPC_ERROR_NONE) {
-      error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("connector shutdown");
-      // We were shut down after handshaking completed successfully, so
-      // destroy the endpoint here.
-      // TODO(ctiller): It is currently necessary to shutdown endpoints
-      // before destroying them, even if we know that there are no
-      // pending read/write callbacks.  This should be fixed, at which
-      // point this can be removed.
-      grpc_endpoint_shutdown(args->endpoint, GRPC_ERROR_REF(error));
-      grpc_endpoint_destroy(args->endpoint);
-      grpc_channel_args_destroy(args->args);
-      grpc_slice_buffer_destroy_internal(args->read_buffer);
-      gpr_free(args->read_buffer);
+void Chttp2Connector::Connected(void* arg, grpc_error* error) {
+  Chttp2Connector* self = static_cast<Chttp2Connector*>(arg);
+  bool unref = false;
+  {
+    MutexLock lock(&self->mu_);
+    GPR_ASSERT(self->connecting_);
+    self->connecting_ = false;
+    if (error != GRPC_ERROR_NONE || self->shutdown_) {
+      if (error == GRPC_ERROR_NONE) {
+        error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("connector shutdown");
+      } else {
+        error = GRPC_ERROR_REF(error);
+      }
+      if (self->endpoint_ != nullptr) {
+        grpc_endpoint_shutdown(self->endpoint_, GRPC_ERROR_REF(error));
+      }
+      self->result_->Reset();
+      grpc_closure* notify = self->notify_;
+      self->notify_ = nullptr;
+      ExecCtx::Run(DEBUG_LOCATION, notify, error);
+      unref = true;
     } else {
-      error = GRPC_ERROR_REF(error);
+      GPR_ASSERT(self->endpoint_ != nullptr);
+      self->StartHandshakeLocked();
     }
-    c->result->reset();
-  } else {
-    grpc_endpoint_delete_from_pollset_set(args->endpoint,
-                                          c->args.interested_parties);
-    c->result->transport =
-        grpc_create_chttp2_transport(args->args, args->endpoint, true);
-    c->result->socket =
-        grpc_chttp2_transport_get_socket_node(c->result->transport);
-    GPR_ASSERT(c->result->transport);
-    // TODO(roth): We ideally want to wait until we receive HTTP/2
-    // settings from the server before we consider the connection
-    // established.  If that doesn't happen before the connection
-    // timeout expires, then we should consider the connection attempt a
-    // failure and feed that information back into the backoff code.
-    // We could pass a notify_on_receive_settings callback to
-    // grpc_chttp2_transport_start_reading() to let us know when
-    // settings are received, but we would need to figure out how to use
-    // that information here.
-    //
-    // Unfortunately, we don't currently have a way to split apart the two
-    // effects of scheduling c->notify: we start sending RPCs immediately
-    // (which we want to do) and we consider the connection attempt successful
-    // (which we don't want to do until we get the notify_on_receive_settings
-    // callback from the transport).  If we could split those things
-    // apart, then we could start sending RPCs but then wait for our
-    // timeout before deciding if the connection attempt is successful.
-    // If the attempt is not successful, then we would tear down the
-    // transport and feed the failure back into the backoff code.
-    //
-    // In addition, even if we did that, we would probably not want to do
-    // so until after transparent retries is implemented.  Otherwise, any
-    // RPC that we attempt to send on the connection before the timeout
-    // would fail instead of being retried on a subsequent attempt.
-    grpc_chttp2_transport_start_reading(c->result->transport, args->read_buffer,
-                                        nullptr);
-    c->result->channel_args = args->args;
   }
-  grpc_closure* notify = c->notify;
-  c->notify = nullptr;
-  GRPC_CLOSURE_SCHED(notify, error);
-  c->handshake_mgr.reset();
-  gpr_mu_unlock(&c->mu);
-  chttp2_connector_unref(reinterpret_cast<grpc_connector*>(c));
+  if (unref) self->Unref();
 }
 
-static void start_handshake_locked(chttp2_connector* c) {
-  c->handshake_mgr = grpc_core::MakeRefCounted<grpc_core::HandshakeManager>();
-  grpc_core::HandshakerRegistry::AddHandshakers(
-      grpc_core::HANDSHAKER_CLIENT, c->args.channel_args,
-      c->args.interested_parties, c->handshake_mgr.get());
-  grpc_endpoint_add_to_pollset_set(c->endpoint, c->args.interested_parties);
-  c->handshake_mgr->DoHandshake(c->endpoint, c->args.channel_args,
-                                c->args.deadline, nullptr /* acceptor */,
-                                on_handshake_done, c);
-  c->endpoint = nullptr;  // Endpoint handed off to handshake manager.
+void Chttp2Connector::StartHandshakeLocked() {
+  handshake_mgr_ = MakeRefCounted<HandshakeManager>();
+  HandshakerRegistry::AddHandshakers(HANDSHAKER_CLIENT, args_.channel_args,
+                                     args_.interested_parties,
+                                     handshake_mgr_.get());
+  grpc_endpoint_add_to_pollset_set(endpoint_, args_.interested_parties);
+  handshake_mgr_->DoHandshake(endpoint_, args_.channel_args, args_.deadline,
+                              nullptr /* acceptor */, OnHandshakeDone, this);
+  endpoint_ = nullptr;  // Endpoint handed off to handshake manager.
 }
 
-static void connected(void* arg, grpc_error* error) {
-  chttp2_connector* c = static_cast<chttp2_connector*>(arg);
-  gpr_mu_lock(&c->mu);
-  GPR_ASSERT(c->connecting);
-  c->connecting = false;
-  if (error != GRPC_ERROR_NONE || c->shutdown) {
-    if (error == GRPC_ERROR_NONE) {
-      error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("connector shutdown");
+void Chttp2Connector::OnHandshakeDone(void* arg, grpc_error* error) {
+  auto* args = static_cast<HandshakerArgs*>(arg);
+  Chttp2Connector* self = static_cast<Chttp2Connector*>(args->user_data);
+  {
+    MutexLock lock(&self->mu_);
+    if (error != GRPC_ERROR_NONE || self->shutdown_) {
+      if (error == GRPC_ERROR_NONE) {
+        error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("connector shutdown");
+        // We were shut down after handshaking completed successfully, so
+        // destroy the endpoint here.
+        if (args->endpoint != nullptr) {
+          // TODO(ctiller): It is currently necessary to shutdown endpoints
+          // before destroying them, even if we know that there are no
+          // pending read/write callbacks.  This should be fixed, at which
+          // point this can be removed.
+          grpc_endpoint_shutdown(args->endpoint, GRPC_ERROR_REF(error));
+          grpc_endpoint_destroy(args->endpoint);
+          grpc_channel_args_destroy(args->args);
+          grpc_slice_buffer_destroy_internal(args->read_buffer);
+          gpr_free(args->read_buffer);
+        }
+      } else {
+        error = GRPC_ERROR_REF(error);
+      }
+      self->result_->Reset();
+    } else if (args->endpoint != nullptr) {
+      grpc_endpoint_delete_from_pollset_set(args->endpoint,
+                                            self->args_.interested_parties);
+      self->result_->transport =
+          grpc_create_chttp2_transport(args->args, args->endpoint, true);
+      self->result_->socket_node =
+          grpc_chttp2_transport_get_socket_node(self->result_->transport);
+      GPR_ASSERT(self->result_->transport != nullptr);
+      // TODO(roth): We ideally want to wait until we receive HTTP/2
+      // settings from the server before we consider the connection
+      // established.  If that doesn't happen before the connection
+      // timeout expires, then we should consider the connection attempt a
+      // failure and feed that information back into the backoff code.
+      // We could pass a notify_on_receive_settings callback to
+      // grpc_chttp2_transport_start_reading() to let us know when
+      // settings are received, but we would need to figure out how to use
+      // that information here.
+      //
+      // Unfortunately, we don't currently have a way to split apart the two
+      // effects of scheduling c->notify: we start sending RPCs immediately
+      // (which we want to do) and we consider the connection attempt successful
+      // (which we don't want to do until we get the notify_on_receive_settings
+      // callback from the transport).  If we could split those things
+      // apart, then we could start sending RPCs but then wait for our
+      // timeout before deciding if the connection attempt is successful.
+      // If the attempt is not successful, then we would tear down the
+      // transport and feed the failure back into the backoff code.
+      //
+      // In addition, even if we did that, we would probably not want to do
+      // so until after transparent retries is implemented.  Otherwise, any
+      // RPC that we attempt to send on the connection before the timeout
+      // would fail instead of being retried on a subsequent attempt.
+      grpc_chttp2_transport_start_reading(self->result_->transport,
+                                          args->read_buffer, nullptr);
+      self->result_->channel_args = args->args;
     } else {
-      error = GRPC_ERROR_REF(error);
+      // If the handshaking succeeded but there is no endpoint, then the
+      // handshaker may have handed off the connection to some external
+      // code. Just verify that exit_early flag is set.
+      GPR_DEBUG_ASSERT(args->exit_early);
     }
-    c->result->reset();
-    grpc_closure* notify = c->notify;
-    c->notify = nullptr;
-    GRPC_CLOSURE_SCHED(notify, error);
-    if (c->endpoint != nullptr) {
-      grpc_endpoint_shutdown(c->endpoint, GRPC_ERROR_REF(error));
-    }
-    gpr_mu_unlock(&c->mu);
-    chttp2_connector_unref(static_cast<grpc_connector*>(arg));
-  } else {
-    GPR_ASSERT(c->endpoint != nullptr);
-    start_handshake_locked(c);
-    gpr_mu_unlock(&c->mu);
+    grpc_closure* notify = self->notify_;
+    self->notify_ = nullptr;
+    ExecCtx::Run(DEBUG_LOCATION, notify, error);
+    self->handshake_mgr_.reset();
   }
+  self->Unref();
 }
 
-static void chttp2_connector_connect(grpc_connector* con,
-                                     const grpc_connect_in_args* args,
-                                     grpc_connect_out_args* result,
-                                     grpc_closure* notify) {
-  chttp2_connector* c = reinterpret_cast<chttp2_connector*>(con);
-  grpc_resolved_address addr;
-  grpc_core::Subchannel::GetAddressFromSubchannelAddressArg(args->channel_args,
-                                                            &addr);
-  gpr_mu_lock(&c->mu);
-  GPR_ASSERT(c->notify == nullptr);
-  c->notify = notify;
-  c->args = *args;
-  c->result = result;
-  GPR_ASSERT(c->endpoint == nullptr);
-  chttp2_connector_ref(con);  // Ref taken for callback.
-  GRPC_CLOSURE_INIT(&c->connected, connected, c, grpc_schedule_on_exec_ctx);
-  GPR_ASSERT(!c->connecting);
-  c->connecting = true;
-  grpc_closure* closure = &c->connected;
-  grpc_endpoint** ep = &c->endpoint;
-  gpr_mu_unlock(&c->mu);
-  // In some implementations, the closure can be flushed before
-  // grpc_tcp_client_connect and since the closure requires access to c->mu,
-  // this can result in a deadlock. Refer
-  // https://github.com/grpc/grpc/issues/16427
-  // grpc_tcp_client_connect would fill c->endpoint with proper contents and we
-  // make sure that we would still exist at that point by taking a ref.
-  grpc_tcp_client_connect(closure, ep, args->interested_parties,
-                          args->channel_args, &addr, args->deadline);
-}
-
-static const grpc_connector_vtable chttp2_connector_vtable = {
-    chttp2_connector_ref, chttp2_connector_unref, chttp2_connector_shutdown,
-    chttp2_connector_connect};
-
-grpc_connector* grpc_chttp2_connector_create() {
-  chttp2_connector* c = static_cast<chttp2_connector*>(gpr_zalloc(sizeof(*c)));
-  c->base.vtable = &chttp2_connector_vtable;
-  gpr_mu_init(&c->mu);
-  gpr_ref_init(&c->refs, 1);
-  return &c->base;
-}
+}  // namespace grpc_core