grpc 1.50.0.pre1 → 1.51.0

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

@@ -22,20 +22,25 @@
 
 #include <string.h>
 
+#include <memory>
 #include <new>
 
+#include "absl/status/status.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/default_event_engine.h"
 #include "src/core/lib/gpr/alloc.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/executor.h"
-#include "src/core/lib/iomgr/iomgr.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/transport_impl.h"
 
 grpc_core::DebugOnlyTraceFlag grpc_trace_stream_refcount(false,
                                                          "stream_refcount");
 
 void grpc_stream_destroy(grpc_stream_refcount* refcount) {
-  if (!grpc_iomgr_is_any_background_poller_thread() &&
-      (grpc_core::ExecCtx::Get()->flags() &
+  if ((grpc_core::ExecCtx::Get()->flags() &
        GRPC_EXEC_CTX_FLAG_THREAD_RESOURCE_LOOP)) {
     /* Ick.
        The thread we're running on MAY be owned (indirectly) by a call-stack.
@@ -44,10 +49,15 @@ void grpc_stream_destroy(grpc_stream_refcount* refcount) {
        cope with.
        Throw this over to the executor (on a core-owned thread) and process it
        there. */
-    grpc_core::Executor::Run(&refcount->destroy, GRPC_ERROR_NONE);
+    grpc_event_engine::experimental::GetDefaultEventEngine()->Run([refcount] {
+      grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+      grpc_core::ExecCtx exec_ctx;
+      grpc_core::ExecCtx::Run(DEBUG_LOCATION, &refcount->destroy,
+                              absl::OkStatus());
+    });
   } else {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, &refcount->destroy,
-                            GRPC_ERROR_NONE);
+                            absl::OkStatus());
   }
 }
 
@@ -162,28 +172,51 @@ void grpc_transport_stream_op_batch_queue_finish_with_failure(
     grpc_transport_stream_op_batch* batch, grpc_error_handle error,
     grpc_core::CallCombinerClosureList* closures) {
   if (batch->cancel_stream) {
-    GRPC_ERROR_UNREF(batch->payload->cancel_stream.cancel_error);
   }
   // Construct a list of closures to execute.
   if (batch->recv_initial_metadata) {
     closures->Add(
         batch->payload->recv_initial_metadata.recv_initial_metadata_ready,
-        GRPC_ERROR_REF(error), "failing recv_initial_metadata_ready");
+        error, "failing recv_initial_metadata_ready");
   }
   if (batch->recv_message) {
-    closures->Add(batch->payload->recv_message.recv_message_ready,
-                  GRPC_ERROR_REF(error), "failing recv_message_ready");
+    closures->Add(batch->payload->recv_message.recv_message_ready, error,
+                  "failing recv_message_ready");
   }
   if (batch->recv_trailing_metadata) {
     closures->Add(
         batch->payload->recv_trailing_metadata.recv_trailing_metadata_ready,
-        GRPC_ERROR_REF(error), "failing recv_trailing_metadata_ready");
+        error, "failing recv_trailing_metadata_ready");
+  }
+  if (batch->on_complete != nullptr) {
+    closures->Add(batch->on_complete, error, "failing on_complete");
+  }
+}
+
+void grpc_transport_stream_op_batch_finish_with_failure_from_transport(
+    grpc_transport_stream_op_batch* batch, grpc_error_handle error) {
+  if (batch->cancel_stream) {
+  }
+  // Construct a list of closures to execute.
+  if (batch->recv_initial_metadata) {
+    grpc_core::ExecCtx::Run(
+        DEBUG_LOCATION,
+        batch->payload->recv_initial_metadata.recv_initial_metadata_ready,
+        error);
+  }
+  if (batch->recv_message) {
+    grpc_core::ExecCtx::Run(
+        DEBUG_LOCATION, batch->payload->recv_message.recv_message_ready, error);
+  }
+  if (batch->recv_trailing_metadata) {
+    grpc_core::ExecCtx::Run(
+        DEBUG_LOCATION,
+        batch->payload->recv_trailing_metadata.recv_trailing_metadata_ready,
+        error);
   }
   if (batch->on_complete != nullptr) {
-    closures->Add(batch->on_complete, GRPC_ERROR_REF(error),
-                  "failing on_complete");
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, batch->on_complete, error);
   }
