grpc 1.25.0 → 1.26.0.pre1

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

@@ -30,11 +30,10 @@
 namespace grpc_core {
 namespace channelz {
 
-SubchannelNode::SubchannelNode(const char* target_address,
+SubchannelNode::SubchannelNode(std::string target_address,
                                size_t channel_tracer_max_nodes)
-    : BaseNode(EntityType::kSubchannel,
-               UniquePtr<char>(gpr_strdup(target_address))),
-      target_(UniquePtr<char>(gpr_strdup(target_address))),
+    : BaseNode(EntityType::kSubchannel, target_address),
+      target_(std::move(target_address)),
       trace_(channel_tracer_max_nodes) {}
 
 SubchannelNode::~SubchannelNode() {}
@@ -76,8 +75,8 @@ grpc_json* SubchannelNode::RenderJson() {
   json = data;
   json_iterator = nullptr;
   PopulateConnectivityState(json);
-  GPR_ASSERT(target_.get() != nullptr);
-  grpc_json_create_child(nullptr, json, "target", target_.get(),
+  GPR_ASSERT(!target_.empty());
+  grpc_json_create_child(nullptr, json, "target", target_.c_str(),
                          GRPC_JSON_STRING, false);
   // fill in the channel trace if applicable
   grpc_json* trace_json = trace_.RenderJson();
@@ -102,7 +101,8 @@ grpc_json* SubchannelNode::RenderJson() {
     grpc_json* sibling_iterator = grpc_json_add_number_string_child(
         json_iterator, nullptr, "socketId", child_socket->uuid());
     grpc_json_create_child(sibling_iterator, json_iterator, "name",
-                           child_socket->name(), GRPC_JSON_STRING, false);
+                           child_socket->name().c_str(), GRPC_JSON_STRING,
+                           false);
   }
   return top_level_json;
 }

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

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string>
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_trace.h"
@@ -34,7 +36,7 @@ namespace channelz {
 
 class SubchannelNode : public BaseNode {
  public:
-  SubchannelNode(const char* target_address, size_t channel_tracer_max_nodes);
+  SubchannelNode(std::string target_address, size_t channel_tracer_max_nodes);
   ~SubchannelNode() override;
 
   // Sets the subchannel's connectivity state without health checking.
@@ -67,7 +69,7 @@ class SubchannelNode : public BaseNode {
   Atomic<grpc_connectivity_state> connectivity_state_{GRPC_CHANNEL_IDLE};
   Mutex socket_mu_;
   RefCountedPtr<SocketNode> child_socket_;
-  UniquePtr<char> target_;
+  std::string target_;
   CallCountingHelper call_counter_;
   ChannelTrace trace_;
 };

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

@@ -29,7 +29,7 @@ namespace grpc_core {
 namespace {
 
 void* factory_arg_copy(void* f) { return f; }
-void factory_arg_destroy(void* f) {}
+void factory_arg_destroy(void* /*f*/) {}
 int factory_arg_cmp(void* factory1, void* factory2) {
   return GPR_ICMP(factory1, factory2);
 }

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

@@ -48,8 +48,8 @@ void grpc_client_channel_init(void) {
   grpc_core::LoadBalancingPolicyRegistry::Builder::InitRegistry();
   grpc_core::ResolverRegistry::Builder::InitRegistry();
   grpc_core::internal::ServerRetryThrottleMap::Init();
-  grpc_proxy_mapper_registry_init();
-  grpc_register_http_proxy_mapper();
+  grpc_core::ProxyMapperRegistry::Init();
+  grpc_core::RegisterHttpProxyMapper();
   grpc_core::GlobalSubchannelPool::Init();
   grpc_channel_init_register_stage(
       GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY, append_filter,
@@ -61,7 +61,7 @@ void grpc_client_channel_init(void) {
 void grpc_client_channel_shutdown(void) {
   grpc_core::GlobalSubchannelPool::Shutdown();
   grpc_channel_init_shutdown();
-  grpc_proxy_mapper_registry_shutdown();
+  grpc_core::ProxyMapperRegistry::Shutdown();
   grpc_core::internal::ServerRetryThrottleMap::Shutdown();
   grpc_core::ResolverRegistry::Builder::ShutdownRegistry();
   grpc_core::LoadBalancingPolicyRegistry::Builder::ShutdownRegistry();

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

@@ -23,62 +23,57 @@
 
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channelz.h"
+#include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/transport/transport.h"
 
-typedef struct grpc_connector grpc_connector;
-typedef struct grpc_connector_vtable grpc_connector_vtable;
+namespace grpc_core {
 
-struct grpc_connector {
-  const grpc_connector_vtable* vtable;
-};
+// Interface for connection-establishment functionality.
+// Each transport that supports client channels (e.g., not inproc) must
+// supply an implementation of this.
+class SubchannelConnector : public InternallyRefCounted<SubchannelConnector> {
+ public:
+  struct Args {
+    // Set of pollsets interested in this connection.
+    grpc_pollset_set* interested_parties;
+    // Deadline for connection.
+    grpc_millis deadline;
+    // Channel args to be passed to handshakers and transport.
+    const grpc_channel_args* channel_args;
+  };
 
-typedef struct {
-  /** set of pollsets interested in this connection */
-  grpc_pollset_set* interested_parties;
-  /** deadline for connection */
-  grpc_millis deadline;
-  /** channel arguments (to be passed to transport) */
-  const grpc_channel_args* channel_args;
-} grpc_connect_in_args;
+  struct Result {
+    // The connected transport.
+    grpc_transport* transport = nullptr;
+    // Channel args to be passed to filters.
+    const grpc_channel_args* channel_args = nullptr;
+    // Channelz socket node of the connected transport, if any.
+    RefCountedPtr<channelz::SocketNode> socket_node;
 
-typedef struct {
-  /** the connected transport */
-  grpc_transport* transport;
+    void Reset() {
+      transport = nullptr;
+      channel_args = nullptr;
+      socket_node.reset();
+    }
+  };
 
-  /** channel arguments (to be passed to the filters) */
-  grpc_channel_args* channel_args;
+  // Attempts to connect.
+  // When complete, populates *result and invokes notify.
+  // Only one connection attempt may be in progress at any one time.
+  virtual void Connect(const Args& args, Result* result,
+                       grpc_closure* notify) = 0;
 
-  /** channelz socket node of the connected transport. nullptr if not available
-   */
-  grpc_core::RefCountedPtr<grpc_core::channelz::SocketNode> socket;
+  // Cancels any in-flight connection attempt and shuts down the
+  // connector.
+  virtual void Shutdown(grpc_error* error) = 0;
 
-  void reset() {
-    transport = nullptr;
-    channel_args = nullptr;
-    socket = nullptr;
+  void Orphan() override {
+    Shutdown(GRPC_ERROR_CREATE_FROM_STATIC_STRING("Subchannel disconnected"));
+    Unref();
   }
-} grpc_connect_out_args;
-
-struct grpc_connector_vtable {
-  void (*ref)(grpc_connector* connector);
-  void (*unref)(grpc_connector* connector);
-  /** Implementation of grpc_connector_shutdown */
-  void (*shutdown)(grpc_connector* connector, grpc_error* why);
-  /** Implementation of grpc_connector_connect */
-  void (*connect)(grpc_connector* connector,
-                  const grpc_connect_in_args* in_args,
-                  grpc_connect_out_args* out_args, grpc_closure* notify);
 };
 
-grpc_connector* grpc_connector_ref(grpc_connector* connector);
-void grpc_connector_unref(grpc_connector* connector);
-/** Connect using the connector: max one outstanding call at a time */
-void grpc_connector_connect(grpc_connector* connector,
-                            const grpc_connect_in_args* in_args,
-                            grpc_connect_out_args* out_args,
-                            grpc_closure* notify);
-/** Cancel any pending connection */
-void grpc_connector_shutdown(grpc_connector* connector, grpc_error* why);
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CONNECTOR_H */

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

@@ -35,7 +35,7 @@ GlobalSubchannelPool::~GlobalSubchannelPool() {
 }
 
 void GlobalSubchannelPool::Init() {
-  instance_ = New<RefCountedPtr<GlobalSubchannelPool>>(
+  instance_ = new RefCountedPtr<GlobalSubchannelPool>(
       MakeRefCounted<GlobalSubchannelPool>());
 }
 
@@ -45,7 +45,7 @@ void GlobalSubchannelPool::Shutdown() {
   // To ensure Shutdown() was not called before.
   GPR_ASSERT(*instance_ != nullptr);
   instance_->reset();
-  Delete(instance_);
+  delete instance_;
 }
 
 RefCountedPtr<GlobalSubchannelPool> GlobalSubchannelPool::instance() {
@@ -78,7 +78,7 @@ Subchannel* GlobalSubchannelPool::RegisterSubchannel(SubchannelKey* key,
       // Note that we should ref the old map first because grpc_avl_add() will
       // unref it while we still need to access it later.
       grpc_avl new_map = grpc_avl_add(
-          grpc_avl_ref(old_map, nullptr), New<SubchannelKey>(*key),
+          grpc_avl_ref(old_map, nullptr), new SubchannelKey(*key),
           GRPC_SUBCHANNEL_WEAK_REF(constructed, "subchannel_register+new"),
           nullptr);
       // Try to publish the change to the shared map. It may happen (but
@@ -140,28 +140,28 @@ RefCountedPtr<GlobalSubchannelPool>* GlobalSubchannelPool::instance_ = nullptr;
 
 namespace {
 
-void sck_avl_destroy(void* p, void* user_data) {
+void sck_avl_destroy(void* p, void* /*user_data*/) {
   SubchannelKey* key = static_cast<SubchannelKey*>(p);
-  Delete(key);
+  delete key;
 }
 
-void* sck_avl_copy(void* p, void* unused) {
+void* sck_avl_copy(void* p, void* /*unused*/) {
   const SubchannelKey* key = static_cast<const SubchannelKey*>(p);
-  auto* new_key = New<SubchannelKey>(*key);
+  auto* new_key = new SubchannelKey(*key);
   return static_cast<void*>(new_key);
 }
 
-long sck_avl_compare(void* a, void* b, void* unused) {
+long sck_avl_compare(void* a, void* b, void* /*unused*/) {
   const SubchannelKey* key_a = static_cast<const SubchannelKey*>(a);
   const SubchannelKey* key_b = static_cast<const SubchannelKey*>(b);
   return key_a->Cmp(*key_b);
 }
 
-void scv_avl_destroy(void* p, void* user_data) {
+void scv_avl_destroy(void* p, void* /*user_data*/) {
   GRPC_SUBCHANNEL_WEAK_UNREF((Subchannel*)p, "global_subchannel_pool");
 }
 
-void* scv_avl_copy(void* p, void* unused) {
+void* scv_avl_copy(void* p, void* /*unused*/) {
   GRPC_SUBCHANNEL_WEAK_REF((Subchannel*)p, "global_subchannel_pool");
   return p;
 }

data/src/core/ext/filters/client_channel/health/health_check_client.cc

@@ -200,7 +200,7 @@ bool DecodeResponse(grpc_slice_buffer* slice_buffer, grpc_error** error) {
     return false;
   }
   // Concatenate the slices to form a single string.
-  UniquePtr<uint8_t> recv_message_deleter;
+  std::unique_ptr<uint8_t> recv_message_deleter;
   uint8_t* recv_message;
   if (slice_buffer->count == 1) {
     recv_message = GRPC_SLICE_START_PTR(slice_buffer->slices[0]);
@@ -300,7 +300,8 @@ void HealthCheckClient::CallState::StartCall() {
     // Schedule instead of running directly, since we must not be
     // holding health_check_client_->mu_ when CallEnded() is called.
     call_->Ref(DEBUG_LOCATION, "call_end_closure").release();
-    GRPC_CLOSURE_SCHED(
+    ExecCtx::Run(
+        DEBUG_LOCATION,
         GRPC_CLOSURE_INIT(&batch_.handler_private.closure, CallEndedRetry, this,
                           grpc_schedule_on_exec_ctx),
         GRPC_ERROR_NONE);
@@ -377,8 +378,8 @@ void HealthCheckClient::CallState::StartCall() {
   StartBatch(&recv_trailing_metadata_batch_);
 }
 
-void HealthCheckClient::CallState::StartBatchInCallCombiner(void* arg,
-                                                            grpc_error* error) {
+void HealthCheckClient::CallState::StartBatchInCallCombiner(
+    void* arg, grpc_error* /*error*/) {
   grpc_transport_stream_op_batch* batch =
       static_cast<grpc_transport_stream_op_batch*>(arg);
   SubchannelCall* call =
@@ -396,21 +397,22 @@ void HealthCheckClient::CallState::StartBatch(
 }
 
 void HealthCheckClient::CallState::AfterCallStackDestruction(
-    void* arg, grpc_error* error) {
+    void* arg, grpc_error* /*error*/) {
   HealthCheckClient::CallState* self =
       static_cast<HealthCheckClient::CallState*>(arg);
-  Delete(self);
+  delete self;
 }
 
 void HealthCheckClient::CallState::OnCancelComplete(void* arg,
-                                                    grpc_error* error) {
+                                                    grpc_error* /*error*/) {
   HealthCheckClient::CallState* self =
       static_cast<HealthCheckClient::CallState*>(arg);
   GRPC_CALL_COMBINER_STOP(&self->call_combiner_, "health_cancel");
   self->call_->Unref(DEBUG_LOCATION, "cancel");
 }
 
-void HealthCheckClient::CallState::StartCancel(void* arg, grpc_error* error) {
+void HealthCheckClient::CallState::StartCancel(void* arg,
+                                               grpc_error* /*error*/) {
   HealthCheckClient::CallState* self =
       static_cast<HealthCheckClient::CallState*>(arg);
   auto* batch = grpc_make_transport_stream_op(
@@ -432,7 +434,8 @@ void HealthCheckClient::CallState::Cancel() {
   }
 }
 
-void HealthCheckClient::CallState::OnComplete(void* arg, grpc_error* error) {
+void HealthCheckClient::CallState::OnComplete(void* arg,
+                                              grpc_error* /*error*/) {
   HealthCheckClient::CallState* self =
       static_cast<HealthCheckClient::CallState*>(arg);
   GRPC_CALL_COMBINER_STOP(&self->call_combiner_, "on_complete");
@@ -441,8 +444,8 @@ void HealthCheckClient::CallState::OnComplete(void* arg, grpc_error* error) {
   self->call_->Unref(DEBUG_LOCATION, "on_complete");
 }
 
-void HealthCheckClient::CallState::RecvInitialMetadataReady(void* arg,
-                                                            grpc_error* error) {
+void HealthCheckClient::CallState::RecvInitialMetadataReady(
+    void* arg, grpc_error* /*error*/) {
   HealthCheckClient::CallState* self =
       static_cast<HealthCheckClient::CallState*>(arg);
   GRPC_CALL_COMBINER_STOP(&self->call_combiner_, "recv_initial_metadata_ready");
@@ -524,7 +527,7 @@ void HealthCheckClient::CallState::OnByteStreamNext(void* arg,
 }
 
 void HealthCheckClient::CallState::RecvMessageReady(void* arg,
-                                                    grpc_error* error) {
+                                                    grpc_error* /*error*/) {
   HealthCheckClient::CallState* self =
       static_cast<HealthCheckClient::CallState*>(arg);
   GRPC_CALL_COMBINER_STOP(&self->call_combiner_, "recv_message_ready");
@@ -583,7 +586,7 @@ void HealthCheckClient::CallState::RecvTrailingMetadataReady(
 }
 
 void HealthCheckClient::CallState::CallEndedRetry(void* arg,
-                                                  grpc_error* error) {
+                                                  grpc_error* /*error*/) {
   HealthCheckClient::CallState* self =
       static_cast<HealthCheckClient::CallState*>(arg);
   self->CallEnded(true /* retry */);

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

@@ -57,8 +57,10 @@ class HttpConnectHandshaker : public Handshaker {
   void HandshakeFailedLocked(grpc_error* error);
   static void OnWriteDone(void* arg, grpc_error* error);
   static void OnReadDone(void* arg, grpc_error* error);
+  static void OnWriteDoneScheduler(void* arg, grpc_error* error);
+  static void OnReadDoneScheduler(void* arg, grpc_error* error);
 
-  gpr_mu mu_;
+  Mutex mu_;
 
   bool is_shutdown_ = false;
   // Endpoint and read buffer to destroy after a shutdown.
@@ -78,7 +80,6 @@ class HttpConnectHandshaker : public Handshaker {
 };
 
 HttpConnectHandshaker::~HttpConnectHandshaker() {
-  gpr_mu_destroy(&mu_);
   if (endpoint_to_destroy_ != nullptr) {
     grpc_endpoint_destroy(endpoint_to_destroy_);
   }
@@ -125,34 +126,59 @@ void HttpConnectHandshaker::HandshakeFailedLocked(grpc_error* error) {
     is_shutdown_ = true;
   }
   // Invoke callback.
-  GRPC_CLOSURE_SCHED(on_handshake_done_, error);
+  ExecCtx::Run(DEBUG_LOCATION, on_handshake_done_, error);
+}
+
+// This callback can be invoked inline while already holding onto the mutex. To
+// avoid deadlocks, schedule OnWriteDone on ExecCtx.
+void HttpConnectHandshaker::OnWriteDoneScheduler(void* arg, grpc_error* error) {
+  auto* handshaker = static_cast<HttpConnectHandshaker*>(arg);
+  grpc_core::ExecCtx::Run(
+      DEBUG_LOCATION,
+      GRPC_CLOSURE_INIT(&handshaker->request_done_closure_,
+                        &HttpConnectHandshaker::OnWriteDone, handshaker,
+                        grpc_schedule_on_exec_ctx),
+      GRPC_ERROR_REF(error));
 }
 
 // Callback invoked when finished writing HTTP CONNECT request.
 void HttpConnectHandshaker::OnWriteDone(void* arg, grpc_error* error) {
   auto* handshaker = static_cast<HttpConnectHandshaker*>(arg);
-  gpr_mu_lock(&handshaker->mu_);
+  ReleasableMutexLock lock(&handshaker->mu_);
   if (error != GRPC_ERROR_NONE || handshaker->is_shutdown_) {
     // If the write failed or we're shutting down, clean up and invoke the
     // callback with the error.
     handshaker->HandshakeFailedLocked(GRPC_ERROR_REF(error));
-    gpr_mu_unlock(&handshaker->mu_);
+    lock.Unlock();
     handshaker->Unref();
   } else {
     // Otherwise, read the response.
     // The read callback inherits our ref to the handshaker.
-    grpc_endpoint_read(handshaker->args_->endpoint,
-                       handshaker->args_->read_buffer,
-                       &handshaker->response_read_closure_, /*urgent=*/true);
-    gpr_mu_unlock(&handshaker->mu_);
+    grpc_endpoint_read(
+        handshaker->args_->endpoint, handshaker->args_->read_buffer,
+        GRPC_CLOSURE_INIT(&handshaker->response_read_closure_,
+                          &HttpConnectHandshaker::OnReadDoneScheduler,
+                          handshaker, grpc_schedule_on_exec_ctx),
+        /*urgent=*/true);
   }
 }
 
+// This callback can be invoked inline while already holding onto the mutex. To
+// avoid deadlocks, schedule OnReadDone on ExecCtx.
+void HttpConnectHandshaker::OnReadDoneScheduler(void* arg, grpc_error* error) {
+  auto* handshaker = static_cast<HttpConnectHandshaker*>(arg);
+  grpc_core::ExecCtx::Run(
+      DEBUG_LOCATION,
+      GRPC_CLOSURE_INIT(&handshaker->response_read_closure_,
+                        &HttpConnectHandshaker::OnReadDone, handshaker,
+                        grpc_schedule_on_exec_ctx),
+      GRPC_ERROR_REF(error));
+}
+
 // Callback invoked for reading HTTP CONNECT response.
 void HttpConnectHandshaker::OnReadDone(void* arg, grpc_error* error) {
   auto* handshaker = static_cast<HttpConnectHandshaker*>(arg);
-
-  gpr_mu_lock(&handshaker->mu_);
+  ReleasableMutexLock lock(&handshaker->mu_);
   if (error != GRPC_ERROR_NONE || handshaker->is_shutdown_) {
     // If the read failed or we're shutting down, clean up and invoke the
     // callback with the error.
@@ -204,10 +230,12 @@ void HttpConnectHandshaker::OnReadDone(void* arg, grpc_error* error) {
   // at the Content-Length: header).
   if (handshaker->http_parser_.state != GRPC_HTTP_BODY) {
     grpc_slice_buffer_reset_and_unref_internal(handshaker->args_->read_buffer);
-    grpc_endpoint_read(handshaker->args_->endpoint,
-                       handshaker->args_->read_buffer,
-                       &handshaker->response_read_closure_, /*urgent=*/true);
-    gpr_mu_unlock(&handshaker->mu_);
+    grpc_endpoint_read(
+        handshaker->args_->endpoint, handshaker->args_->read_buffer,
+        GRPC_CLOSURE_INIT(&handshaker->response_read_closure_,
+                          &HttpConnectHandshaker::OnReadDoneScheduler,
+                          handshaker, grpc_schedule_on_exec_ctx),
+        /*urgent=*/true);
     return;
   }
   // Make sure we got a 2xx response.
@@ -222,12 +250,12 @@ void HttpConnectHandshaker::OnReadDone(void* arg, grpc_error* error) {
     goto done;
   }
   // Success.  Invoke handshake-done callback.
-  GRPC_CLOSURE_SCHED(handshaker->on_handshake_done_, error);
+  ExecCtx::Run(DEBUG_LOCATION, handshaker->on_handshake_done_, error);
 done:
   // Set shutdown to true so that subsequent calls to
   // http_connect_handshaker_shutdown() do nothing.
   handshaker->is_shutdown_ = true;
-  gpr_mu_unlock(&handshaker->mu_);
+  lock.Unlock();
   handshaker->Unref();
 }
 
@@ -236,17 +264,18 @@ done:
 //
 
 void HttpConnectHandshaker::Shutdown(grpc_error* why) {
-  gpr_mu_lock(&mu_);
-  if (!is_shutdown_) {
-    is_shutdown_ = true;
-    grpc_endpoint_shutdown(args_->endpoint, GRPC_ERROR_REF(why));
-    CleanupArgsForFailureLocked();
+  {
+    MutexLock lock(&mu_);
+    if (!is_shutdown_) {
+      is_shutdown_ = true;
+      grpc_endpoint_shutdown(args_->endpoint, GRPC_ERROR_REF(why));
+      CleanupArgsForFailureLocked();
+    }
   }
-  gpr_mu_unlock(&mu_);
   GRPC_ERROR_UNREF(why);
 }
 
-void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* acceptor,
+void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
                                         grpc_closure* on_handshake_done,
                                         HandshakerArgs* args) {
   // Check for HTTP CONNECT channel arg.
@@ -257,10 +286,11 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* acceptor,
   if (server_name == nullptr) {
     // Set shutdown to true so that subsequent calls to
     // http_connect_handshaker_shutdown() do nothing.
-    gpr_mu_lock(&mu_);
-    is_shutdown_ = true;
-    gpr_mu_unlock(&mu_);
-    GRPC_CLOSURE_SCHED(on_handshake_done, GRPC_ERROR_NONE);
+    {
+      MutexLock lock(&mu_);
+      is_shutdown_ = true;
+    }
+    ExecCtx::Run(DEBUG_LOCATION, on_handshake_done, GRPC_ERROR_NONE);
     return;
   }
   // Get headers from channel args.
@@ -320,17 +350,16 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* acceptor,
   gpr_free(header_strings);
   // Take a new ref to be held by the write callback.
   Ref().release();
-  grpc_endpoint_write(args->endpoint, &write_buffer_, &request_done_closure_,
-                      nullptr);
+  grpc_endpoint_write(
+      args->endpoint, &write_buffer_,
+      GRPC_CLOSURE_INIT(&request_done_closure_,
+                        &HttpConnectHandshaker::OnWriteDoneScheduler, this,
+                        grpc_schedule_on_exec_ctx),
+      nullptr);
 }
 
 HttpConnectHandshaker::HttpConnectHandshaker() {
-  gpr_mu_init(&mu_);
   grpc_slice_buffer_init(&write_buffer_);
-  GRPC_CLOSURE_INIT(&request_done_closure_, &HttpConnectHandshaker::OnWriteDone,
-                    this, grpc_schedule_on_exec_ctx);
-  GRPC_CLOSURE_INIT(&response_read_closure_, &HttpConnectHandshaker::OnReadDone,
-                    this, grpc_schedule_on_exec_ctx);
   grpc_http_parser_init(&http_parser_, GRPC_HTTP_RESPONSE, &http_response_);
 }
 
@@ -340,8 +369,8 @@ HttpConnectHandshaker::HttpConnectHandshaker() {
 
 class HttpConnectHandshakerFactory : public HandshakerFactory {
  public:
-  void AddHandshakers(const grpc_channel_args* args,
-                      grpc_pollset_set* interested_parties,
+  void AddHandshakers(const grpc_channel_args* /*args*/,
+                      grpc_pollset_set* /*interested_parties*/,
                       HandshakeManager* handshake_mgr) override {
     handshake_mgr->Add(MakeRefCounted<HttpConnectHandshaker>());
   }