grpc 1.67.0 → 1.69.0.pre1

data/src/core/telemetry/stats_data.h

@@ -17,17 +17,15 @@
 #ifndef GRPC_SRC_CORE_TELEMETRY_STATS_DATA_H
 #define GRPC_SRC_CORE_TELEMETRY_STATS_DATA_H
 
+#include <grpc/support/port_platform.h>
 #include <stdint.h>
 
 #include <atomic>
 #include <memory>
 
 #include "absl/strings/string_view.h"
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gprpp/per_cpu.h"
 #include "src/core/telemetry/histogram_view.h"
+#include "src/core/util/per_cpu.h"
 
 namespace grpc_core {
 class HistogramCollector_100000_20;
@@ -206,6 +204,9 @@ struct GlobalStats {
     kClientSubchannelsCreated,
     kServerChannelsCreated,
     kInsecureConnectionsCreated,
+    kRqConnectionsDropped,
+    kRqCallsDropped,
+    kRqCallsRejected,
     kSyscallWrite,
     kSyscallRead,
     kTcpReadAlloc8k,
@@ -246,6 +247,16 @@ struct GlobalStats {
     kHttp2SendMessageSize,
     kHttp2MetadataSize,
     kHttp2HpackEntryLifetime,
+    kHttp2HeaderTableSize,
+    kHttp2InitialWindowSize,
+    kHttp2MaxConcurrentStreams,
+    kHttp2MaxFrameSize,
+    kHttp2MaxHeaderListSize,
+    kHttp2PreferredReceiveCryptoMessageSize,
+    kHttp2StreamRemoteWindowUpdate,
+    kHttp2TransportRemoteWindowUpdate,
+    kHttp2TransportWindowUpdatePeriod,
+    kHttp2StreamWindowUpdatePeriod,
     kWrrSubchannelListSize,
     kWrrSubchannelReadySize,
     kWorkSerializerRunTimeMs,
@@ -283,6 +294,9 @@ struct GlobalStats {
       uint64_t client_subchannels_created;
       uint64_t server_channels_created;
       uint64_t insecure_connections_created;
+      uint64_t rq_connections_dropped;
+      uint64_t rq_calls_dropped;
+      uint64_t rq_calls_rejected;
       uint64_t syscall_write;
       uint64_t syscall_read;
       uint64_t tcp_read_alloc_8k;
@@ -323,6 +337,16 @@ struct GlobalStats {
   Histogram_16777216_20 http2_send_message_size;
   Histogram_65536_26 http2_metadata_size;
   Histogram_1800000_40 http2_hpack_entry_lifetime;
+  Histogram_16777216_20 http2_header_table_size;
+  Histogram_16777216_20 http2_initial_window_size;
+  Histogram_16777216_20 http2_max_concurrent_streams;
+  Histogram_16777216_20 http2_max_frame_size;
+  Histogram_16777216_20 http2_max_header_list_size;
+  Histogram_16777216_20 http2_preferred_receive_crypto_message_size;
+  Histogram_16777216_20 http2_stream_remote_window_update;
+  Histogram_16777216_20 http2_transport_remote_window_update;
+  Histogram_100000_20 http2_transport_window_update_period;
+  Histogram_100000_20 http2_stream_window_update_period;
   Histogram_10000_20 wrr_subchannel_list_size;
   Histogram_10000_20 wrr_subchannel_ready_size;
   Histogram_100000_20 work_serializer_run_time_ms;
@@ -373,6 +397,16 @@ class GlobalStatsCollector {
     data_.this_cpu().insecure_connections_created.fetch_add(
         1, std::memory_order_relaxed);
   }
+  void IncrementRqConnectionsDropped() {
+    data_.this_cpu().rq_connections_dropped.fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void IncrementRqCallsDropped() {
+    data_.this_cpu().rq_calls_dropped.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementRqCallsRejected() {
+    data_.this_cpu().rq_calls_rejected.fetch_add(1, std::memory_order_relaxed);
+  }
   void IncrementSyscallWrite() {
     data_.this_cpu().syscall_write.fetch_add(1, std::memory_order_relaxed);
   }
@@ -492,6 +526,37 @@ class GlobalStatsCollector {
   void IncrementHttp2HpackEntryLifetime(int value) {
     data_.this_cpu().http2_hpack_entry_lifetime.Increment(value);
   }
+  void IncrementHttp2HeaderTableSize(int value) {
+    data_.this_cpu().http2_header_table_size.Increment(value);
+  }
+  void IncrementHttp2InitialWindowSize(int value) {
+    data_.this_cpu().http2_initial_window_size.Increment(value);
+  }
+  void IncrementHttp2MaxConcurrentStreams(int value) {
+    data_.this_cpu().http2_max_concurrent_streams.Increment(value);
+  }
+  void IncrementHttp2MaxFrameSize(int value) {
+    data_.this_cpu().http2_max_frame_size.Increment(value);
+  }
+  void IncrementHttp2MaxHeaderListSize(int value) {
+    data_.this_cpu().http2_max_header_list_size.Increment(value);
+  }
+  void IncrementHttp2PreferredReceiveCryptoMessageSize(int value) {
+    data_.this_cpu().http2_preferred_receive_crypto_message_size.Increment(
+        value);
+  }
+  void IncrementHttp2StreamRemoteWindowUpdate(int value) {
+    data_.this_cpu().http2_stream_remote_window_update.Increment(value);
+  }
+  void IncrementHttp2TransportRemoteWindowUpdate(int value) {
+    data_.this_cpu().http2_transport_remote_window_update.Increment(value);
+  }
+  void IncrementHttp2TransportWindowUpdatePeriod(int value) {
+    data_.this_cpu().http2_transport_window_update_period.Increment(value);
+  }
+  void IncrementHttp2StreamWindowUpdatePeriod(int value) {
+    data_.this_cpu().http2_stream_window_update_period.Increment(value);
+  }
   void IncrementWrrSubchannelListSize(int value) {
     data_.this_cpu().wrr_subchannel_list_size.Increment(value);
   }
@@ -562,6 +627,9 @@ class GlobalStatsCollector {
     std::atomic<uint64_t> client_subchannels_created{0};
     std::atomic<uint64_t> server_channels_created{0};
     std::atomic<uint64_t> insecure_connections_created{0};
+    std::atomic<uint64_t> rq_connections_dropped{0};
+    std::atomic<uint64_t> rq_calls_dropped{0};
+    std::atomic<uint64_t> rq_calls_rejected{0};
     std::atomic<uint64_t> syscall_write{0};
     std::atomic<uint64_t> syscall_read{0};
     std::atomic<uint64_t> tcp_read_alloc_8k{0};
@@ -599,6 +667,16 @@ class GlobalStatsCollector {
     HistogramCollector_16777216_20 http2_send_message_size;
     HistogramCollector_65536_26 http2_metadata_size;
     HistogramCollector_1800000_40 http2_hpack_entry_lifetime;
+    HistogramCollector_16777216_20 http2_header_table_size;
+    HistogramCollector_16777216_20 http2_initial_window_size;
+    HistogramCollector_16777216_20 http2_max_concurrent_streams;
+    HistogramCollector_16777216_20 http2_max_frame_size;
+    HistogramCollector_16777216_20 http2_max_header_list_size;
+    HistogramCollector_16777216_20 http2_preferred_receive_crypto_message_size;
+    HistogramCollector_16777216_20 http2_stream_remote_window_update;
+    HistogramCollector_16777216_20 http2_transport_remote_window_update;
+    HistogramCollector_100000_20 http2_transport_window_update_period;
+    HistogramCollector_100000_20 http2_stream_window_update_period;
     HistogramCollector_10000_20 wrr_subchannel_list_size;
     HistogramCollector_10000_20 wrr_subchannel_ready_size;
     HistogramCollector_100000_20 work_serializer_run_time_ms;

data/src/core/telemetry/tcp_tracer.h

@@ -19,6 +19,7 @@
 #ifndef GRPC_SRC_CORE_TELEMETRY_TCP_TRACER_H
 #define GRPC_SRC_CORE_TELEMETRY_TCP_TRACER_H
 
+#include <grpc/support/port_platform.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ -27,8 +28,6 @@
 #include "absl/time/time.h"
 #include "absl/types/optional.h"
 
-#include <grpc/support/port_platform.h>
-
 namespace grpc_core {
 
 // Interface for TCP tracer implementations. Created by CallTracerInterface.

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

@@ -16,21 +16,18 @@
 //
 //
 
-#include <string.h>
-
-#include <memory>
-
+#include <grpc/support/alloc.h>
+#include <grpc/support/port_platform.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 "absl/types/span.h"
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/port_platform.h>
+#include <memory>
 
+#include "absl/types/span.h"
 #include "src/core/tsi/alts/crypt/gsec.h"
 
 constexpr size_t kKdfKeyLen = 32;

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

@@ -18,11 +18,10 @@
 
 #include "src/core/tsi/alts/crypt/gsec.h"
 
-#include <stdio.h>
-#include <string.h>
-
 #include <grpc/support/alloc.h>
 #include <grpc/support/port_platform.h>
+#include <stdio.h>
+#include <string.h>
 
 static const char vtable_error_msg[] =
     "crypter or crypter->vtable has not been initialized properly";

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

@@ -20,6 +20,9 @@
 #define GRPC_SRC_CORE_TSI_ALTS_CRYPT_GSEC_H
 
 #include <assert.h>
+#include <grpc/event_engine/port.h>
+#include <grpc/grpc.h>
+#include <grpc/support/port_platform.h>
 #include <stdint.h>
 #include <stdlib.h>
 
@@ -28,10 +31,6 @@
 
 #include "absl/types/span.h"
 
-#include <grpc/event_engine/port.h>
-#include <grpc/grpc.h>
-#include <grpc/support/port_platform.h>
-
 namespace grpc_core {
 
 // Provides accessors to all information representing a gsec key. Owns all the

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

@@ -18,10 +18,9 @@
 
 #include "src/core/tsi/alts/frame_protector/alts_counter.h"
 
-#include <string.h>
-
 #include <grpc/support/alloc.h>
 #include <grpc/support/port_platform.h>
+#include <string.h>
 
 static void maybe_copy_error_msg(const char* src, char** dst) {
   if (dst != nullptr && src != nullptr) {

data/src/core/tsi/alts/frame_protector/alts_counter.h

@@ -19,11 +19,10 @@
 #ifndef GRPC_SRC_CORE_TSI_ALTS_FRAME_PROTECTOR_ALTS_COUNTER_H
 #define GRPC_SRC_CORE_TSI_ALTS_FRAME_PROTECTOR_ALTS_COUNTER_H
 
-#include <stdbool.h>
-#include <stdlib.h>
-
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
+#include <stdbool.h>
+#include <stdlib.h>
 
 // Main struct for a crypter counter managed within seal/unseal operations.
 typedef struct alts_counter {
@@ -89,7 +88,7 @@ size_t alts_counter_get_size(alts_counter* crypter_counter);
 unsigned char* alts_counter_get_counter(alts_counter* crypter_counter);
 
 ///
-/// This method de-allocates all memory allocated to an alts_coutner instance.
+/// This method de-allocates all memory allocated to an alts_counter instance.
 ///- crypter_counter: an alts_counter instance.
 ///
 void alts_counter_destroy(alts_counter* crypter_counter);

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

@@ -18,10 +18,9 @@
 
 #include "src/core/tsi/alts/frame_protector/alts_crypter.h"
 
-#include <string.h>
-
 #include <grpc/support/alloc.h>
 #include <grpc/support/port_platform.h>
+#include <string.h>
 
 static void maybe_copy_error_msg(const char* src, char** dst) {
   if (dst != nullptr && src != nullptr) {

data/src/core/tsi/alts/frame_protector/alts_crypter.h

@@ -19,11 +19,10 @@
 #ifndef GRPC_SRC_CORE_TSI_ALTS_FRAME_PROTECTOR_ALTS_CRYPTER_H
 #define GRPC_SRC_CORE_TSI_ALTS_FRAME_PROTECTOR_ALTS_CRYPTER_H
 
-#include <stdbool.h>
-#include <string.h>
-
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
+#include <stdbool.h>
+#include <string.h>
 
 #include "src/core/tsi/alts/crypt/gsec.h"
 

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

@@ -18,6 +18,8 @@
 
 #include "src/core/tsi/alts/frame_protector/alts_frame_protector.h"
 
+#include <grpc/support/alloc.h>
+#include <grpc/support/port_platform.h>
 #include <stdio.h>
 #include <stdlib.h>
 
@@ -26,15 +28,11 @@
 
 #include "absl/log/log.h"
 #include "absl/types/span.h"
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gprpp/memory.h"
 #include "src/core/tsi/alts/crypt/gsec.h"
 #include "src/core/tsi/alts/frame_protector/alts_crypter.h"
 #include "src/core/tsi/alts/frame_protector/frame_handler.h"
 #include "src/core/tsi/transport_security.h"
+#include "src/core/util/memory.h"
 
 constexpr size_t kMinFrameLength = 1024;
 constexpr size_t kDefaultFrameLength = 16 * 1024;
@@ -380,6 +378,7 @@ tsi_result alts_create_frame_protector(const uint8_t* key, size_t key_size,
   if (status != GRPC_STATUS_OK) {
     LOG(ERROR) << "Failed to create ALTS crypters, " << error_details;
     gpr_free(error_details);
+    gpr_free(impl);
     return TSI_INTERNAL_ERROR;
   }
   ///

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

@@ -19,9 +19,8 @@
 #ifndef GRPC_SRC_CORE_TSI_ALTS_FRAME_PROTECTOR_ALTS_FRAME_PROTECTOR_H
 #define GRPC_SRC_CORE_TSI_ALTS_FRAME_PROTECTOR_ALTS_FRAME_PROTECTOR_H
 
-#include <stdbool.h>
-
 #include <grpc/support/port_platform.h>
+#include <stdbool.h>
 
 #include "src/core/tsi/transport_security_interface.h"
 

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

@@ -30,7 +30,7 @@ static void maybe_copy_error_msg(const char* src, char** dst) {
   }
 }
 
-// Perform input santity check for a seal operation.
+// Perform input sanity check for a seal operation.
 static grpc_status_code seal_check(alts_crypter* c, const unsigned char* data,
                                    size_t data_allocated_size, size_t data_size,
                                    size_t* output_size, char** error_details) {

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

@@ -30,7 +30,7 @@ static void maybe_copy_error_msg(const char* src, char** dst) {
   }
 }
 
-// Perform input santity check.
+// Perform input sanity check.
 static grpc_status_code unseal_check(alts_crypter* c, const unsigned char* data,
                                      size_t /*data_allocated_size*/,
                                      size_t data_size, size_t* output_size,

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

@@ -18,6 +18,8 @@
 
 #include "src/core/tsi/alts/frame_protector/frame_handler.h"
 
+#include <grpc/support/alloc.h>
+#include <grpc/support/port_platform.h>
 #include <limits.h>
 #include <stdint.h>
 #include <string.h>
@@ -25,12 +27,8 @@
 #include <algorithm>
 
 #include "absl/log/log.h"
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gprpp/crash.h"
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/util/crash.h"
+#include "src/core/util/memory.h"
 
 // Use little endian to interpret a string of bytes as uint32_t.
 static uint32_t load_32_le(const unsigned char* buffer) {

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

@@ -19,11 +19,10 @@
 #ifndef GRPC_SRC_CORE_TSI_ALTS_FRAME_PROTECTOR_FRAME_HANDLER_H
 #define GRPC_SRC_CORE_TSI_ALTS_FRAME_PROTECTOR_FRAME_HANDLER_H
 
+#include <grpc/support/port_platform.h>
 #include <stdbool.h>
 #include <stdlib.h>
 
-#include <grpc/support/port_platform.h>
-
 const size_t kFrameMessageType = 0x06;
 const size_t kFrameLengthFieldSize = 4;
 const size_t kFrameMessageTypeFieldSize = 4;

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

@@ -18,26 +18,25 @@
 
 #include "src/core/tsi/alts/handshaker/alts_handshaker_client.h"
 
+#include <grpc/byte_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/port_platform.h>
+
 #include <list>
 
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/numbers.h"
-#include "upb/mem/arena.hpp"
-
-#include <grpc/byte_buffer.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gprpp/crash.h"
-#include "src/core/lib/gprpp/env.h"
-#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/tsi/alts/handshaker/alts_shared_resource.h"
 #include "src/core/tsi/alts/handshaker/alts_tsi_handshaker_private.h"
 #include "src/core/tsi/alts/handshaker/alts_tsi_utils.h"
+#include "src/core/util/crash.h"
+#include "src/core/util/env.h"
+#include "src/core/util/sync.h"
+#include "upb/mem/arena.hpp"
 
 #define TSI_ALTS_INITIAL_BUFFER_SIZE 256
 
@@ -234,7 +233,7 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
     return;
   }
   if (recv_buffer == nullptr) {
-    LOG(ERROR)
+    VLOG(2)
         << "recv_buffer is nullptr in alts_tsi_handshaker_handle_response()";
     handle_response_done(
         client, TSI_INTERNAL_ERROR,
@@ -930,11 +929,11 @@ void alts_handshaker_client_destroy(alts_handshaker_client* c) {
 }
 
 size_t MaxNumberOfConcurrentHandshakes() {
-  size_t max_concurrent_handshakes = 40;
+  size_t max_concurrent_handshakes = 100;
   absl::optional<std::string> env_var_max_concurrent_handshakes =
       grpc_core::GetEnv(kMaxConcurrentStreamsEnvironmentVariable);
   if (env_var_max_concurrent_handshakes.has_value()) {
-    size_t effective_max_concurrent_handshakes = 40;
+    size_t effective_max_concurrent_handshakes = 100;
     if (absl::SimpleAtoi(*env_var_max_concurrent_handshakes,
                          &effective_max_concurrent_handshakes)) {
       max_concurrent_handshakes = effective_max_concurrent_handshakes;

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

@@ -18,13 +18,12 @@
 
 #include "src/core/tsi/alts/handshaker/alts_shared_resource.h"
 
-#include "absl/log/check.h"
-
 #include <grpc/support/port_platform.h>
 
+#include "absl/log/check.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gprpp/crash.h"
 #include "src/core/tsi/alts/handshaker/alts_handshaker_client.h"
+#include "src/core/util/crash.h"
 
 static alts_shared_resource_dedicated g_alts_resource_dedicated;
 

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

@@ -23,9 +23,9 @@
 #include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 
-#include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/surface/completion_queue.h"
+#include "src/core/util/thd.h"
 
 ///
 /// Main struct containing ALTS shared resources used when

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

@@ -18,14 +18,6 @@
 
 #include "src/core/tsi/alts/handshaker/alts_tsi_handshaker.h"
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "upb/mem/arena.hpp"
-
 #include <grpc/credentials.h>
 #include <grpc/grpc_security.h>
 #include <grpc/support/alloc.h>
@@ -33,9 +25,12 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/thd_id.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
-#include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/gprpp/sync.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/surface/channel.h"
@@ -43,6 +38,9 @@
 #include "src/core/tsi/alts/handshaker/alts_handshaker_client.h"
 #include "src/core/tsi/alts/handshaker/alts_shared_resource.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_zero_copy_grpc_protector.h"
+#include "src/core/util/memory.h"
+#include "src/core/util/sync.h"
+#include "upb/mem/arena.hpp"
 
 // Main struct for ALTS TSI handshaker.
 struct alts_tsi_handshaker {
@@ -484,7 +482,7 @@ static tsi_result alts_tsi_handshaker_continue_handshaker_next(
 
 struct alts_tsi_handshaker_continue_handshaker_next_args {
   alts_tsi_handshaker* handshaker;
-  std::unique_ptr<unsigned char> received_bytes;
+  unsigned char* received_bytes;
   size_t received_bytes_size;
   tsi_handshaker_on_next_done_cb cb;
   void* user_data;
@@ -509,13 +507,13 @@ static void alts_tsi_handshaker_create_channel(
   grpc_channel_credentials_release(creds);
   tsi_result continue_next_result =
       alts_tsi_handshaker_continue_handshaker_next(
-          handshaker, next_args->received_bytes.get(),
-          next_args->received_bytes_size, next_args->cb, next_args->user_data,
-          next_args->error);
+          handshaker, next_args->received_bytes, next_args->received_bytes_size,
+          next_args->cb, next_args->user_data, next_args->error);
   if (continue_next_result != TSI_OK) {
     next_args->cb(continue_next_result, next_args->user_data, nullptr, 0,
                   nullptr);
   }
+  gpr_free(next_args->received_bytes);
   delete next_args;
 }
 
@@ -539,6 +537,10 @@ static tsi_result handshaker_next(
       return TSI_HANDSHAKE_SHUTDOWN;
     }
   }
+
+  if (!handshaker->is_client && received_bytes_size == 0) {
+    return TSI_INCOMPLETE_DATA;
+  }
   if (handshaker->channel == nullptr && !handshaker->use_dedicated_cq) {
     alts_tsi_handshaker_continue_handshaker_next_args* args =
         new alts_tsi_handshaker_continue_handshaker_next_args();
@@ -547,9 +549,9 @@ static tsi_result handshaker_next(
     args->received_bytes_size = received_bytes_size;
     args->error = error;
     if (received_bytes_size > 0) {
-      args->received_bytes = std::unique_ptr<unsigned char>(
-          static_cast<unsigned char*>(gpr_zalloc(received_bytes_size)));
-      memcpy(args->received_bytes.get(), received_bytes, received_bytes_size);
+      args->received_bytes =
+          static_cast<unsigned char*>(gpr_zalloc(received_bytes_size));
+      memcpy(args->received_bytes, received_bytes, received_bytes_size);
     }
     args->cb = cb;
     args->user_data = user_data;

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

@@ -18,12 +18,11 @@
 
 #include "src/core/tsi/alts/handshaker/alts_tsi_utils.h"
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-
 #include <grpc/byte_buffer_reader.h>
 #include <grpc/support/port_platform.h>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 

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

@@ -18,11 +18,11 @@
 
 #include "src/core/tsi/alts/handshaker/transport_security_common_api.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "absl/log/log.h"
 #include "upb/mem/arena.hpp"
 
-#include <grpc/support/port_platform.h>
-
 bool grpc_gcp_rpc_protocol_versions_set_max(
     grpc_gcp_rpc_protocol_versions* versions, uint32_t max_major,
     uint32_t max_minor) {

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

@@ -24,16 +24,16 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/crash.h"
+#include "src/core/util/crash.h"
 #include "src/proto/grpc/gcp/transport_security_common.upb.h"
 
-// C struct coresponding to protobuf message RpcProtocolVersions.Version
+// C struct corresponding to protobuf message RpcProtocolVersions.Version
 typedef struct _grpc_gcp_RpcProtocolVersions_Version {
   uint32_t major;
   uint32_t minor;
 } grpc_gcp_rpc_protocol_versions_version;
 
-// C struct coresponding to protobuf message RpcProtocolVersions
+// C struct corresponding to protobuf message RpcProtocolVersions
 typedef struct _grpc_gcp_RpcProtocolVersions {
   grpc_gcp_rpc_protocol_versions_version max_rpc_version;
   grpc_gcp_rpc_protocol_versions_version min_rpc_version;

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

@@ -18,19 +18,17 @@
 
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_integrity_only_record_protocol.h"
 
+#include <grpc/support/alloc.h>
+#include <grpc/support/port_platform.h>
 #include <string.h>
 
 #include "absl/log/check.h"
 #include "absl/log/log.h"
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gprpp/crash.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"
+#include "src/core/util/crash.h"
 
 // Main struct for alts_grpc_integrity_only_record_protocol.
 typedef struct alts_grpc_integrity_only_record_protocol {

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

@@ -19,9 +19,8 @@
 #ifndef GRPC_SRC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_INTEGRITY_ONLY_RECORD_PROTOCOL_H
 #define GRPC_SRC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_INTEGRITY_ONLY_RECORD_PROTOCOL_H
 
-#include <stdbool.h>
-
 #include <grpc/support/port_platform.h>
+#include <stdbool.h>
 
 #include "src/core/tsi/alts/crypt/gsec.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol.h"