-  GRPC_ERROR_UNREF(error);
 }
 
 struct made_transport_op {
@@ -197,8 +230,7 @@ struct made_transport_op {
 
 static void destroy_made_transport_op(void* arg, grpc_error_handle error) {
   made_transport_op* op = static_cast<made_transport_op*>(arg);
-  grpc_core::ExecCtx::Run(DEBUG_LOCATION, op->inner_on_complete,
-                          GRPC_ERROR_REF(error));
+  grpc_core::ExecCtx::Run(DEBUG_LOCATION, op->inner_on_complete, error);
   delete op;
 }
 
@@ -223,7 +255,7 @@ static void destroy_made_transport_stream_op(void* arg,
   grpc_closure* c = op->inner_on_complete;
   delete op;
   if (c != nullptr) {
-    grpc_core::Closure::Run(DEBUG_LOCATION, c, GRPC_ERROR_REF(error));
+    grpc_core::Closure::Run(DEBUG_LOCATION, c, error);
   }
 }
 
@@ -237,3 +269,17 @@ grpc_transport_stream_op_batch* grpc_make_transport_stream_op(
   op->op.on_complete = &op->outer_on_complete;
   return &op->op;
 }
+
+namespace grpc_core {
+
+ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status) {
+  auto hdl =
+      GetContext<Arena>()->MakePooled<ServerMetadata>(GetContext<Arena>());
+  hdl->Set(GrpcStatusMetadata(), static_cast<grpc_status_code>(status.code()));
+  if (!status.ok()) {
+    hdl->Set(GrpcMessageMetadata(), Slice::FromCopiedString(status.message()));
+  }
+  return hdl;
+}
+
+}  // namespace grpc_core

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

@@ -27,6 +27,7 @@
 
 #include <functional>
 #include <string>
+#include <utility>
 
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
@@ -50,17 +51,15 @@
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/promise/arena_promise.h"
-#include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/detail/status.h"
 #include "src/core/lib/promise/latch.h"
+#include "src/core/lib/promise/pipe.h"
 #include "src/core/lib/resource_quota/arena.h"
-#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport_fwd.h"
 
-struct grpc_transport_stream_op_batch_payload;
-
 /* Minimum and maximum protocol accepted versions. */
 #define GRPC_PROTOCOL_VERSION_MAX_MAJOR 2
 #define GRPC_PROTOCOL_VERSION_MAX_MINOR 1
@@ -81,63 +80,37 @@ struct grpc_transport_stream_op_batch_payload;
   (GRPC_WRITE_INTERNAL_COMPRESS | GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED)
 
 namespace grpc_core {
-// TODO(ctiller): eliminate once MetadataHandle is constructable directly.
-namespace promise_filter_detail {
-class BaseCallData;
-}
-
-// Small unowned "handle" type to ensure one accessor at a time to metadata.
-// The focus here is to get promises to use the syntax we'd like - we'll
-// probably substitute some other smart pointer later.
-template <typename T>
-class MetadataHandle {
- public:
-  MetadataHandle() = default;
-
-  MetadataHandle(const MetadataHandle&) = delete;
-  MetadataHandle& operator=(const MetadataHandle&) = delete;
-
-  MetadataHandle(MetadataHandle&& other) noexcept : handle_(other.handle_) {
-    other.handle_ = nullptr;
-  }
-  MetadataHandle& operator=(MetadataHandle&& other) noexcept {
-    handle_ = other.handle_;
-    other.handle_ = nullptr;
-    return *this;
-  }
 
-  explicit MetadataHandle(const absl::Status& status) {
-    handle_ = GetContext<Arena>()->New<T>(GetContext<Arena>());
-    handle_->Set(GrpcStatusMetadata(),
-                 static_cast<grpc_status_code>(status.code()));
-    if (status.ok()) return;
-    handle_->Set(GrpcMessageMetadata(),
-                 Slice::FromCopiedString(status.message()));
-  }
+// Server metadata type
+// TODO(ctiller): This should be a bespoke instance of MetadataMap<>
+using ServerMetadata = grpc_metadata_batch;
+using ServerMetadataHandle = Arena::PoolPtr<ServerMetadata>;
 
-  T* operator->() const { return handle_; }
-  bool has_value() const { return handle_ != nullptr; }
-  T* get() const { return handle_; }
+// Client initial metadata type
+// TODO(ctiller): This should be a bespoke instance of MetadataMap<>
+using ClientMetadata = grpc_metadata_batch;
+using ClientMetadataHandle = Arena::PoolPtr<ClientMetadata>;
 
-  static MetadataHandle TestOnlyWrap(T* p) { return MetadataHandle(p); }
+class Message {
+ public:
+  Message() = default;
+  ~Message() = default;
+  Message(SliceBuffer payload, uint32_t flags)
+      : payload_(std::move(payload)), flags_(flags) {}
+  Message(const Message&) = delete;
+  Message& operator=(const Message&) = delete;
+
+  uint32_t flags() const { return flags_; }
+  uint32_t& mutable_flags() { return flags_; }
+  SliceBuffer* payload() { return &payload_; }
+  const SliceBuffer* payload() const { return &payload_; }
 
  private:
-  friend class promise_filter_detail::BaseCallData;
-
-  explicit MetadataHandle(T* handle) : handle_(handle) {}
-  T* Unwrap() {
-    T* result = handle_;
-    handle_ = nullptr;
-    return result;
-  }
-
-  T* handle_ = nullptr;
+  SliceBuffer payload_;
+  uint32_t flags_ = 0;
 };
 
-// Server metadata type
-// TODO(ctiller): This should be a bespoke instance of MetadataMap<>
-using ServerMetadata = grpc_metadata_batch;
-using ServerMetadataHandle = MetadataHandle<ServerMetadata>;
+using MessageHandle = Arena::PoolPtr<Message>;
 
 // Ok/not-ok check for trailing metadata, so that it can be used as result types
 // for TrySeq.
@@ -146,18 +119,36 @@ inline bool IsStatusOk(const ServerMetadataHandle& m) {
          GRPC_STATUS_OK;
 }
 
-// Client initial metadata type
-// TODO(ctiller): This should be a bespoke instance of MetadataMap<>
-using ClientMetadata = grpc_metadata_batch;
-using ClientMetadataHandle = MetadataHandle<ClientMetadata>;
+ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status);
 
-// Server initial metadata type
-// TODO(ctiller): This should be a bespoke instance of MetadataMap<>
-using ServerMetadataHandle = MetadataHandle<grpc_metadata_batch>;
+template <>
+struct StatusCastImpl<ServerMetadataHandle, absl::Status> {
+  static ServerMetadataHandle Cast(const absl::Status& m) {
+    return ServerMetadataFromStatus(m);
+  }
+};
+
+template <>
+struct StatusCastImpl<ServerMetadataHandle, const absl::Status&> {
+  static ServerMetadataHandle Cast(const absl::Status& m) {
+    return ServerMetadataFromStatus(m);
+  }
+};
 
 struct CallArgs {
+  // Initial metadata from the client to the server.
+  // During promise setup this can be manipulated by filters (and then
+  // passed on to the next filter).
   ClientMetadataHandle client_initial_metadata;
+  // Initial metadata from the server to the client.
+  // Set once when it's available.
+  // During promise setup filters can substitute their own latch for this
+  // and consequently intercept the sent value and mutate/observe it.
   Latch<ServerMetadata*>* server_initial_metadata;
+  // Messages travelling from the application to the transport.
+  PipeReceiver<MessageHandle>* outgoing_messages;
+  // Messages travelling from the transport to the application.
+  PipeSender<MessageHandle>* incoming_messages;
 };
 
 using NextPromiseFactory =
@@ -422,10 +413,11 @@ struct grpc_transport_stream_op_batch_payload {
 
   /** Forcefully close this stream.
       The HTTP2 semantics should be:
-      - server side: if cancel_error has GRPC_ERROR_INT_GRPC_STATUS, and
-        trailing metadata has not been sent, send trailing metadata with status
-        and message from cancel_error (use grpc_error_get_status) followed by
-        a RST_STREAM with error=GRPC_CHTTP2_NO_ERROR to force a full close
+      - server side: if cancel_error has
+     grpc_core::StatusIntProperty::kRpcStatus, and trailing metadata has not
+     been sent, send trailing metadata with status and message from cancel_error
+     (use grpc_error_get_status) followed by a RST_STREAM with
+     error=GRPC_CHTTP2_NO_ERROR to force a full close
       - at all other times: use grpc_error_get_status to get a status code, and
         convert to a HTTP2 error code using
         grpc_chttp2_grpc_status_to_http2_error. Send a RST_STREAM with this
@@ -433,7 +425,7 @@ struct grpc_transport_stream_op_batch_payload {
   struct {
     // Error contract: the transport that gets this op must cause cancel_error
     //                 to be unref'ed after processing it
-    grpc_error_handle cancel_error = GRPC_ERROR_NONE;
+    grpc_error_handle cancel_error;
   } cancel_stream;
 
   /* Indexes correspond to grpc_context_index enum values */
@@ -453,11 +445,11 @@ typedef struct grpc_transport_op {
   /** should the transport be disconnected
    * Error contract: the transport that gets this op must cause
    *                 disconnect_with_error to be unref'ed after processing it */
-  grpc_error_handle disconnect_with_error = GRPC_ERROR_NONE;
+  grpc_error_handle disconnect_with_error;
   /** what should the goaway contain?
    * Error contract: the transport that gets this op must cause
    *                 goaway_error to be unref'ed after processing it */
-  grpc_error_handle goaway_error = GRPC_ERROR_NONE;
+  grpc_error_handle goaway_error;
   /** set the callback for accepting new streams;
       this is a permanent callback, unlike the other one-shot closures.
       If true, the callback is set to set_accept_stream_fn, with its
@@ -538,6 +530,10 @@ void grpc_transport_stream_op_batch_finish_with_failure(
 void grpc_transport_stream_op_batch_queue_finish_with_failure(
     grpc_transport_stream_op_batch* batch, grpc_error_handle error,
     grpc_core::CallCombinerClosureList* closures);
+// Fail a batch from within the transport (i.e. without the activity lock/call
+// combiner taken).
+void grpc_transport_stream_op_batch_finish_with_failure_from_transport(
+    grpc_transport_stream_op_batch* batch, grpc_error_handle error);
 
 std::string grpc_transport_stream_op_batch_string(
     grpc_transport_stream_op_batch* op);

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

@@ -56,7 +56,7 @@ typedef struct grpc_transport_vtable {
      There is an on-going migration to move all filters to providing this, and
      then to drop perform_stream_op. */
   grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle> (*make_call_promise)(
-      grpc_transport* self, grpc_core::ClientMetadataHandle initial_metadata);
+      grpc_transport* self, grpc_core::CallArgs call_args);
 
   /* implementation of grpc_transport_set_pollset */
   void (*set_pollset)(grpc_transport* self, grpc_stream* stream,

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

@@ -32,6 +32,7 @@
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/connectivity_state.h"
@@ -86,7 +87,7 @@ std::string grpc_transport_stream_op_batch_string(
   if (op->cancel_stream) {
     out.push_back(absl::StrCat(
         " CANCEL:",
-        grpc_error_std_string(op->payload->cancel_stream.cancel_error)));
+        grpc_core::StatusToString(op->payload->cancel_stream.cancel_error)));
   }
 
   return absl::StrJoin(out, "");
@@ -107,14 +108,14 @@ std::string grpc_transport_op_string(grpc_transport_op* op) {
                                   op->stop_connectivity_watch));
   }
 
-  if (!GRPC_ERROR_IS_NONE(op->disconnect_with_error)) {
+  if (!op->disconnect_with_error.ok()) {
     out.push_back(absl::StrCat(
-        " DISCONNECT:", grpc_error_std_string(op->disconnect_with_error)));
+        " DISCONNECT:", grpc_core::StatusToString(op->disconnect_with_error)));
   }
 
