grpc 1.63.0 → 1.65.2

data/src/core/ext/transport/inproc/legacy_inproc_transport.cc

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/ext/transport/inproc/legacy_inproc_transport.h"
 
 #include <stddef.h>
@@ -29,6 +27,8 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -41,11 +41,12 @@
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 
+#include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_args_preconditioning.h"
-#include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -63,16 +64,16 @@
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/channel_create.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/surface/server.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/server/server.h"
 
-#define INPROC_LOG(...)                               \
-  do {                                                \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_inproc_trace)) { \
-      gpr_log(__VA_ARGS__);                           \
-    }                                                 \
+#define INPROC_LOG(...)                    \
+  do {                                     \
+    if (GRPC_TRACE_FLAG_ENABLED(inproc)) { \
+      gpr_log(__VA_ARGS__);                \
+    }                                      \
   } while (0)
 
 namespace {
@@ -102,8 +103,7 @@ struct shared_mu {
   gpr_refcount refs;
 };
 
-struct inproc_transport final : public grpc_core::Transport,
-                                public grpc_core::FilterStackTransport {
+struct inproc_transport final : public grpc_core::FilterStackTransport {
   inproc_transport(shared_mu* mu, bool is_client)
       : mu(mu),
         is_client(is_client),
@@ -135,7 +135,6 @@ struct inproc_transport final : public grpc_core::Transport,
   void SetPollsetSet(grpc_stream* stream,
                      grpc_pollset_set* pollset_set) override;
   void PerformOp(grpc_transport_op* op) override;
-  grpc_endpoint* GetEndpoint() override;
 
   size_t SizeOfStream() const override;
   bool HackyDisableStreamOpBatchCoalescingInConnectedChannel() const override {
@@ -320,7 +319,7 @@ void log_metadata(const grpc_metadata_batch* md_batch, bool is_client,
   std::string prefix = absl::StrCat(
       "INPROC:", is_initial ? "HDR:" : "TRL:", is_client ? "CLI:" : "SVR:");
   md_batch->Log([&prefix](absl::string_view key, absl::string_view value) {
-    gpr_log(GPR_INFO, "%s", absl::StrCat(prefix, key, ": ", value).c_str());
+    LOG(INFO) << absl::StrCat(prefix, key, ": ", value);
   });
 }
 
@@ -353,7 +352,7 @@ class CopySink {
 
 void fill_in_metadata(inproc_stream* s, const grpc_metadata_batch* metadata,
                       grpc_metadata_batch* out_md, bool* markfilled) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_inproc_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(inproc)) {
     log_metadata(metadata, s->t->is_client,
                  metadata->get_pointer(grpc_core::WaitForReady()) != nullptr);
   }
@@ -950,7 +949,7 @@ void inproc_transport::PerformStreamOp(grpc_stream* gs,
   gpr_mu* mu = &s->t->mu->mu;  // save aside in case s gets closed
   gpr_mu_lock(mu);
 
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_inproc_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(inproc)) {
     if (op->send_initial_metadata) {
       log_metadata(op->payload->send_initial_metadata.send_initial_metadata,
                    s->t->is_client, true);
@@ -1214,8 +1213,6 @@ void inproc_transport::SetPollsetSet(grpc_stream* /*gs*/,
   // Nothing to do here
 }
 
-grpc_endpoint* inproc_transport::GetEndpoint() { return nullptr; }
-
 //******************************************************************************
 // Main inproc transport functions
 //
@@ -1268,9 +1265,9 @@ grpc_channel* grpc_legacy_inproc_channel_create(grpc_server* server,
     auto new_channel = grpc_core::ChannelCreate(
         "inproc", client_args, GRPC_CLIENT_DIRECT_CHANNEL, client_transport);
     if (!new_channel.ok()) {
-      GPR_ASSERT(!channel);
-      gpr_log(GPR_ERROR, "Failed to create client channel: %s",
-              grpc_core::StatusToString(error).c_str());
+      CHECK(!channel);
+      LOG(ERROR) << "Failed to create client channel: "
+                 << grpc_core::StatusToString(error);
       intptr_t integer;
       grpc_status_code status = GRPC_STATUS_INTERNAL;
       if (grpc_error_get_int(error, grpc_core::StatusIntProperty::kRpcStatus,
@@ -1286,9 +1283,9 @@ grpc_channel* grpc_legacy_inproc_channel_create(grpc_server* server,
       channel = new_channel->release()->c_ptr();
     }
   } else {
-    GPR_ASSERT(!channel);
-    gpr_log(GPR_ERROR, "Failed to create server channel: %s",
-            grpc_core::StatusToString(error).c_str());
+    CHECK(!channel);
+    LOG(ERROR) << "Failed to create server channel: "
+               << grpc_core::StatusToString(error);
     intptr_t integer;
     grpc_status_code status = GRPC_STATUS_INTERNAL;
     if (grpc_error_get_int(error, grpc_core::StatusIntProperty::kRpcStatus,

data/src/core/ext/transport/inproc/legacy_inproc_transport.h

@@ -15,9 +15,8 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_INPROC_LEGACY_INPROC_TRANSPORT_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_INPROC_LEGACY_INPROC_TRANSPORT_H
 
-#include <grpc/support/port_platform.h>
-
 #include <grpc/grpc.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
 
@@ -25,6 +24,4 @@ grpc_channel* grpc_legacy_inproc_channel_create(grpc_server* server,
                                                 const grpc_channel_args* args,
                                                 void* reserved);
 
-extern grpc_core::TraceFlag grpc_inproc_trace;
-
 #endif  // GRPC_SRC_CORE_EXT_TRANSPORT_INPROC_LEGACY_INPROC_TRANSPORT_H

data/src/core/{lib/transport → handshaker/endpoint_info}/endpoint_info_handshaker.cc

@@ -14,23 +14,23 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/transport/endpoint_info_handshaker.h"
+#include "src/core/handshaker/endpoint_info/endpoint_info_handshaker.h"
 
 #include <memory>
 
 #include "absl/status/status.h"
 
+#include <grpc/support/port_platform.h>
+
+#include "src/core/handshaker/handshaker.h"
+#include "src/core/handshaker/handshaker_factory.h"
+#include "src/core/handshaker/handshaker_registry.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/transport/handshaker.h"
-#include "src/core/lib/transport/handshaker_factory.h"
-#include "src/core/lib/transport/handshaker_registry.h"
 
 namespace grpc_core {
 

data/src/core/{lib/transport → handshaker/endpoint_info}/endpoint_info_handshaker.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_ENDPOINT_INFO_HANDSHAKER_H
-#define GRPC_SRC_CORE_LIB_TRANSPORT_ENDPOINT_INFO_HANDSHAKER_H
+#ifndef GRPC_SRC_CORE_HANDSHAKER_ENDPOINT_INFO_ENDPOINT_INFO_HANDSHAKER_H
+#define GRPC_SRC_CORE_HANDSHAKER_ENDPOINT_INFO_ENDPOINT_INFO_HANDSHAKER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -34,4 +34,4 @@ void RegisterEndpointInfoHandshaker(CoreConfiguration::Builder* builder);
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_ENDPOINT_INFO_HANDSHAKER_H
+#endif  // GRPC_SRC_CORE_HANDSHAKER_ENDPOINT_INFO_ENDPOINT_INFO_HANDSHAKER_H

data/src/core/{lib/transport → handshaker}/handshaker.cc

@@ -16,15 +16,14 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/transport/handshaker.h"
+#include "src/core/handshaker/handshaker.h"
 
 #include <inttypes.h>
 
 #include <string>
 #include <utility>
 
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
@@ -33,6 +32,7 @@
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -43,8 +43,6 @@
 
 namespace grpc_core {
 
-TraceFlag grpc_handshaker_trace(false, "handshaker");
-
 namespace {
 
 using ::grpc_event_engine::experimental::EventEngine;
@@ -62,13 +60,12 @@ std::string HandshakerArgsString(HandshakerArgs* args) {
 }  // namespace
 
 HandshakeManager::HandshakeManager()
-    : RefCounted(GRPC_TRACE_FLAG_ENABLED(grpc_handshaker_trace)
-                     ? "HandshakeManager"
-                     : nullptr) {}
+    : RefCounted(GRPC_TRACE_FLAG_ENABLED(handshaker) ? "HandshakeManager"
+                                                     : nullptr) {}
 
 void HandshakeManager::Add(RefCountedPtr<Handshaker> handshaker) {
   MutexLock lock(&mu_);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_handshaker_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(handshaker)) {
     gpr_log(
         GPR_INFO,
         "handshake_manager %p: adding handshaker %s [%p] at index %" PRIuPTR,
@@ -94,14 +91,14 @@ void HandshakeManager::Shutdown(grpc_error_handle why) {
 // on_handshake_done callback.
 // Returns true if we've scheduled the on_handshake_done callback.
 bool HandshakeManager::CallNextHandshakerLocked(grpc_error_handle error) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_handshaker_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(handshaker)) {
     gpr_log(GPR_INFO,
             "handshake_manager %p: error=%s shutdown=%d index=%" PRIuPTR
             ", args=%s",
             this, StatusToString(error).c_str(), is_shutdown_, index_,
             HandshakerArgsString(&args_).c_str());
   }
-  GPR_ASSERT(index_ <= handshakers_.size());
+  CHECK(index_ <= handshakers_.size());
   // If we got an error or we've been shut down or we're exiting early or
   // we've finished the last handshaker, invoke the on_handshake_done
   // callback.  Otherwise, call the next handshaker.
@@ -113,20 +110,17 @@ bool HandshakeManager::CallNextHandshakerLocked(grpc_error_handle error) {
       // a shutdown call while this callback was sitting on the ExecCtx
       // with no error.
       if (args_.endpoint != nullptr) {
-        // TODO(roth): It is currently necessary to shutdown endpoints
-        // before destroying then, even when 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, error);
         grpc_endpoint_destroy(args_.endpoint);
         args_.endpoint = nullptr;
-        args_.args = ChannelArgs();
+      }
+      if (args_.read_buffer != nullptr) {
         grpc_slice_buffer_destroy(args_.read_buffer);
         gpr_free(args_.read_buffer);
         args_.read_buffer = nullptr;
       }
+      args_.args = ChannelArgs();
     }
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_handshaker_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(handshaker)) {
       gpr_log(GPR_INFO,
               "handshake_manager %p: handshaking complete -- scheduling "
               "on_handshake_done with error=%s",
@@ -139,7 +133,7 @@ bool HandshakeManager::CallNextHandshakerLocked(grpc_error_handle error) {
     is_shutdown_ = true;
   } else {
     auto handshaker = handshakers_[index_];
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_handshaker_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(handshaker)) {
       gpr_log(
           GPR_INFO,
           "handshake_manager %p: calling handshaker %s [%p] at index %" PRIuPTR,
@@ -176,7 +170,7 @@ void HandshakeManager::DoHandshake(grpc_endpoint* endpoint,
   bool done;
   {
     MutexLock lock(&mu_);
-    GPR_ASSERT(index_ == 0);
+    CHECK_EQ(index_, 0u);
     // Construct handshaker args.  These will be passed through all
     // handshakers and eventually be freed by the on_handshake_done callback.
     args_.endpoint = endpoint;

data/src/core/{lib/transport → handshaker}/handshaker.h

@@ -16,10 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_H
-#define GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_H
-
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_HANDSHAKER_HANDSHAKER_H
+#define GRPC_SRC_CORE_HANDSHAKER_HANDSHAKER_H
 
 #include <stddef.h>
 
@@ -30,6 +28,7 @@
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/slice.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -162,4 +161,4 @@ class HandshakeManager : public RefCounted<HandshakeManager> {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_H
+#endif  // GRPC_SRC_CORE_HANDSHAKER_HANDSHAKER_H

data/src/core/{lib/transport → handshaker}/handshaker_factory.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_FACTORY_H
-#define GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_FACTORY_H
+#ifndef GRPC_SRC_CORE_HANDSHAKER_HANDSHAKER_FACTORY_H
+#define GRPC_SRC_CORE_HANDSHAKER_HANDSHAKER_FACTORY_H
 
 #include <grpc/support/port_platform.h>
 
@@ -58,6 +58,22 @@ class HandshakerFactory {
     // Handshakers that are responsible for post connect security handshakes.
     // Applicable for both Client and Server handshakers.
     kSecurityHandshakers,
+    // TEMPORARY HACK -- DO NOT USE
+    // Currently, handshakers that need to hijack the endpoint's fd and
+    // exit early (which generally run at priority kSecurityHandshakers)
+    // need to call grpc_tcp_destroy_and_release_fd(), which asserts
+    // that the endpoint is an iomgr endpoint.  If another handshaker
+    // has wrapped the endpoint before then, this assertion fails.  So
+    // for now, we introduce a new priority here for handshakers that
+    // need to wrap the endpoint, to make sure that they run after
+    // handshakers that hijack the fd and exit early.
+    // TODO(hork): As part of migrating to the EventEngine endpoint API,
+    // remove this priority.  In the EE API, handshakers that want to
+    // hijack the fd will do so via the query interface, so we can just
+    // have any wrapper endpoints forward query interfaces to the wrapped
+    // endpoint, so that it's not a problem if the endpoint is wrapped
+    // before a handshaker needs to hijack the fd.
+    kTemporaryHackDoNotUseEndpointWrappingHandshakers,
   };
 
   virtual void AddHandshakers(const ChannelArgs& args,
@@ -70,4 +86,4 @@ class HandshakerFactory {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_FACTORY_H
+#endif  // GRPC_SRC_CORE_HANDSHAKER_HANDSHAKER_FACTORY_H

data/src/core/{lib/transport → handshaker}/handshaker_registry.cc

@@ -16,15 +16,15 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/transport/handshaker_registry.h"
+#include "src/core/handshaker/handshaker_registry.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 void HandshakerRegistry::Builder::RegisterHandshakerFactory(

data/src/core/{lib/transport → handshaker}/handshaker_registry.h

@@ -16,17 +16,17 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_REGISTRY_H
-#define GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_REGISTRY_H
-
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_HANDSHAKER_HANDSHAKER_REGISTRY_H
+#define GRPC_SRC_CORE_HANDSHAKER_HANDSHAKER_REGISTRY_H
 
 #include <memory>
 #include <vector>
 
+#include <grpc/support/port_platform.h>
+
+#include "src/core/handshaker/handshaker_factory.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
-#include "src/core/lib/transport/handshaker_factory.h"
 
 namespace grpc_core {
 
@@ -66,4 +66,4 @@ class HandshakerRegistry {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_REGISTRY_H
+#endif  // GRPC_SRC_CORE_HANDSHAKER_HANDSHAKER_REGISTRY_H

data/src/core/{lib/transport → handshaker/http_connect}/http_connect_handshaker.cc

@@ -16,9 +16,7 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/transport/http_connect_handshaker.h"
+#include "src/core/handshaker/http_connect/http_connect_handshaker.h"
 
 #include <limits.h>
 #include <string.h>
@@ -36,24 +34,25 @@
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
+#include "src/core/handshaker/handshaker.h"
+#include "src/core/handshaker/handshaker_factory.h"
+#include "src/core/handshaker/handshaker_registry.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/http/format_request.h"
-#include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/tcp_server.h"
-#include "src/core/lib/transport/handshaker.h"
-#include "src/core/lib/transport/handshaker_factory.h"
-#include "src/core/lib/transport/handshaker_registry.h"
+#include "src/core/util/http_client/format_request.h"
+#include "src/core/util/http_client/parser.h"
+#include "src/core/util/string.h"
 
 namespace grpc_core {
 
@@ -81,8 +80,7 @@ class HttpConnectHandshaker : public Handshaker {
   Mutex mu_;
 
   bool is_shutdown_ ABSL_GUARDED_BY(mu_) = false;
-  // Endpoint and read buffer to destroy after a shutdown.
-  grpc_endpoint* endpoint_to_destroy_ ABSL_GUARDED_BY(mu_) = nullptr;
+  // Read buffer to destroy after a shutdown.
   grpc_slice_buffer* read_buffer_to_destroy_ ABSL_GUARDED_BY(mu_) = nullptr;
 
   // State saved while performing the handshake.
@@ -98,9 +96,6 @@ class HttpConnectHandshaker : public Handshaker {
 };
 
 HttpConnectHandshaker::~HttpConnectHandshaker() {
-  if (endpoint_to_destroy_ != nullptr) {
-    grpc_endpoint_destroy(endpoint_to_destroy_);
-  }
   if (read_buffer_to_destroy_ != nullptr) {
     grpc_slice_buffer_destroy(read_buffer_to_destroy_);
     gpr_free(read_buffer_to_destroy_);
@@ -113,8 +108,6 @@ HttpConnectHandshaker::~HttpConnectHandshaker() {
 // Set args fields to nullptr, saving the endpoint and read buffer for
 // later destruction.
 void HttpConnectHandshaker::CleanupArgsForFailureLocked() {
-  endpoint_to_destroy_ = args_->endpoint;
-  args_->endpoint = nullptr;
   read_buffer_to_destroy_ = args_->read_buffer;
   args_->read_buffer = nullptr;
   args_->args = ChannelArgs();
@@ -130,13 +123,10 @@ void HttpConnectHandshaker::HandshakeFailedLocked(grpc_error_handle error) {
     error = GRPC_ERROR_CREATE("Handshaker shutdown");
   }
   if (!is_shutdown_) {
-    // 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, error);
     // Not shutting down, so the handshake failed.  Clean up before
     // invoking the callback.
+    grpc_endpoint_destroy(args_->endpoint);
+    args_->endpoint = nullptr;
     CleanupArgsForFailureLocked();
     // Set shutdown to true so that subsequent calls to
     // http_connect_handshaker_shutdown() do nothing.
@@ -277,12 +267,13 @@ done:
 // Public handshaker methods
 //
 
-void HttpConnectHandshaker::Shutdown(grpc_error_handle why) {
+void HttpConnectHandshaker::Shutdown(grpc_error_handle /*why*/) {
   {
     MutexLock lock(&mu_);
     if (!is_shutdown_) {
       is_shutdown_ = true;
-      grpc_endpoint_shutdown(args_->endpoint, why);
+      grpc_endpoint_destroy(args_->endpoint);
+      args_->endpoint = nullptr;
       CleanupArgsForFailureLocked();
     }
   }
@@ -339,8 +330,8 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
   // Log connection via proxy.
   std::string proxy_name(grpc_endpoint_get_peer(args->endpoint));
   std::string server_name_string(*server_name);
-  gpr_log(GPR_INFO, "Connecting to server %s via HTTP proxy %s",
-          server_name_string.c_str(), proxy_name.c_str());
+  VLOG(2) << "Connecting to server " << server_name_string << " via HTTP proxy "
+          << proxy_name;
   // Construct HTTP CONNECT request.
   grpc_http_request request;
   request.method = const_cast<char*>("CONNECT");

data/src/core/{lib/transport → handshaker/http_connect}/http_connect_handshaker.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_HTTP_CONNECT_HANDSHAKER_H
-#define GRPC_SRC_CORE_LIB_TRANSPORT_HTTP_CONNECT_HANDSHAKER_H
+#ifndef GRPC_SRC_CORE_HANDSHAKER_HTTP_CONNECT_HTTP_CONNECT_HANDSHAKER_H
+#define GRPC_SRC_CORE_HANDSHAKER_HTTP_CONNECT_HTTP_CONNECT_HANDSHAKER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -39,4 +39,4 @@ void RegisterHttpConnectHandshaker(CoreConfiguration::Builder* builder);
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_HTTP_CONNECT_HANDSHAKER_H
+#endif  // GRPC_SRC_CORE_HANDSHAKER_HTTP_CONNECT_HTTP_CONNECT_HANDSHAKER_H

data/src/core/{client_channel → handshaker/http_connect}/http_proxy_mapper.cc

@@ -16,9 +16,7 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/client_channel/http_proxy_mapper.h"
+#include "src/core/handshaker/http_connect/http_proxy_mapper.h"
 
 #include <stdint.h>
 #include <string.h>
@@ -27,6 +25,8 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/ascii.h"
@@ -42,17 +42,18 @@
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
+#include "src/core/handshaker/http_connect/http_connect_handshaker.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/transport/http_connect_handshaker.h"
 #include "src/core/lib/uri/uri_parser.h"
+#include "src/core/util/string.h"
 
 namespace grpc_core {
 namespace {
@@ -107,7 +108,7 @@ bool AddressIncluded(
 ///
 absl::optional<std::string> GetHttpProxyServer(
     const ChannelArgs& args, absl::optional<std::string>* user_cred) {
-  GPR_ASSERT(user_cred != nullptr);
+  CHECK_NE(user_cred, nullptr);
   absl::StatusOr<URI> uri;
   // We check the following places to determine the HTTP proxy to use, stopping
   // at the first one that is set:
@@ -141,7 +142,7 @@ absl::optional<std::string> GetHttpProxyServer(
   size_t authority_nstrs;
   gpr_string_split(uri->authority().c_str(), "@", &authority_strs,
                    &authority_nstrs);
-  GPR_ASSERT(authority_nstrs != 0);  // should have at least 1 string
+  CHECK_NE(authority_nstrs, 0u);  // should have at least 1 string
   absl::optional<std::string> proxy_name;
   if (authority_nstrs == 1) {
     // User cred not present in authority
@@ -150,7 +151,7 @@ absl::optional<std::string> GetHttpProxyServer(
     // User cred found
     *user_cred = authority_strs[0];
     proxy_name = authority_strs[1];
-    gpr_log(GPR_DEBUG, "userinfo found in proxy URI");
+    VLOG(2) << "userinfo found in proxy URI";
   } else {
     // Bad authority
     proxy_name = absl::nullopt;
@@ -219,13 +220,11 @@ absl::optional<std::string> HttpProxyMapper::MapName(
     return absl::nullopt;
   }
   if (uri->scheme() == "unix") {
-    gpr_log(GPR_INFO, "not using proxy for Unix domain socket '%s'",
-            std::string(server_uri).c_str());
+    VLOG(2) << "not using proxy for Unix domain socket '" << server_uri << "'";
     return absl::nullopt;
   }
   if (uri->scheme() == "vsock") {
-    gpr_log(GPR_INFO, "not using proxy for VSock '%s'",
-            std::string(server_uri).c_str());
+    VLOG(2) << "not using proxy for VSock '" << server_uri << "'";
     return absl::nullopt;
   }
   // Prefer using 'no_grpc_proxy'. Fallback on 'no_proxy' if it is not set.
@@ -238,18 +237,17 @@ absl::optional<std::string> HttpProxyMapper::MapName(
     std::string server_port;
     if (!SplitHostPort(absl::StripPrefix(uri->path(), "/"), &server_host,
                        &server_port)) {
-      gpr_log(GPR_INFO,
-              "unable to split host and port, not checking no_proxy list for "
-              "host '%s'",
-              std::string(server_uri).c_str());
+      VLOG(2) << "unable to split host and port, not checking no_proxy list "
+                 "for host '"
+              << server_uri << "'";
     } else {
       auto address = StringToSockaddr(server_host, 0);
       if (AddressIncluded(address.ok()
                               ? absl::optional<grpc_resolved_address>(*address)
                               : absl::nullopt,
                           server_host, *no_proxy_str)) {
-        gpr_log(GPR_INFO, "not using proxy for host in no_proxy list '%s'",
-                std::string(server_uri).c_str());
+        VLOG(2) << "not using proxy for host in no_proxy list '" << server_uri
+                << "'";
         return absl::nullopt;
       }
     }