grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

data/src/core/lib/transport/error_utils.h

@@ -50,14 +50,14 @@ absl::Status grpc_error_to_absl_status(grpc_error_handle error);
 
 /// Utility function to convert an absl::Status \a status to grpc_error. Note
 /// that this method does not return "special case" errors such as
-/// GRPC_ERROR_CANCELLED, with the exception of GRPC_ERROR_NONE returned for
+/// absl::CancelledError(), with the exception of absl::OkStatus() returned for
 /// \a absl::OkStatus().
 grpc_error_handle absl_status_to_grpc_error(absl::Status status);
 
 /// A utility function to check whether there is a clear status code that
 /// doesn't need to be guessed in \a error. This means that \a error or some
-/// child has GRPC_ERROR_INT_GRPC_STATUS set, or that it is GRPC_ERROR_NONE or
-/// GRPC_ERROR_CANCELLED
+/// child has grpc_core::StatusIntProperty::kRpcStatus set, or that it is
+/// absl::OkStatus() or absl::CancelledError()
 bool grpc_error_has_clear_grpc_status(grpc_error_handle error);
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_ERROR_UTILS_H */

data/src/core/lib/transport/handshaker.cc

@@ -25,6 +25,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
@@ -35,9 +36,9 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/slice/slice_internal.h"
 
 namespace grpc_core {
 
@@ -78,10 +79,9 @@ void HandshakeManager::Shutdown(grpc_error_handle why) {
     // Shutdown the handshaker that's currently in progress, if any.
     if (!is_shutdown_ && index_ > 0) {
       is_shutdown_ = true;
-      handshakers_[index_ - 1]->Shutdown(GRPC_ERROR_REF(why));
+      handshakers_[index_ - 1]->Shutdown(why);
     }
   }
-  GRPC_ERROR_UNREF(why);
 }
 
 // Helper function to call either the next handshaker or the