-  if (!GRPC_ERROR_IS_NONE(op->goaway_error)) {
-    out.push_back(
-        absl::StrCat(" SEND_GOAWAY:", grpc_error_std_string(op->goaway_error)));
+  if (!op->goaway_error.ok()) {
+    out.push_back(absl::StrCat(" SEND_GOAWAY:",
+                               grpc_core::StatusToString(op->goaway_error)));
   }
 
   if (op->set_accept_stream) {

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -25,16 +25,11 @@
 #include "src/core/lib/transport/http_connect_handshaker.h"
 #include "src/core/lib/transport/tcp_connect_handshaker.h"
 
-extern void grpc_register_extra_plugins(void);
-
-void grpc_resolver_dns_ares_init(void);
-void grpc_resolver_dns_ares_shutdown(void);
-
-void grpc_register_built_in_plugins(void) {
-  grpc_register_plugin(grpc_resolver_dns_ares_init,
-                       grpc_resolver_dns_ares_shutdown);
-  grpc_register_extra_plugins();
-}
+namespace grpc_event_engine {
+namespace experimental {
+extern void RegisterEventEngineChannelArgPreconditioning(grpc_core::CoreConfiguration::Builder* builder);
+}  // namespace experimental
+}  // namespace grpc_event_engine
 
 namespace grpc_core {
 
@@ -74,6 +69,7 @@ extern void RegisterBinderResolver(CoreConfiguration::Builder* builder);
 #endif
 
 void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
+  grpc_event_engine::experimental::RegisterEventEngineChannelArgPreconditioning(builder);
   // The order of the handshaker registration is crucial here.
   // We want TCP connect handshaker to be registered last so that it is added to
   // the start of the handshaker list.

data/src/core/plugin_registry/grpc_plugin_registry_extra.cc

@@ -21,20 +21,6 @@
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/surface/builtins.h"
 
-#ifndef GRPC_NO_XDS
-namespace grpc_core {
-void XdsClientGlobalInit();
-void XdsClientGlobalShutdown();
-}  // namespace grpc_core
-#endif
-
-void grpc_register_extra_plugins() {
-#ifndef GRPC_NO_XDS
-  grpc_register_plugin(grpc_core::XdsClientGlobalInit,
-                       grpc_core::XdsClientGlobalShutdown);
-#endif
-}
-
 namespace grpc_core {
 #ifndef GRPC_NO_XDS
 extern void RbacFilterRegister(CoreConfiguration::Builder* builder);
@@ -49,6 +35,7 @@ extern void RegisterXdsClusterImplLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterCdsLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterXdsClusterResolverLbPolicy(
     CoreConfiguration::Builder* builder);
+extern void RegisterXdsWrrLocalityLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterFileWatcherCertificateProvider(
     CoreConfiguration::Builder* builder);
 #endif
@@ -67,6 +54,7 @@ void RegisterExtraFilters(CoreConfiguration::Builder* builder) {
   RegisterXdsClusterImplLbPolicy(builder);
   RegisterCdsLbPolicy(builder);
   RegisterXdsClusterResolverLbPolicy(builder);
+  RegisterXdsWrrLocalityLbPolicy(builder);
   RegisterFileWatcherCertificateProvider(builder);
 #endif
 }

data/src/core/tsi/alts/handshaker/alts_handshaker_client.cc

@@ -135,11 +135,11 @@ static void alts_grpc_handshaker_client_unref(
     client->send_buffer = nullptr;
     client->recv_buffer = nullptr;
     grpc_metadata_array_destroy(&client->recv_initial_metadata);
-    grpc_slice_unref_internal(client->recv_bytes);
-    grpc_slice_unref_internal(client->target_name);
+    grpc_core::CSliceUnref(client->recv_bytes);
+    grpc_core::CSliceUnref(client->target_name);
     grpc_alts_credentials_options_destroy(client->options);
     gpr_free(client->buffer);
-    grpc_slice_unref_internal(client->handshake_status_details);
+    grpc_core::CSliceUnref(client->handshake_status_details);
     delete client;
   }
 }
@@ -468,7 +468,7 @@ static void on_status_received(void* arg, grpc_error_handle error) {
             "alts_grpc_handshaker_client:%p on_status_received "
             "status:%d details:|%s| error:|%s|",
             client, client->handshake_status_code, status_details,
-            grpc_error_std_string(error).c_str());
+            grpc_core::StatusToString(error).c_str());
     gpr_free(status_details);
   }
   maybe_complete_tsi_next(client, true /* receive_status_finished */,
@@ -488,7 +488,7 @@ static grpc_byte_buffer* get_serialized_handshaker_req(
   }
   grpc_slice slice = grpc_slice_from_copied_buffer(buf, buf_length);
   grpc_byte_buffer* byte_buffer = grpc_raw_byte_buffer_create(&slice, 1);
-  grpc_slice_unref_internal(slice);
+  grpc_core::CSliceUnref(slice);
   return byte_buffer;
 }
 
@@ -639,8 +639,8 @@ static tsi_result handshaker_client_next(alts_handshaker_client* c,
   }
   alts_grpc_handshaker_client* client =
       reinterpret_cast<alts_grpc_handshaker_client*>(c);
-  grpc_slice_unref_internal(client->recv_bytes);
-  client->recv_bytes = grpc_slice_ref_internal(*bytes_received);
+  grpc_core::CSliceUnref(client->recv_bytes);
+  client->recv_bytes = grpc_core::CSliceRef(*bytes_received);
   grpc_byte_buffer* buffer = get_serialized_next(bytes_received);
   if (buffer == nullptr) {
     gpr_log(GPR_ERROR, "get_serialized_next() failed");
@@ -692,7 +692,7 @@ static void handshaker_client_destruct(alts_handshaker_client* c) {
           DEBUG_LOCATION,
           GRPC_CLOSURE_CREATE(handshaker_call_unref, client->call,
                               grpc_schedule_on_exec_ctx),
-          GRPC_ERROR_NONE);
+          absl::OkStatus());
     }
   }
 }
