grpc 1.40.0 → 1.43.1

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

@@ -20,6 +20,7 @@
 
 #include "src/core/lib/transport/status_metadata.h"
 
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/transport/static_metadata.h"
 

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

@@ -61,25 +61,6 @@ void slice_stream_destroy(void* arg) {
   grpc_stream_destroy(static_cast<grpc_stream_refcount*>(arg));
 }
 
-#define STREAM_REF_FROM_SLICE_REF(p)         \
-  ((grpc_stream_refcount*)(((uint8_t*)(p)) - \
-                           offsetof(grpc_stream_refcount, slice_refcount)))
-
-grpc_slice grpc_slice_from_stream_owned_buffer(grpc_stream_refcount* refcount,
-                                               void* buffer, size_t length) {
-#ifndef NDEBUG
-  grpc_stream_ref(STREAM_REF_FROM_SLICE_REF(&refcount->slice_refcount),
-                  "slice");
-#else
-  grpc_stream_ref(STREAM_REF_FROM_SLICE_REF(&refcount->slice_refcount));
-#endif
-  grpc_slice res;
-  res.refcount = &refcount->slice_refcount;
-  res.data.refcounted.bytes = static_cast<uint8_t*>(buffer);
-  res.data.refcounted.length = length;
-  return res;
-}
-
 #ifndef NDEBUG
 void grpc_stream_ref_init(grpc_stream_refcount* refcount, int /*initial_refs*/,
                           grpc_iomgr_cb_func cb, void* cb_arg,
@@ -94,21 +75,18 @@ void grpc_stream_ref_init(grpc_stream_refcount* refcount, int /*initial_refs*/,
   new (&refcount->refs) grpc_core::RefCount(
       1, GRPC_TRACE_FLAG_ENABLED(grpc_trace_stream_refcount) ? "stream_refcount"
                                                              : nullptr);
-  new (&refcount->slice_refcount) grpc_slice_refcount(
-      grpc_slice_refcount::Type::REGULAR, &refcount->refs, slice_stream_destroy,
-      refcount, &refcount->slice_refcount);
 }
 
-static void move64(uint64_t* from, uint64_t* to) {
+static void move64bits(uint64_t* from, uint64_t* to) {
   *to += *from;
   *from = 0;
 }
 
 void grpc_transport_move_one_way_stats(grpc_transport_one_way_stats* from,
                                        grpc_transport_one_way_stats* to) {
-  move64(&from->framing_bytes, &to->framing_bytes);
-  move64(&from->data_bytes, &to->data_bytes);
-  move64(&from->header_bytes, &to->header_bytes);
+  move64bits(&from->framing_bytes, &to->framing_bytes);
+  move64bits(&from->data_bytes, &to->data_bytes);
+  move64bits(&from->header_bytes, &to->header_bytes);
 }
 
 void grpc_transport_move_stats(grpc_transport_stream_stats* from,
@@ -237,22 +215,21 @@ grpc_transport_op* grpc_make_transport_op(grpc_closure* on_complete) {
 
 struct made_transport_stream_op {
   grpc_closure outer_on_complete;
-  grpc_closure* inner_on_complete;
+  grpc_closure* inner_on_complete = nullptr;
   grpc_transport_stream_op_batch op;
-  grpc_transport_stream_op_batch_payload payload;
+  grpc_transport_stream_op_batch_payload payload{nullptr};
 };
 static void destroy_made_transport_stream_op(void* arg,
                                              grpc_error_handle error) {
   made_transport_stream_op* op = static_cast<made_transport_stream_op*>(arg);
   grpc_closure* c = op->inner_on_complete;
-  gpr_free(op);
+  delete op;
   grpc_core::Closure::Run(DEBUG_LOCATION, c, GRPC_ERROR_REF(error));
 }
 
 grpc_transport_stream_op_batch* grpc_make_transport_stream_op(
     grpc_closure* on_complete) {
-  made_transport_stream_op* op =
-      static_cast<made_transport_stream_op*>(gpr_zalloc(sizeof(*op)));
+  made_transport_stream_op* op = new made_transport_stream_op();
   op->op.payload = &op->payload;
   GRPC_CLOSURE_INIT(&op->outer_on_complete, destroy_made_transport_stream_op,
                     op, grpc_schedule_on_exec_ctx);

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

@@ -59,7 +59,6 @@ typedef struct grpc_stream_refcount {
 #ifndef NDEBUG
   const char* object_type;
 #endif
-  grpc_slice_refcount slice_refcount;
 } grpc_stream_refcount;
 
 #ifndef NDEBUG

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

@@ -18,8 +18,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/channel/channel_stack.h"
-
 #include <inttypes.h>
 #include <stdarg.h>
 #include <stdio.h>
@@ -33,6 +31,8 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
+
+#include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/transport/connectivity_state.h"
@@ -40,27 +40,47 @@
 /* These routines are here to facilitate debugging - they produce string
    representations of various transport data structures */
 
-static void put_metadata(grpc_mdelem md, std::vector<std::string>* out) {
-  out->push_back("key=");
-  char* dump = grpc_dump_slice(GRPC_MDKEY(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);
-  out->push_back(dump);
-  gpr_free(dump);
-  out->push_back(" value=");
-  dump = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);
-  out->push_back(dump);
-  gpr_free(dump);
-}
+namespace {
+class MetadataListEncoder {
+ public:
+  explicit MetadataListEncoder(std::vector<std::string>* out) : out_(out) {}
+  void Encode(const grpc_mdelem& md) {
+    MaybeAddComma();
+    out_->push_back("key=");
+    char* dump = grpc_dump_slice(GRPC_MDKEY(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    out_->push_back(dump);
+    gpr_free(dump);
+    out_->push_back(" value=");
+    dump = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    out_->push_back(dump);
+    gpr_free(dump);
+  }
 
-static void put_metadata_list(grpc_metadata_batch md,
-                              std::vector<std::string>* out) {
-  grpc_linked_mdelem* m;
-  for (m = md.list.head; m != nullptr; m = m->next) {
-    if (m != md.list.head) out->push_back(", ");
-    put_metadata(m->md, out);
+  void Encode(grpc_core::GrpcTimeoutMetadata, grpc_millis deadline) {
+    MaybeAddComma();
+    out_->push_back(absl::StrFormat("deadline=%" PRId64, deadline));
+  }
+
+  template <typename Which>
+  void Encode(Which, const typename Which::ValueType& value) {
+    MaybeAddComma();
+    out_->push_back(
+        absl::StrCat(Which::key(), "=", Which::DisplayValue(value)));
   }
-  if (md.deadline != GRPC_MILLIS_INF_FUTURE) {
-    out->push_back(absl::StrFormat(" deadline=%" PRId64, md.deadline));
+
+ private:
+  void MaybeAddComma() {
+    if (out_->size() != initial_size_) out_->push_back(", ");
   }
+  std::vector<std::string>* const out_;
+  const size_t initial_size_ = out_->size();
+};
+}  // namespace
+
+static void put_metadata_list(const grpc_metadata_batch& md,
+                              std::vector<std::string>* out) {
+  MetadataListEncoder encoder(out);
+  md.Encode(&encoder);
 }
 
 std::string grpc_transport_stream_op_batch_string(

data/src/core/lib/uri/uri_parser.cc

@@ -34,11 +34,29 @@
 #include "src/core/lib/gpr/string.h"
 
 namespace grpc_core {
+
 namespace {
+// Checks if this string is made up of pchars, '/', '?', and '%' exclusively.
+// See https://tools.ietf.org/html/rfc3986#section-3.4
+bool IsPCharString(absl::string_view str) {
+  return (str.find_first_not_of("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                "abcdefghijklmnopqrstuvwxyz"
+                                "0123456789"
+                                "?/:@\\-._~!$&'()*+,;=%") ==
+          absl::string_view::npos);
+}
+
+absl::Status MakeInvalidURIStatus(absl::string_view part_name,
+                                  absl::string_view uri,
+                                  absl::string_view extra) {
+  return absl::InvalidArgumentError(absl::StrFormat(
+      "Could not parse '%s' from uri '%s'. %s", part_name, uri, extra));
+}
+}  // namespace
 
 // Similar to `grpc_permissive_percent_decode_slice`, this %-decodes all valid
 // triplets, and passes through the rest verbatim.
-std::string PercentDecode(absl::string_view str) {
+std::string URI::PercentDecode(absl::string_view str) {
   if (str.empty() || !absl::StrContains(str, "%")) {
     return std::string(str);
   }
@@ -64,24 +82,6 @@ std::string PercentDecode(absl::string_view str) {
   return out;
 }
 
-// Checks if this string is made up of pchars, '/', '?', and '%' exclusively.
-// See https://tools.ietf.org/html/rfc3986#section-3.4
-bool IsPCharString(absl::string_view str) {
-  return (str.find_first_not_of("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                "abcdefghijklmnopqrstuvwxyz"
-                                "0123456789"
-                                "?/:@\\-._~!$&'()*+,;=%") ==
-          absl::string_view::npos);
-}
-
-absl::Status MakeInvalidURIStatus(absl::string_view part_name,
-                                  absl::string_view uri,
-                                  absl::string_view extra) {
-  return absl::InvalidArgumentError(absl::StrFormat(
-      "Could not parse '%s' from uri '%s'. %s", part_name, uri, extra));
-}
-}  // namespace
-
 absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
   absl::StatusOr<std::string> decoded;
   absl::string_view remaining = uri_text;

data/src/core/lib/uri/uri_parser.h

@@ -56,6 +56,8 @@ class URI {
   URI(URI&&) = default;
   URI& operator=(URI&&) = default;
 
+  static std::string PercentDecode(absl::string_view str);
+
   const std::string& scheme() const { return scheme_; }
   const std::string& authority() const { return authority_; }
   const std::string& path() const { return path_; }

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -20,12 +20,11 @@
 
 #include <grpc/grpc.h>
 
-void grpc_http_filters_init(void);
-void grpc_http_filters_shutdown(void);
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/surface/builtins.h"
+
 void grpc_chttp2_plugin_init(void);
 void grpc_chttp2_plugin_shutdown(void);
-void grpc_deadline_filter_init(void);
-void grpc_deadline_filter_shutdown(void);
 void grpc_client_channel_init(void);
 void grpc_client_channel_shutdown(void);
 void grpc_inproc_plugin_init(void);
@@ -48,23 +47,19 @@ void grpc_resolver_dns_native_init(void);
 void grpc_resolver_dns_native_shutdown(void);
 void grpc_resolver_sockaddr_init(void);
 void grpc_resolver_sockaddr_shutdown(void);
-void grpc_client_idle_filter_init(void);
-void grpc_client_idle_filter_shutdown(void);
-void grpc_max_age_filter_init(void);
-void grpc_max_age_filter_shutdown(void);
 void grpc_message_size_filter_init(void);
 void grpc_message_size_filter_shutdown(void);
-void grpc_service_config_channel_arg_filter_init(void);
-void grpc_service_config_channel_arg_filter_shutdown(void);
-void grpc_client_authority_filter_init(void);
-void grpc_client_authority_filter_shutdown(void);
-void grpc_workaround_cronet_compression_filter_init(void);
-void grpc_workaround_cronet_compression_filter_shutdown(void);
 namespace grpc_core {
 void FaultInjectionFilterInit(void);
 void FaultInjectionFilterShutdown(void);
 void GrpcLbPolicyRingHashInit(void);
 void GrpcLbPolicyRingHashShutdown(void);
+#ifndef GRPC_NO_RLS
+void RlsLbPluginInit();
+void RlsLbPluginShutdown();
+#endif  // !GRPC_NO_RLS
+void ServiceConfigParserInit(void);
+void ServiceConfigParserShutdown(void);
 }  // namespace grpc_core
 
 #ifndef GRPC_NO_XDS
@@ -91,24 +86,27 @@ void grpc_resolver_xds_shutdown(void);
 namespace grpc_core {
 void GoogleCloud2ProdResolverInit();
 void GoogleCloud2ProdResolverShutdown();
-}
+}  // namespace grpc_core
+#endif
+
+#ifdef GPR_SUPPORT_BINDER_TRANSPORT
+void grpc_resolver_binder_init(void);
+void grpc_resolver_binder_shutdown(void);
 #endif
 
 void grpc_register_built_in_plugins(void) {
-  grpc_register_plugin(grpc_http_filters_init,
-                       grpc_http_filters_shutdown);
-  grpc_register_plugin(grpc_chttp2_plugin_init,
-                       grpc_chttp2_plugin_shutdown);
-  grpc_register_plugin(grpc_deadline_filter_init,
-                       grpc_deadline_filter_shutdown);
-  grpc_register_plugin(grpc_client_channel_init,
-                       grpc_client_channel_shutdown);
-  grpc_register_plugin(grpc_inproc_plugin_init,
-                       grpc_inproc_plugin_shutdown);
-  grpc_register_plugin(grpc_resolver_fake_init,
-                       grpc_resolver_fake_shutdown);
+  grpc_register_plugin(grpc_chttp2_plugin_init, grpc_chttp2_plugin_shutdown);
+  grpc_register_plugin(grpc_core::ServiceConfigParserInit,
+                       grpc_core::ServiceConfigParserShutdown);
+  grpc_register_plugin(grpc_client_channel_init, grpc_client_channel_shutdown);
+  grpc_register_plugin(grpc_inproc_plugin_init, grpc_inproc_plugin_shutdown);
+  grpc_register_plugin(grpc_resolver_fake_init, grpc_resolver_fake_shutdown);
   grpc_register_plugin(grpc_lb_policy_grpclb_init,
                        grpc_lb_policy_grpclb_shutdown);
+#ifndef GRPC_NO_RLS
+  grpc_register_plugin(grpc_core::RlsLbPluginInit,
+                       grpc_core::RlsLbPluginShutdown);
+#endif  // !GRPC_NO_RLS
   grpc_register_plugin(grpc_lb_policy_priority_init,
                        grpc_lb_policy_priority_shutdown);
   grpc_register_plugin(grpc_lb_policy_weighted_target_init,
@@ -125,20 +123,10 @@ void grpc_register_built_in_plugins(void) {
                        grpc_resolver_dns_native_shutdown);
   grpc_register_plugin(grpc_resolver_sockaddr_init,
                        grpc_resolver_sockaddr_shutdown);
-  grpc_register_plugin(grpc_client_idle_filter_init,
-                       grpc_client_idle_filter_shutdown);
-  grpc_register_plugin(grpc_max_age_filter_init,
-                       grpc_max_age_filter_shutdown);
   grpc_register_plugin(grpc_message_size_filter_init,
                        grpc_message_size_filter_shutdown);
   grpc_register_plugin(grpc_core::FaultInjectionFilterInit,
                        grpc_core::FaultInjectionFilterShutdown);
-  grpc_register_plugin(grpc_service_config_channel_arg_filter_init,
-                       grpc_service_config_channel_arg_filter_shutdown);
-  grpc_register_plugin(grpc_client_authority_filter_init,
-                       grpc_client_authority_filter_shutdown);
-  grpc_register_plugin(grpc_workaround_cronet_compression_filter_init,
-                       grpc_workaround_cronet_compression_filter_shutdown);
 #ifndef GRPC_NO_XDS
   grpc_register_plugin(grpc_core::XdsClientGlobalInit,
                        grpc_core::XdsClientGlobalShutdown);
@@ -146,17 +134,66 @@ void grpc_register_built_in_plugins(void) {
                        grpc_certificate_provider_registry_shutdown);
   grpc_register_plugin(grpc_core::FileWatcherCertificateProviderInit,
                        grpc_core::FileWatcherCertificateProviderShutdown);
-  grpc_register_plugin(grpc_lb_policy_cds_init,
-                       grpc_lb_policy_cds_shutdown);
+  grpc_register_plugin(grpc_lb_policy_cds_init, grpc_lb_policy_cds_shutdown);
   grpc_register_plugin(grpc_lb_policy_xds_cluster_impl_init,
                        grpc_lb_policy_xds_cluster_impl_shutdown);
   grpc_register_plugin(grpc_lb_policy_xds_cluster_resolver_init,
                        grpc_lb_policy_xds_cluster_resolver_shutdown);
   grpc_register_plugin(grpc_lb_policy_xds_cluster_manager_init,
                        grpc_lb_policy_xds_cluster_manager_shutdown);
-  grpc_register_plugin(grpc_resolver_xds_init,
-                       grpc_resolver_xds_shutdown);
+  grpc_register_plugin(grpc_resolver_xds_init, grpc_resolver_xds_shutdown);
   grpc_register_plugin(grpc_core::GoogleCloud2ProdResolverInit,
                        grpc_core::GoogleCloud2ProdResolverShutdown);
 #endif
+
+#ifdef GPR_SUPPORT_BINDER_TRANSPORT
+  grpc_register_plugin(grpc_resolver_binder_init,
+                       grpc_resolver_binder_shutdown);
+#endif
+}
+
+namespace grpc_core {
+
+extern void BuildClientChannelConfiguration(
+    CoreConfiguration::Builder* builder);
+extern void SecurityRegisterHandshakerFactories(
+    CoreConfiguration::Builder* builder);
+extern void RegisterClientAuthorityFilter(CoreConfiguration::Builder* builder);
+extern void RegisterClientIdleFilter(CoreConfiguration::Builder* builder);
+extern void RegisterDeadlineFilter(CoreConfiguration::Builder* builder);
+extern void RegisterGrpcLbLoadReportingFilter(
+    CoreConfiguration::Builder* builder);
+extern void RegisterHttpFilters(CoreConfiguration::Builder* builder);
+extern void RegisterMaxAgeFilter(CoreConfiguration::Builder* builder);
+extern void RegisterMessageSizeFilter(CoreConfiguration::Builder* builder);
+extern void RegisterSecurityFilters(CoreConfiguration::Builder* builder);
+extern void RegisterServiceConfigChannelArgFilter(
+    CoreConfiguration::Builder* builder);
+extern void RegisterResourceQuota(CoreConfiguration::Builder* builder);
+#ifndef GRPC_NO_XDS
+extern void RegisterXdsChannelStackModifier(
+    CoreConfiguration::Builder* builder);
+#endif
+
+void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
+  BuildClientChannelConfiguration(builder);
+  SecurityRegisterHandshakerFactories(builder);
+  RegisterClientAuthorityFilter(builder);
+  RegisterClientIdleFilter(builder);
+  RegisterGrpcLbLoadReportingFilter(builder);
+  RegisterHttpFilters(builder);
+  RegisterMaxAgeFilter(builder);
+  RegisterDeadlineFilter(builder);
+  RegisterMessageSizeFilter(builder);
+  RegisterServiceConfigChannelArgFilter(builder);
+  RegisterResourceQuota(builder);
+#ifndef GRPC_NO_XDS
+  RegisterXdsChannelStackModifier(builder);
+#endif
+  // Run last so it gets a consistent location.
+  // TODO(ctiller): Is this actually necessary?
+  RegisterSecurityFilters(builder);
+  RegisterBuiltins(builder);
 }
+
+}  // namespace grpc_core

data/src/core/tsi/alts/crypt/aes_gcm.cc

@@ -18,17 +18,18 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/tsi/alts/crypt/gsec.h"
+#include <string.h>
 
 #include <openssl/bio.h>
 #include <openssl/buffer.h>
 #include <openssl/err.h>
 #include <openssl/evp.h>
 #include <openssl/hmac.h>
-#include <string.h>
 
 #include <grpc/support/alloc.h>
 
+#include "src/core/tsi/alts/crypt/gsec.h"
+
 constexpr size_t kKdfKeyLen = 32;
 constexpr size_t kKdfCounterLen = 6;
 constexpr size_t kKdfCounterOffset = 2;
@@ -558,7 +559,9 @@ static grpc_status_code gsec_aes_gcm_aead_crypter_decrypt_iovec(
   if (!EVP_DecryptFinal_ex(aes_gcm_crypter->ctx, nullptr,
                            &bytes_written_temp)) {
     aes_gcm_format_errors("Checking tag failed.", error_details);
-    memset(plaintext_vec.iov_base, 0x00, plaintext_vec.iov_len);
+    if (plaintext_vec.iov_base != nullptr) {
+      memset(plaintext_vec.iov_base, 0x00, plaintext_vec.iov_len);
+    }
     return GRPC_STATUS_FAILED_PRECONDITION;
   }
   if (bytes_written_temp != 0) {

data/src/core/tsi/alts/crypt/gsec.h

@@ -21,16 +21,15 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/event_engine/port.h>
-
 #include <assert.h>
 #include <stdint.h>
 #include <stdlib.h>
 
+#include <grpc/event_engine/port.h>
 #include <grpc/grpc.h>
 
 #ifndef _STRUCT_IOVEC
-#ifndef GRPC_EVENT_ENGINE_POSIX
+#if !defined(GRPC_EVENT_ENGINE_POSIX)
 struct iovec {
   void* iov_base;
   size_t iov_len;

data/src/core/tsi/alts/frame_protector/alts_frame_protector.cc

@@ -23,6 +23,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <algorithm>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
@@ -156,10 +158,10 @@ static tsi_result alts_protect(tsi_frame_protector* self,
    */
   if (impl->in_place_protect_bytes_buffered + impl->overhead_length <
       max_encrypted_payload_bytes(impl)) {
-    size_t bytes_to_buffer = GPR_MIN(*unprotected_bytes_size,
-                                     max_encrypted_payload_bytes(impl) -
-                                         impl->in_place_protect_bytes_buffered -
-                                         impl->overhead_length);
+    size_t bytes_to_buffer = std::min(
+        *unprotected_bytes_size, max_encrypted_payload_bytes(impl) -
+                                     impl->in_place_protect_bytes_buffered -
+                                     impl->overhead_length);
     *unprotected_bytes_size = bytes_to_buffer;
     if (bytes_to_buffer > 0) {
       memcpy(
@@ -266,9 +268,9 @@ static tsi_result alts_unprotect(tsi_frame_protector* self,
   if (!alts_is_frame_reader_done(impl->reader)) {
     ensure_buffer_size(impl);
     *protected_frames_bytes_size =
-        GPR_MIN(impl->max_unprotected_frame_size -
-                    alts_get_output_bytes_read(impl->reader),
-                *protected_frames_bytes_size);
+        std::min(impl->max_unprotected_frame_size -
+                     alts_get_output_bytes_read(impl->reader),
+                 *protected_frames_bytes_size);
     size_t read_frames_bytes_size = *protected_frames_bytes_size;
     if (!alts_read_frame_bytes(impl->reader, protected_frames_bytes,
                                &read_frames_bytes_size)) {
@@ -290,7 +292,7 @@ static tsi_result alts_unprotect(tsi_frame_protector* self,
         return result;
       }
     }
-    size_t bytes_to_write = GPR_MIN(
+    size_t bytes_to_write = std::min(
         *unprotected_bytes_size, alts_get_output_bytes_read(impl->reader) -
                                      impl->in_place_unprotect_bytes_processed -
                                      impl->overhead_length);
@@ -368,8 +370,7 @@ tsi_result alts_create_frame_protector(const uint8_t* key, size_t key_size,
     return TSI_INTERNAL_ERROR;
   }
   char* error_details = nullptr;
-  alts_frame_protector* impl =
-      static_cast<alts_frame_protector*>(gpr_zalloc(sizeof(*impl)));
+  alts_frame_protector* impl = grpc_core::Zalloc<alts_frame_protector>();
   grpc_status_code status = create_alts_crypters(
       key, key_size, is_client, is_rekey, impl, &error_details);
   if (status != GRPC_STATUS_OK) {
@@ -385,9 +386,9 @@ tsi_result alts_create_frame_protector(const uint8_t* key, size_t key_size,
   size_t max_protected_frame_size_to_set = kDefaultFrameLength;
   if (max_protected_frame_size != nullptr) {
     *max_protected_frame_size =
-        GPR_MIN(*max_protected_frame_size, kMaxFrameLength);
+        std::min(*max_protected_frame_size, kMaxFrameLength);
     *max_protected_frame_size =
-        GPR_MAX(*max_protected_frame_size, kMinFrameLength);
+        std::max(*max_protected_frame_size, kMinFrameLength);
     max_protected_frame_size_to_set = *max_protected_frame_size;
   }
   impl->max_protected_frame_size = max_protected_frame_size_to_set;

data/src/core/tsi/alts/frame_protector/frame_handler.cc

@@ -24,10 +24,12 @@
 #include <stdint.h>
 #include <string.h>
 
+#include <algorithm>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/memory.h"
 
 /* Use little endian to interpret a string of bytes as uint32_t. */
 static uint32_t load_32_le(const unsigned char* buffer) {
@@ -47,9 +49,7 @@ static void store_32_le(uint32_t value, unsigned char* buffer) {
 
 /* Frame writer implementation. */
 alts_frame_writer* alts_create_frame_writer() {
-  alts_frame_writer* writer =
-      static_cast<alts_frame_writer*>(gpr_zalloc(sizeof(*writer)));
-  return writer;
+  return grpc_core::Zalloc<alts_frame_writer>();
 }
 
 bool alts_reset_frame_writer(alts_frame_writer* writer,
@@ -82,8 +82,8 @@ bool alts_write_frame_bytes(alts_frame_writer* writer, unsigned char* output,
   /* Write some header bytes, if needed. */
   if (writer->header_bytes_written != sizeof(writer->header_buffer)) {
     size_t bytes_to_write =
-        GPR_MIN(*bytes_size,
-                sizeof(writer->header_buffer) - writer->header_bytes_written);
+        std::min(*bytes_size,
+                 sizeof(writer->header_buffer) - writer->header_bytes_written);
     memcpy(output, writer->header_buffer + writer->header_bytes_written,
            bytes_to_write);
     bytes_written += bytes_to_write;
@@ -97,7 +97,7 @@ bool alts_write_frame_bytes(alts_frame_writer* writer, unsigned char* output,
   }
   /* Write some non-header bytes. */
   size_t bytes_to_write =
-      GPR_MIN(writer->input_size - writer->input_bytes_written, *bytes_size);
+      std::min(writer->input_size - writer->input_bytes_written, *bytes_size);
   memcpy(output, writer->input_buffer, bytes_to_write);
   writer->input_buffer += bytes_to_write;
   bytes_written += bytes_to_write;
@@ -120,8 +120,7 @@ void alts_destroy_frame_writer(alts_frame_writer* writer) { gpr_free(writer); }
 
 /* Frame reader implementation. */
 alts_frame_reader* alts_create_frame_reader() {
-  alts_frame_reader* reader =
-      static_cast<alts_frame_reader*>(gpr_zalloc(sizeof(*reader)));
+  alts_frame_reader* reader = grpc_core::Zalloc<alts_frame_reader>();
   return reader;
 }
 
@@ -167,7 +166,7 @@ bool alts_read_frame_bytes(alts_frame_reader* reader,
   size_t bytes_processed = 0;
   /* Process the header, if needed. */
   if (reader->header_bytes_read != sizeof(reader->header_buffer)) {
-    size_t bytes_to_write = GPR_MIN(
+    size_t bytes_to_write = std::min(
         *bytes_size, sizeof(reader->header_buffer) - reader->header_bytes_read);
     memcpy(reader->header_buffer + reader->header_bytes_read, bytes,
            bytes_to_write);
@@ -199,7 +198,7 @@ bool alts_read_frame_bytes(alts_frame_reader* reader,
     reader->bytes_remaining = frame_length - kFrameMessageTypeFieldSize;
   }
   /* Process the non-header bytes. */
-  size_t bytes_to_write = GPR_MIN(*bytes_size, reader->bytes_remaining);
+  size_t bytes_to_write = std::min(*bytes_size, reader->bytes_remaining);
   memcpy(reader->output_buffer, bytes, bytes_to_write);
   reader->output_buffer += bytes_to_write;
   bytes_processed += bytes_to_write;

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

@@ -18,10 +18,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <list>
-
 #include "src/core/tsi/alts/handshaker/alts_handshaker_client.h"
 
+#include <list>
+
 #include "upb/upb.hpp"
 
 #include <grpc/byte_buffer.h>
@@ -178,8 +178,7 @@ static void handle_response_done(alts_grpc_handshaker_client* client,
                                  const unsigned char* bytes_to_send,
                                  size_t bytes_to_send_size,
                                  tsi_handshaker_result* result) {
-  recv_message_result* p =
-      static_cast<recv_message_result*>(gpr_zalloc(sizeof(*p)));
+  recv_message_result* p = grpc_core::Zalloc<recv_message_result>();
   p->status = status;
   p->bytes_to_send = bytes_to_send;
   p->bytes_to_send_size = bytes_to_send_size;
@@ -850,7 +849,7 @@ void alts_handshaker_client_on_status_received_for_testing(
       reinterpret_cast<alts_grpc_handshaker_client*>(c);
   client->handshake_status_code = status;
   client->handshake_status_details = grpc_empty_slice();
-  grpc_core::Closure::Run(DEBUG_LOCATION, &client->on_status_received, error);
+  Closure::Run(DEBUG_LOCATION, &client->on_status_received, error);
 }
 
 }  // namespace internal

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

@@ -25,11 +25,10 @@
 #include <grpc/byte_buffer_reader.h>
 #include <grpc/grpc.h>
 
-#include "src/core/tsi/alts/handshaker/alts_tsi_handshaker.h"
-#include "src/core/tsi/transport_security_interface.h"
-
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/tsi/alts/handshaker/alts_tsi_handshaker.h"
+#include "src/core/tsi/transport_security_interface.h"
 
 #define ALTS_SERVICE_METHOD "/grpc.gcp.HandshakerService/DoHandshake"
 #define ALTS_APPLICATION_PROTOCOL "grpc"