@@ -92,17 +92,17 @@ bool HandshakeManager::CallNextHandshakerLocked(grpc_error_handle error) {
     gpr_log(GPR_INFO,
             "handshake_manager %p: error=%s shutdown=%d index=%" PRIuPTR
             ", args=%s",
-            this, grpc_error_std_string(error).c_str(), is_shutdown_, index_,
+            this, StatusToString(error).c_str(), is_shutdown_, index_,
             HandshakerArgsString(&args_).c_str());
   }
   GPR_ASSERT(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.
-  if (!GRPC_ERROR_IS_NONE(error) || is_shutdown_ || args_.exit_early ||
+  if (!error.ok() || is_shutdown_ || args_.exit_early ||
       index_ == handshakers_.size()) {
-    if (GRPC_ERROR_IS_NONE(error) && is_shutdown_) {
-      error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("handshaker shutdown");
+    if (error.ok() && is_shutdown_) {
+      error = GRPC_ERROR_CREATE("handshaker shutdown");
       // It is possible that the endpoint has already been destroyed by
       // a shutdown call while this callback was sitting on the ExecCtx
       // with no error.
@@ -111,11 +111,11 @@ bool HandshakeManager::CallNextHandshakerLocked(grpc_error_handle error) {
         // 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, GRPC_ERROR_REF(error));
+        grpc_endpoint_shutdown(args_.endpoint, error);
         grpc_endpoint_destroy(args_.endpoint);
         args_.endpoint = nullptr;
         args_.args = ChannelArgs();
-        grpc_slice_buffer_destroy_internal(args_.read_buffer);
+        grpc_slice_buffer_destroy(args_.read_buffer);
         gpr_free(args_.read_buffer);
         args_.read_buffer = nullptr;
       }
@@ -124,7 +124,7 @@ bool HandshakeManager::CallNextHandshakerLocked(grpc_error_handle error) {
       gpr_log(GPR_INFO,
               "handshake_manager %p: handshaking complete -- scheduling "
               "on_handshake_done with error=%s",
-              this, grpc_error_std_string(error).c_str());
+              this, StatusToString(error).c_str());
     }
     // Cancel deadline timer, since we're invoking the on_handshake_done
     // callback now.
@@ -151,7 +151,7 @@ void HandshakeManager::CallNextHandshakerFn(void* arg,
   bool done;
   {
     MutexLock lock(&mgr->mu_);
-    done = mgr->CallNextHandshakerLocked(GRPC_ERROR_REF(error));
+    done = mgr->CallNextHandshakerLocked(error);
   }
   // If we're invoked the final callback, we won't be coming back
   // to this function, so we can release our reference to the
@@ -163,8 +163,8 @@ void HandshakeManager::CallNextHandshakerFn(void* arg,
 
 void HandshakeManager::OnTimeoutFn(void* arg, grpc_error_handle error) {
   auto* mgr = static_cast<HandshakeManager*>(arg);
-  if (GRPC_ERROR_IS_NONE(error)) {  // Timer fired, rather than being cancelled
-    mgr->Shutdown(GRPC_ERROR_CREATE_FROM_STATIC_STRING("Handshake timed out"));
+  if (error.ok()) {  // Timer fired, rather than being cancelled
+    mgr->Shutdown(GRPC_ERROR_CREATE("Handshake timed out"));
   }
   mgr->Unref();
 }
@@ -207,7 +207,7 @@ void HandshakeManager::DoHandshake(grpc_endpoint* endpoint,
     grpc_timer_init(&deadline_timer_, deadline, &on_timeout_);
     // Start first handshaker, which also owns a ref.
     Ref().release();
-    done = CallNextHandshakerLocked(GRPC_ERROR_NONE);
+    done = CallNextHandshakerLocked(absl::OkStatus());
   }
   if (done) {
     Unref();

data/src/core/lib/transport/handshaker.h

@@ -117,7 +117,7 @@ class HandshakeManager : public RefCounted<HandshakeManager> {
   ///
   /// When done, invokes \a on_handshake_done with a HandshakerArgs
   /// object as its argument.  If the callback is invoked with error !=
-  /// GRPC_ERROR_NONE, then handshaking failed and the handshaker has done
+  /// absl::OkStatus(), then handshaking failed and the handshaker has done
   /// the necessary clean-up.  Otherwise, the callback takes ownership of
   /// the arguments.
   void DoHandshake(grpc_endpoint* endpoint, const ChannelArgs& channel_args,

data/src/core/lib/transport/handshaker_factory.h

@@ -37,9 +37,35 @@ class HandshakeManager;
 
 class HandshakerFactory {
  public:
+  // Enum representing the priority of the handshakers.
+  // The order of the handshakers is decided by the priority.
+  // For example kPreTCPConnect handshakers are called before kTCPConnect and so
+  // on.
+  enum class HandshakerPriority : int {
+    // Handshakers that should be called before a TCP connect. Applicable mainly
+    // for Client handshakers.
+    kPreTCPConnectHandshakers,
+    // Handshakers responsible for the actual TCP connect establishment.
+    // Applicable mainly for Client handshakers.
+    kTCPConnectHandshakers,
+    // Handshakers responsible for the actual HTTP connect established.
+    // Applicable
+    // mainly for Client handshakers.
+    kHTTPConnectHandshakers,
+    // Handshakers that should be called before security handshakes but after
+    // connect establishment. Applicable mainly for Server handshakers
+    // currently.
+    kReadAheadSecurityHandshakers,
+    // Handshakers that are responsible for post connect security handshakes.
+    // Applicable for both Client and Server handshakers.
+    kSecurityHandshakers,
+  };
+
   virtual void AddHandshakers(const ChannelArgs& args,
                               grpc_pollset_set* interested_parties,
                               HandshakeManager* handshake_mgr) = 0;
+  // Return the priority associated with the handshaker.
+  virtual HandshakerPriority Priority() = 0;
   virtual ~HandshakerFactory() = default;
 };
 

data/src/core/lib/transport/handshaker_registry.cc

@@ -28,10 +28,16 @@
 namespace grpc_core {
 
 void HandshakerRegistry::Builder::RegisterHandshakerFactory(
-    bool at_start, HandshakerType handshaker_type,
+    HandshakerType handshaker_type,
     std::unique_ptr<HandshakerFactory> factory) {
   auto& vec = factories_[handshaker_type];
-  auto where = at_start ? vec.begin() : vec.end();
+  auto where = vec.empty() ? vec.begin() : vec.end();
+  for (auto iter = vec.begin(); iter != vec.end(); ++iter) {
+    if (factory->Priority() < iter->get()->Priority()) {
+      where = iter;
+      break;
+    }
+  }
   vec.insert(where, std::move(factory));
 }
 

data/src/core/lib/transport/handshaker_registry.h

@@ -41,10 +41,9 @@ class HandshakerRegistry {
   class Builder {
    public:
     /// Registers a new handshaker factory.  Takes ownership.
-    /// If \a at_start is true, the new handshaker will be at the beginning of
-    /// the list.  Otherwise, it will be added to the end.
-    void RegisterHandshakerFactory(bool at_start,
-                                   HandshakerType handshaker_type,
+    /// The priority of the handshaker will be used to order the handshakers
+    /// in the list.
+    void RegisterHandshakerFactory(HandshakerType handshaker_type,
                                    std::unique_ptr<HandshakerFactory> factory);
 
     HandshakerRegistry Build();

data/src/core/lib/transport/http_connect_handshaker.cc

@@ -27,7 +27,7 @@
 #include <string>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/memory/memory.h"
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
@@ -51,7 +51,6 @@
 #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/slice/slice_internal.h"
 #include "src/core/lib/transport/handshaker.h"
 #include "src/core/lib/transport/handshaker_factory.h"
 #include "src/core/lib/transport/handshaker_registry.h"
@@ -103,10 +102,10 @@ HttpConnectHandshaker::~HttpConnectHandshaker() {
     grpc_endpoint_destroy(endpoint_to_destroy_);
   }
   if (read_buffer_to_destroy_ != nullptr) {
-    grpc_slice_buffer_destroy_internal(read_buffer_to_destroy_);
+    grpc_slice_buffer_destroy(read_buffer_to_destroy_);
     gpr_free(read_buffer_to_destroy_);
   }
-  grpc_slice_buffer_destroy_internal(&write_buffer_);
+  grpc_slice_buffer_destroy(&write_buffer_);
   grpc_http_parser_destroy(&http_parser_);
   grpc_http_response_destroy(&http_response_);
 }
@@ -124,18 +123,18 @@ void HttpConnectHandshaker::CleanupArgsForFailureLocked() {
 // If the handshake failed or we're shutting down, clean up and invoke the
 // callback with the error.
 void HttpConnectHandshaker::HandshakeFailedLocked(grpc_error_handle error) {
-  if (GRPC_ERROR_IS_NONE(error)) {
+  if (error.ok()) {
     // If we were shut down after an endpoint operation succeeded but
     // before the endpoint callback was invoked, we need to generate our
     // own error.
-    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Handshaker shutdown");
+    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, GRPC_ERROR_REF(error));
+    grpc_endpoint_shutdown(args_->endpoint, error);
     // Not shutting down, so the handshake failed.  Clean up before
     // invoking the callback.
     CleanupArgsForFailureLocked();
@@ -156,17 +155,17 @@ void HttpConnectHandshaker::OnWriteDoneScheduler(void* arg,
                GRPC_CLOSURE_INIT(&handshaker->request_done_closure_,
                                  &HttpConnectHandshaker::OnWriteDone,
                                  handshaker, grpc_schedule_on_exec_ctx),
-               GRPC_ERROR_REF(error));
+               error);
 }
 
 // Callback invoked when finished writing HTTP CONNECT request.
 void HttpConnectHandshaker::OnWriteDone(void* arg, grpc_error_handle error) {
   auto* handshaker = static_cast<HttpConnectHandshaker*>(arg);
   ReleasableMutexLock lock(&handshaker->mu_);
-  if (!GRPC_ERROR_IS_NONE(error) || handshaker->is_shutdown_) {
+  if (!error.ok() || 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));
+    handshaker->HandshakeFailedLocked(error);
     lock.Release();
     handshaker->Unref();
   } else {
@@ -190,17 +189,17 @@ void HttpConnectHandshaker::OnReadDoneScheduler(void* arg,
                GRPC_CLOSURE_INIT(&handshaker->response_read_closure_,
                                  &HttpConnectHandshaker::OnReadDone, handshaker,
                                  grpc_schedule_on_exec_ctx),
-               GRPC_ERROR_REF(error));
+               error);
 }
 
 // Callback invoked for reading HTTP CONNECT response.
 void HttpConnectHandshaker::OnReadDone(void* arg, grpc_error_handle error) {
   auto* handshaker = static_cast<HttpConnectHandshaker*>(arg);
   ReleasableMutexLock lock(&handshaker->mu_);
-  if (!GRPC_ERROR_IS_NONE(error) || handshaker->is_shutdown_) {
+  if (!error.ok() || handshaker->is_shutdown_) {
     // If the read failed or we're shutting down, clean up and invoke the
     // callback with the error.
-    handshaker->HandshakeFailedLocked(GRPC_ERROR_REF(error));
+    handshaker->HandshakeFailedLocked(error);
     goto done;
   }
   // Add buffer to parser.
@@ -210,7 +209,7 @@ void HttpConnectHandshaker::OnReadDone(void* arg, grpc_error_handle error) {
       error = grpc_http_parser_parse(&handshaker->http_parser_,
                                      handshaker->args_->read_buffer->slices[i],
                                      &body_start_offset);
-      if (!GRPC_ERROR_IS_NONE(error)) {
+      if (!error.ok()) {
         handshaker->HandshakeFailedLocked(error);
         goto done;
       }
@@ -230,7 +229,7 @@ void HttpConnectHandshaker::OnReadDone(void* arg, grpc_error_handle error) {
                                &handshaker->args_->read_buffer->slices[i + 1],
                                handshaker->args_->read_buffer->count - i - 1);
         grpc_slice_buffer_swap(handshaker->args_->read_buffer, &tmp_buffer);
-        grpc_slice_buffer_destroy_internal(&tmp_buffer);
+        grpc_slice_buffer_destroy(&tmp_buffer);
         break;
       }
     }
@@ -247,7 +246,7 @@ void HttpConnectHandshaker::OnReadDone(void* arg, grpc_error_handle error) {
   // complete (e.g., handling chunked transfer encoding or looking
   // 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_slice_buffer_reset_and_unref(handshaker->args_->read_buffer);
     grpc_endpoint_read(
         handshaker->args_->endpoint, handshaker->args_->read_buffer,
         GRPC_CLOSURE_INIT(&handshaker->response_read_closure_,
@@ -259,9 +258,8 @@ void HttpConnectHandshaker::OnReadDone(void* arg, grpc_error_handle error) {
   // Make sure we got a 2xx response.
   if (handshaker->http_response_.status < 200 ||
       handshaker->http_response_.status >= 300) {
-    error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
-        absl::StrCat("HTTP proxy returned response code ",
-                     handshaker->http_response_.status));
+    error = GRPC_ERROR_CREATE(absl::StrCat("HTTP proxy returned response code ",
+                                           handshaker->http_response_.status));
     handshaker->HandshakeFailedLocked(error);
     goto done;
   }
@@ -284,11 +282,10 @@ void HttpConnectHandshaker::Shutdown(grpc_error_handle why) {
     MutexLock lock(&mu_);
     if (!is_shutdown_) {
       is_shutdown_ = true;
-      grpc_endpoint_shutdown(args_->endpoint, GRPC_ERROR_REF(why));
+      grpc_endpoint_shutdown(args_->endpoint, why);
       CleanupArgsForFailureLocked();
     }
   }
-  GRPC_ERROR_UNREF(why);
 }
 
 void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
@@ -305,7 +302,7 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
       MutexLock lock(&mu_);
       is_shutdown_ = true;
     }
-    ExecCtx::Run(DEBUG_LOCATION, on_handshake_done, GRPC_ERROR_NONE);
+    ExecCtx::Run(DEBUG_LOCATION, on_handshake_done, absl::OkStatus());
     return;
   }
   // Get headers from channel args.
@@ -387,6 +384,9 @@ class HttpConnectHandshakerFactory : public HandshakerFactory {
                       HandshakeManager* handshake_mgr) override {
     handshake_mgr->Add(MakeRefCounted<HttpConnectHandshaker>());
   }
+  HandshakerPriority Priority() override {
+    return HandshakerPriority::kHTTPConnectHandshakers;
+  }
   ~HttpConnectHandshakerFactory() override = default;
 };
 
@@ -394,8 +394,7 @@ class HttpConnectHandshakerFactory : public HandshakerFactory {
 
 void RegisterHttpConnectHandshaker(CoreConfiguration::Builder* builder) {
   builder->handshaker_registry()->RegisterHandshakerFactory(
-      true /* at_start */, HANDSHAKER_CLIENT,
-      absl::make_unique<HttpConnectHandshakerFactory>());
+      HANDSHAKER_CLIENT, std::make_unique<HttpConnectHandshakerFactory>());
 }
 
 }  // namespace grpc_core

data/src/core/lib/transport/metadata_batch.h

@@ -387,6 +387,14 @@ struct GrpcStatusContext {
   static const std::string& DisplayValue(const std::string& x);
 };
 
+// Annotation added by a transport to note that the status came from the wire.
+struct GrpcStatusFromWire {
+  static absl::string_view DebugKey() { return "GrpcStatusFromWire"; }
+  static constexpr bool kRepeatable = false;
+  using ValueType = bool;
+  static absl::string_view DisplayValue(bool x) { return x ? "true" : "false"; }
+};
+
 // Annotation added by client surface code to denote wait-for-ready state
 struct WaitForReady {
   struct ValueType {
@@ -645,6 +653,13 @@ struct AdaptDisplayValueToLog<const std::string&> {
   static std::string ToString(const std::string& value) { return value; }
 };
 
+template <>
+struct AdaptDisplayValueToLog<absl::string_view> {
+  static std::string ToString(absl::string_view value) {
+    return std::string(value);
+  }
+};
+
 template <>
 struct AdaptDisplayValueToLog<Slice> {
   static std::string ToString(Slice value) {
@@ -1301,7 +1316,8 @@ using grpc_metadata_batch_base = grpc_core::MetadataMap<
     grpc_core::LbCostBinMetadata, grpc_core::LbTokenMetadata,
     // Non-encodable things
     grpc_core::GrpcStreamNetworkState, grpc_core::PeerString,
-    grpc_core::GrpcStatusContext, grpc_core::WaitForReady>;
+    grpc_core::GrpcStatusContext, grpc_core::GrpcStatusFromWire,
+    grpc_core::WaitForReady>;
 
 struct grpc_metadata_batch : public grpc_metadata_batch_base {
   using grpc_metadata_batch_base::grpc_metadata_batch_base;

data/src/core/lib/transport/parsed_metadata.cc

@@ -16,8 +16,6 @@
 
 #include "src/core/lib/transport/parsed_metadata.h"
 
-#include "src/core/lib/slice/slice_refcount.h"
-
 namespace grpc_core {
 namespace metadata_detail {
 
@@ -26,12 +24,10 @@ std::string MakeDebugString(absl::string_view key, absl::string_view value) {
 }
 
 Slice SliceFromBuffer(const Buffer& buffer) {
-  return Slice(grpc_slice_ref_internal(buffer.slice));
+  return Slice(CSliceRef(buffer.slice));
 }
 
-void DestroySliceValue(const Buffer& value) {
-  grpc_slice_unref_internal(value.slice);
-}
+void DestroySliceValue(const Buffer& value) { CSliceUnref(value.slice); }
 
 void DestroyTrivialMemento(const Buffer&) {}
 

data/src/core/lib/transport/tcp_connect_handshaker.cc

@@ -23,12 +23,13 @@
 #include <memory>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/memory/memory.h"
+#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
 #include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
@@ -49,7 +50,6 @@
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_server.h"
-#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/transport/handshaker.h"
 #include "src/core/lib/transport/handshaker_factory.h"
 #include "src/core/lib/transport/handshaker_registry.h"
@@ -100,7 +100,7 @@ TCPConnectHandshaker::TCPConnectHandshaker(grpc_pollset_set* pollset_set)
   GRPC_CLOSURE_INIT(&connected_, Connected, this, grpc_schedule_on_exec_ctx);
 }
 
-void TCPConnectHandshaker::Shutdown(grpc_error_handle why) {
+void TCPConnectHandshaker::Shutdown(grpc_error_handle /*why*/) {
   // TODO(anramach): After migration to EventEngine, cancel the in-progress
   // TCP connection attempt.
   {
@@ -113,12 +113,10 @@ void TCPConnectHandshaker::Shutdown(grpc_error_handle why) {
       // the necessary clean up.
       if (on_handshake_done_ != nullptr) {
         CleanupArgsForFailureLocked();
-        FinishLocked(
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING("tcp handshaker shutdown"));
+        FinishLocked(GRPC_ERROR_CREATE("tcp handshaker shutdown"));
       }
     }
   }
-  GRPC_ERROR_UNREF(why);
 }
 
 void TCPConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
@@ -134,8 +132,7 @@ void TCPConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
       args->args.GetString(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS).value());
   if (!uri.ok() || !grpc_parse_uri(*uri, &addr_)) {
     MutexLock lock(&mu_);
-    FinishLocked(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Resolved address in invalid format"));
+    FinishLocked(GRPC_ERROR_CREATE("Resolved address in invalid format"));
     return;
   }
   bind_endpoint_to_pollset_ =
@@ -167,15 +164,12 @@ void TCPConnectHandshaker::Connected(void* arg, grpc_error_handle error) {
       static_cast<TCPConnectHandshaker*>(arg));
   {
     MutexLock lock(&self->mu_);
-    if (!GRPC_ERROR_IS_NONE(error) || self->shutdown_) {
-      if (GRPC_ERROR_IS_NONE(error)) {
-        error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("tcp handshaker shutdown");
-      } else {
-        error = GRPC_ERROR_REF(error);
+    if (!error.ok() || self->shutdown_) {
+      if (error.ok()) {
+        error = GRPC_ERROR_CREATE("tcp handshaker shutdown");
       }
       if (self->endpoint_to_destroy_ != nullptr) {
-        grpc_endpoint_shutdown(self->endpoint_to_destroy_,
-                               GRPC_ERROR_REF(error));
+        grpc_endpoint_shutdown(self->endpoint_to_destroy_, error);
       }
       if (!self->shutdown_) {
         self->CleanupArgsForFailureLocked();
@@ -185,7 +179,6 @@ void TCPConnectHandshaker::Connected(void* arg, grpc_error_handle error) {
         // The on_handshake_done_ is already as part of shutdown when
         // connecting So nothing to be done here other than unrefing the
         // error.
-        GRPC_ERROR_UNREF(error);
       }
       return;
     }
@@ -196,7 +189,7 @@ void TCPConnectHandshaker::Connected(void* arg, grpc_error_handle error) {
       grpc_endpoint_add_to_pollset_set(self->args_->endpoint,
                                        self->interested_parties_);
     }
-    self->FinishLocked(GRPC_ERROR_NONE);
+    self->FinishLocked(absl::OkStatus());
   }
 }
 
@@ -205,7 +198,7 @@ TCPConnectHandshaker::~TCPConnectHandshaker() {
     grpc_endpoint_destroy(endpoint_to_destroy_);
   }
   if (read_buffer_to_destroy_ != nullptr) {
-    grpc_slice_buffer_destroy_internal(read_buffer_to_destroy_);
+    grpc_slice_buffer_destroy(read_buffer_to_destroy_);
     gpr_free(read_buffer_to_destroy_);
   }
   grpc_pollset_set_destroy(interested_parties_);
@@ -237,6 +230,9 @@ class TCPConnectHandshakerFactory : public HandshakerFactory {
     handshake_mgr->Add(
         MakeRefCounted<TCPConnectHandshaker>(interested_parties));
   }
+  HandshakerPriority Priority() override {
+    return HandshakerPriority::kTCPConnectHandshakers;
+  }
   ~TCPConnectHandshakerFactory() override = default;
 };
 
@@ -244,8 +240,7 @@ class TCPConnectHandshakerFactory : public HandshakerFactory {
 
 void RegisterTCPConnectHandshaker(CoreConfiguration::Builder* builder) {
   builder->handshaker_registry()->RegisterHandshakerFactory(
-      true /* at_start */, HANDSHAKER_CLIENT,
-      absl::make_unique<TCPConnectHandshakerFactory>());
+      HANDSHAKER_CLIENT, std::make_unique<TCPConnectHandshakerFactory>());
 }
 
 }  // namespace grpc_core