@@ -741,7 +741,7 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
                 channel, nullptr, GRPC_PROPAGATE_DEFAULTS, interested_parties,
                 grpc_slice_from_static_string(ALTS_SERVICE_METHOD), &slice,
                 grpc_core::Timestamp::InfFuture(), nullptr);
-  grpc_slice_unref_internal(slice);
+  grpc_core::CSliceUnref(slice);
   GRPC_CLOSURE_INIT(&client->on_handshaker_service_resp_recv, grpc_cb, client,
                     grpc_schedule_on_exec_ctx);
   GRPC_CLOSURE_INIT(&client->on_status_received, on_status_received, client,
@@ -789,7 +789,7 @@ void alts_handshaker_client_set_recv_bytes_for_testing(
   GPR_ASSERT(c != nullptr);
   alts_grpc_handshaker_client* client =
       reinterpret_cast<alts_grpc_handshaker_client*>(c);
-  client->recv_bytes = grpc_slice_ref_internal(*recv_bytes);
+  client->recv_bytes = CSliceRef(*recv_bytes);
 }
 
 void alts_handshaker_client_set_fields_for_testing(

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.cc

@@ -249,8 +249,8 @@ static void handshaker_result_destroy(tsi_handshaker_result* self) {
   gpr_free(result->peer_identity);
   gpr_free(result->key_data);
   gpr_free(result->unused_bytes);
-  grpc_slice_unref_internal(result->rpc_versions);
-  grpc_slice_unref_internal(result->serialized_context);
+  grpc_core::CSliceUnref(result->rpc_versions);
+  grpc_core::CSliceUnref(result->serialized_context);
   gpr_free(result);
 }
 
@@ -391,10 +391,10 @@ static void on_handshaker_service_resp_recv(void* arg,
     return;
   }
   bool success = true;
-  if (!GRPC_ERROR_IS_NONE(error)) {
+  if (!error.ok()) {
     gpr_log(GPR_INFO,
             "ALTS handshaker on_handshaker_service_resp_recv error: %s",
-            grpc_error_std_string(error).c_str());
+            grpc_core::StatusToString(error).c_str());
     success = false;
   }
   alts_handshaker_client_handle_response(client, success);
@@ -407,7 +407,7 @@ static void on_handshaker_service_resp_recv_dedicated(
   alts_shared_resource_dedicated* resource =
       grpc_alts_get_shared_resource_dedicated();
   grpc_cq_end_op(
-      resource->cq, arg, GRPC_ERROR_NONE,
+      resource->cq, arg, absl::OkStatus(),
       [](void* /*done_arg*/, grpc_cq_completion* /*storage*/) {}, nullptr,
       &resource->storage);
 }
@@ -481,7 +481,7 @@ static tsi_result alts_tsi_handshaker_continue_handshaker_next(
   } else {
     ok = alts_handshaker_client_next(handshaker->client, &slice);
   }
-  grpc_slice_unref_internal(slice);
+  grpc_core::CSliceUnref(slice);
   return ok;
 }
 
@@ -563,7 +563,7 @@ static tsi_result handshaker_next(
     // stack. Doing so avoids potential lock cycles between g_init_mu and other
     // mutexes within core that might be held on the current call stack
     // (note that g_init_mu gets acquired during channel creation).
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, &args->closure, GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, &args->closure, absl::OkStatus());
   } else {
     tsi_result ok = alts_tsi_handshaker_continue_handshaker_next(
         handshaker, received_bytes, received_bytes_size, cb, user_data, error);
@@ -612,7 +612,7 @@ static void handshaker_destroy(tsi_handshaker* self) {
   alts_tsi_handshaker* handshaker =
       reinterpret_cast<alts_tsi_handshaker*>(self);
   alts_handshaker_client_destroy(handshaker->client);
-  grpc_slice_unref_internal(handshaker->target_name);
+  grpc_core::CSliceUnref(handshaker->target_name);
   grpc_alts_credentials_options_destroy(handshaker->options);
   if (handshaker->channel != nullptr) {
     grpc_channel_destroy_internal(handshaker->channel);

data/src/core/tsi/alts/handshaker/alts_tsi_utils.cc

@@ -22,6 +22,7 @@
 
 #include <grpc/byte_buffer_reader.h>
 
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 tsi_result alts_tsi_utils_convert_to_tsi_result(grpc_status_code code) {
@@ -54,7 +55,7 @@ grpc_gcp_HandshakerResp* alts_tsi_utils_deserialize_response(
          buf_size);
   grpc_gcp_HandshakerResp* resp = grpc_gcp_HandshakerResp_parse(
       reinterpret_cast<char*>(buf), buf_size, arena);
-  grpc_slice_unref_internal(slice);
+  grpc_core::CSliceUnref(slice);
   grpc_byte_buffer_reader_destroy(&bbr);
   if (resp == nullptr) {
     gpr_log(GPR_ERROR, "grpc_gcp_handshaker_resp_decode() failed");

data/src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_integrity_only_record_protocol.cc

@@ -25,6 +25,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol_common.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_iovec_record_protocol.h"
@@ -71,7 +72,7 @@ static tsi_result alts_grpc_integrity_only_extra_copy_protect(
     return TSI_INTERNAL_ERROR;
   }
   grpc_slice_buffer_add(protected_slices, protected_slice);
-  grpc_slice_buffer_reset_and_unref_internal(unprotected_slices);
+  grpc_slice_buffer_reset_and_unref(unprotected_slices);
   return TSI_OK;
 }
 
@@ -138,14 +139,13 @@ static tsi_result alts_grpc_integrity_only_unprotect(
   alts_grpc_integrity_only_record_protocol* integrity_only_record_protocol =
       reinterpret_cast<alts_grpc_integrity_only_record_protocol*>(rp);
   /* Strips frame header from protected slices.  */
-  grpc_slice_buffer_reset_and_unref_internal(&rp->header_sb);
+  grpc_slice_buffer_reset_and_unref(&rp->header_sb);
   grpc_slice_buffer_move_first(protected_slices, rp->header_length,
                                &rp->header_sb);
   GPR_ASSERT(rp->header_sb.length == rp->header_length);
   iovec_t header_iovec = alts_grpc_record_protocol_get_header_iovec(rp);
   /* Moves protected slices data to data_sb and leaves the remaining tag.  */
-  grpc_slice_buffer_reset_and_unref_internal(
-      &integrity_only_record_protocol->data_sb);
+  grpc_slice_buffer_reset_and_unref(&integrity_only_record_protocol->data_sb);
   grpc_slice_buffer_move_first(protected_slices,
                                protected_slices->length - rp->tag_length,
                                &integrity_only_record_protocol->data_sb);
@@ -173,8 +173,8 @@ static tsi_result alts_grpc_integrity_only_unprotect(
     gpr_free(error_details);
     return TSI_INTERNAL_ERROR;
   }
-  grpc_slice_buffer_reset_and_unref_internal(&rp->header_sb);
-  grpc_slice_buffer_reset_and_unref_internal(protected_slices);
+  grpc_slice_buffer_reset_and_unref(&rp->header_sb);
+  grpc_slice_buffer_reset_and_unref(protected_slices);
   grpc_slice_buffer_move_into(&integrity_only_record_protocol->data_sb,
                               unprotected_slices);
   return TSI_OK;
@@ -186,7 +186,7 @@ static void alts_grpc_integrity_only_destruct(alts_grpc_record_protocol* rp) {
   }
   alts_grpc_integrity_only_record_protocol* integrity_only_rp =
       reinterpret_cast<alts_grpc_integrity_only_record_protocol*>(rp);
-  grpc_slice_buffer_destroy_internal(&integrity_only_rp->data_sb);
+  grpc_slice_buffer_destroy(&integrity_only_rp->data_sb);
   gpr_free(integrity_only_rp->tag_buf);
 }