grpc 1.75.0.pre1 → 1.76.0.pre1

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

@@ -29,7 +29,6 @@
 #include <stdlib.h>
 #include <string.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"
@@ -39,6 +38,7 @@
 #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/env.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/memory.h"
 #include "src/core/util/sync.h"
 #include "upb/mem/arena.hpp"
@@ -94,6 +94,7 @@ typedef struct alts_tsi_handshaker_result {
   grpc_slice serialized_context;
   // Peer's maximum frame size.
   size_t max_frame_size;
+  std::string record_protocol;
   std::optional<std::string> negotiated_transport_protocol;
 } alts_tsi_handshaker_result;
 
@@ -116,7 +117,7 @@ static tsi_result handshaker_result_extract_peer(
     LOG(ERROR) << "Failed to construct tsi peer";
     return ok;
   }
-  CHECK_NE(&peer->properties[index], nullptr);
+  GRPC_CHECK_NE(&peer->properties[index], nullptr);
   ok = tsi_construct_string_peer_property_from_cstring(
       TSI_CERTIFICATE_TYPE_PEER_PROPERTY, TSI_ALTS_CERTIFICATE_TYPE,
       &peer->properties[index]);
@@ -126,7 +127,7 @@ static tsi_result handshaker_result_extract_peer(
     return ok;
   }
   index++;
-  CHECK_NE(&peer->properties[index], nullptr);
+  GRPC_CHECK_NE(&peer->properties[index], nullptr);
   ok = tsi_construct_string_peer_property_from_cstring(
       TSI_ALTS_SERVICE_ACCOUNT_PEER_PROPERTY, result->peer_identity,
       &peer->properties[index]);
@@ -135,7 +136,7 @@ static tsi_result handshaker_result_extract_peer(
     LOG(ERROR) << "Failed to set tsi peer property";
   }
   index++;
-  CHECK_NE(&peer->properties[index], nullptr);
+  GRPC_CHECK_NE(&peer->properties[index], nullptr);
   ok = tsi_construct_string_peer_property(
       TSI_ALTS_RPC_VERSIONS,
       reinterpret_cast<char*>(GRPC_SLICE_START_PTR(result->rpc_versions)),
@@ -145,7 +146,7 @@ static tsi_result handshaker_result_extract_peer(
     LOG(ERROR) << "Failed to set tsi peer property";
   }
   index++;
-  CHECK_NE(&peer->properties[index], nullptr);
+  GRPC_CHECK_NE(&peer->properties[index], nullptr);
   ok = tsi_construct_string_peer_property(
       TSI_ALTS_CONTEXT,
       reinterpret_cast<char*>(GRPC_SLICE_START_PTR(result->serialized_context)),
@@ -155,18 +156,21 @@ static tsi_result handshaker_result_extract_peer(
     LOG(ERROR) << "Failed to set tsi peer property";
   }
   index++;
-  CHECK_NE(&peer->properties[index], nullptr);
+  GRPC_CHECK_NE(&peer->properties[index], nullptr);
+  tsi_security_level security_level =
+      result->record_protocol == ALTS_INTEGRITY_ONLY_RECORD_PROTOCOL
+          ? TSI_INTEGRITY_ONLY
+          : TSI_PRIVACY_AND_INTEGRITY;
   ok = tsi_construct_string_peer_property_from_cstring(
       TSI_SECURITY_LEVEL_PEER_PROPERTY,
-      tsi_security_level_to_string(TSI_PRIVACY_AND_INTEGRITY),
-      &peer->properties[index]);
+      tsi_security_level_to_string(security_level), &peer->properties[index]);
   if (ok != TSI_OK) {
     tsi_peer_destruct(peer);
     LOG(ERROR) << "Failed to set tsi peer property";
   }
   if (result->negotiated_transport_protocol.has_value()) {
     index++;
-    CHECK_NE(&peer->properties[index], nullptr);
+    GRPC_CHECK_NE(&peer->properties[index], nullptr);
     ok = tsi_construct_string_peer_property_from_cstring(
         TSI_ALTS_NEGOTIATED_TRANSPORT_PROTOCOL,
         result->negotiated_transport_protocol.value().c_str(),
@@ -176,7 +180,7 @@ static tsi_result handshaker_result_extract_peer(
       LOG(ERROR) << "Failed to set tsi peer property";
     }
   }
-  CHECK(++index == peer_properties_count);
+  GRPC_CHECK(++index == peer_properties_count);
   return ok;
 }
 
@@ -221,8 +225,9 @@ static tsi_result handshaker_result_create_zero_copy_grpc_protector(
                                  kAltsAes128GcmRekeyKeyLength},
                                 /*is_rekey=*/true),
       result->is_client,
-      /*is_integrity_only=*/false, /*enable_extra_copy=*/false,
-      max_output_protected_frame_size, protector);
+      /*is_integrity_only=*/
+      (result->record_protocol == ALTS_INTEGRITY_ONLY_RECORD_PROTOCOL),
+      /*enable_extra_copy=*/false, max_output_protected_frame_size, protector);
   if (ok != TSI_OK) {
     LOG(ERROR) << "Failed to create zero-copy grpc protector";
   }
@@ -277,7 +282,7 @@ static void handshaker_result_destroy(tsi_handshaker_result* self) {
   gpr_free(result->unused_bytes);
   grpc_core::CSliceUnref(result->rpc_versions);
   grpc_core::CSliceUnref(result->serialized_context);
-  gpr_free(result);
+  delete result;
 }
 
 static const tsi_handshaker_result_vtable result_vtable = {
@@ -342,9 +347,7 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
       grpc_gcp_Identity_service_account(local_identity);
   // We don't check if local service account is empty here
   // because local identity could be empty in certain situations.
-  alts_tsi_handshaker_result* sresult =
-      static_cast<alts_tsi_handshaker_result*>(
-          gpr_zalloc(sizeof(alts_tsi_handshaker_result)));
+  alts_tsi_handshaker_result* sresult = new alts_tsi_handshaker_result();
   sresult->key_data =
       static_cast<char*>(gpr_zalloc(kAltsAes128GcmRekeyKeyLength));
   memcpy(sresult->key_data, key_data.data, kAltsAes128GcmRekeyKeyLength);
@@ -366,6 +369,10 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
           std::string(transport_protocol.data, transport_protocol.size);
     }
   }
+
+  sresult->record_protocol =
+      std::string(record_protocol.data, record_protocol.size);
+
   upb::Arena rpc_versions_arena;
   bool serialized = grpc_gcp_rpc_protocol_versions_encode(
       peer_rpc_version, rpc_versions_arena.ptr(), &sresult->rpc_versions);
@@ -377,9 +384,10 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
   grpc_gcp_AltsContext* context = grpc_gcp_AltsContext_new(context_arena.ptr());
   grpc_gcp_AltsContext_set_application_protocol(context, application_protocol);
   grpc_gcp_AltsContext_set_record_protocol(context, record_protocol);
-  // ALTS currently only supports the security level of 2,
-  // which is "grpc_gcp_INTEGRITY_AND_PRIVACY".
-  grpc_gcp_AltsContext_set_security_level(context, 2);
+  grpc_gcp_AltsContext_set_security_level(
+      context, sresult->record_protocol == ALTS_INTEGRITY_ONLY_RECORD_PROTOCOL
+                   ? TSI_INTEGRITY_ONLY
+                   : TSI_PRIVACY_AND_INTEGRITY);
   grpc_gcp_AltsContext_set_peer_service_account(context, peer_service_account);
   grpc_gcp_AltsContext_set_local_service_account(context,
                                                  local_service_account);
@@ -456,7 +464,7 @@ static tsi_result alts_tsi_handshaker_continue_handshaker_next(
           handshaker->handshaker_service_url);
       handshaker->interested_parties =
           grpc_alts_get_shared_resource_dedicated()->interested_parties;
-      CHECK_NE(handshaker->interested_parties, nullptr);
+      GRPC_CHECK_NE(handshaker->interested_parties, nullptr);
     }
     grpc_iomgr_cb_func grpc_cb = handshaker->channel == nullptr
                                      ? on_handshaker_service_resp_recv_dedicated
@@ -479,7 +487,7 @@ static tsi_result alts_tsi_handshaker_continue_handshaker_next(
     }
     {
       grpc_core::MutexLock lock(&handshaker->mu);
-      CHECK_EQ(handshaker->client, nullptr);
+      GRPC_CHECK_EQ(handshaker->client, nullptr);
       handshaker->client = client;
       if (handshaker->shutdown) {
         VLOG(2) << "TSI handshake shutdown";
@@ -491,8 +499,8 @@ static tsi_result alts_tsi_handshaker_continue_handshaker_next(
   }
   if (handshaker->channel == nullptr &&
       handshaker->client_vtable_for_testing == nullptr) {
-    CHECK(grpc_cq_begin_op(grpc_alts_get_shared_resource_dedicated()->cq,
-                           handshaker->client));
+    GRPC_CHECK(grpc_cq_begin_op(grpc_alts_get_shared_resource_dedicated()->cq,
+                                handshaker->client));
   }
   grpc_slice slice = (received_bytes == nullptr || received_bytes_size == 0)
                          ? grpc_empty_slice()
@@ -534,7 +542,7 @@ static void alts_tsi_handshaker_create_channel(
   alts_tsi_handshaker_continue_handshaker_next_args* next_args =
       static_cast<alts_tsi_handshaker_continue_handshaker_next_args*>(arg);
   alts_tsi_handshaker* handshaker = next_args->handshaker;
-  CHECK_EQ(handshaker->channel, nullptr);
+  GRPC_CHECK_EQ(handshaker->channel, nullptr);
   grpc_channel_credentials* creds = grpc_insecure_credentials_create();
   // Disable retries so that we quickly get a signal when the
   // handshake server is not reachable.
@@ -643,7 +651,7 @@ static tsi_result handshaker_next_dedicated(
 }
 
 static void handshaker_shutdown(tsi_handshaker* self) {
-  CHECK_NE(self, nullptr);
+  GRPC_CHECK_NE(self, nullptr);
   alts_tsi_handshaker* handshaker =
       reinterpret_cast<alts_tsi_handshaker*>(self);
   grpc_core::MutexLock lock(&handshaker->mu);
@@ -689,7 +697,7 @@ static const tsi_handshaker_vtable handshaker_vtable_dedicated = {
     handshaker_shutdown};
 
 bool alts_tsi_handshaker_has_shutdown(alts_tsi_handshaker* handshaker) {
-  CHECK_NE(handshaker, nullptr);
+  GRPC_CHECK_NE(handshaker, nullptr);
   grpc_core::MutexLock lock(&handshaker->mu);
   return handshaker->shutdown;
 }
@@ -729,8 +737,8 @@ tsi_result alts_tsi_handshaker_create(
 void alts_tsi_handshaker_result_set_unused_bytes(tsi_handshaker_result* result,
                                                  grpc_slice* recv_bytes,
                                                  size_t bytes_consumed) {
-  CHECK(recv_bytes != nullptr);
-  CHECK_NE(result, nullptr);
+  GRPC_CHECK(recv_bytes != nullptr);
+  GRPC_CHECK_NE(result, nullptr);
   if (GRPC_SLICE_LENGTH(*recv_bytes) == bytes_consumed) {
     return;
   }
@@ -749,19 +757,19 @@ namespace internal {
 
 bool alts_tsi_handshaker_get_has_sent_start_message_for_testing(
     alts_tsi_handshaker* handshaker) {
-  CHECK_NE(handshaker, nullptr);
+  GRPC_CHECK_NE(handshaker, nullptr);
   return handshaker->has_sent_start_message;
 }
 
 void alts_tsi_handshaker_set_client_vtable_for_testing(
     alts_tsi_handshaker* handshaker, alts_handshaker_client_vtable* vtable) {
-  CHECK_NE(handshaker, nullptr);
+  GRPC_CHECK_NE(handshaker, nullptr);
   handshaker->client_vtable_for_testing = vtable;
 }
 
 bool alts_tsi_handshaker_get_is_client_for_testing(
     alts_tsi_handshaker* handshaker) {
-  CHECK_NE(handshaker, nullptr);
+  GRPC_CHECK_NE(handshaker, nullptr);
   return handshaker->is_client;
 }
 

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

@@ -21,10 +21,10 @@
 #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"
+#include "src/core/util/grpc_check.h"
 
 tsi_result alts_tsi_utils_convert_to_tsi_result(grpc_status_code code) {
   switch (code) {
@@ -45,8 +45,8 @@ tsi_result alts_tsi_utils_convert_to_tsi_result(grpc_status_code code) {
 
 grpc_gcp_HandshakerResp* alts_tsi_utils_deserialize_response(
     grpc_byte_buffer* resp_buffer, upb_Arena* arena) {
-  CHECK_NE(resp_buffer, nullptr);
-  CHECK_NE(arena, nullptr);
+  GRPC_CHECK_NE(resp_buffer, nullptr);
+  GRPC_CHECK_NE(arena, nullptr);
   grpc_byte_buffer_reader bbr;
   grpc_byte_buffer_reader_init(&bbr, resp_buffer);
   grpc_slice slice = grpc_byte_buffer_reader_readall(&bbr);

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

@@ -22,13 +22,13 @@
 #include <grpc/support/port_platform.h>
 #include <string.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"
 #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"
+#include "src/core/util/grpc_check.h"
 
 // Main struct for alts_grpc_integrity_only_record_protocol.
 typedef struct alts_grpc_integrity_only_record_protocol {
@@ -141,14 +141,14 @@ static tsi_result alts_grpc_integrity_only_unprotect(
   grpc_slice_buffer_reset_and_unref(&rp->header_sb);
   grpc_slice_buffer_move_first(protected_slices, rp->header_length,
                                &rp->header_sb);
-  CHECK(rp->header_sb.length == rp->header_length);
+  GRPC_CHECK(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(&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);
-  CHECK(protected_slices->length == rp->tag_length);
+  GRPC_CHECK(protected_slices->length == rp->tag_length);
   iovec_t tag_iovec = {nullptr, rp->tag_length};
   if (protected_slices->count == 1) {
     tag_iovec.iov_base = GRPC_SLICE_START_PTR(protected_slices->slices[0]);

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

@@ -22,11 +22,11 @@
 #include <grpc/support/port_platform.h>
 #include <string.h>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/useful.h"
 
 const size_t kInitialIovecBufferSize = 8;
@@ -34,8 +34,8 @@ const size_t kInitialIovecBufferSize = 8;
 // Makes sure iovec_buf in alts_grpc_record_protocol is large enough.
 static void ensure_iovec_buf_size(alts_grpc_record_protocol* rp,
                                   const grpc_slice_buffer* sb) {
-  CHECK(rp != nullptr);
-  CHECK_NE(sb, nullptr);
+  GRPC_CHECK(rp != nullptr);
+  GRPC_CHECK_NE(sb, nullptr);
   if (sb->count <= rp->iovec_buf_length) {
     return;
   }
@@ -50,8 +50,8 @@ static void ensure_iovec_buf_size(alts_grpc_record_protocol* rp,
 
 void alts_grpc_record_protocol_convert_slice_buffer_to_iovec(
     alts_grpc_record_protocol* rp, const grpc_slice_buffer* sb) {
-  CHECK(rp != nullptr);
-  CHECK_NE(sb, nullptr);
+  GRPC_CHECK(rp != nullptr);
+  GRPC_CHECK_NE(sb, nullptr);
   ensure_iovec_buf_size(rp, sb);
   for (size_t i = 0; i < sb->count; i++) {
     rp->iovec_buf[i].iov_base = GRPC_SLICE_START_PTR(sb->slices[i]);
@@ -61,8 +61,8 @@ void alts_grpc_record_protocol_convert_slice_buffer_to_iovec(
 
 void alts_grpc_record_protocol_copy_slice_buffer(const grpc_slice_buffer* src,
                                                  unsigned char* dst) {
-  CHECK(src != nullptr);
-  CHECK_NE(dst, nullptr);
+  GRPC_CHECK(src != nullptr);
+  GRPC_CHECK_NE(dst, nullptr);
   for (size_t i = 0; i < src->count; i++) {
     size_t slice_length = GRPC_SLICE_LENGTH(src->slices[i]);
     memcpy(dst, GRPC_SLICE_START_PTR(src->slices[i]), slice_length);

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

@@ -25,7 +25,6 @@
 #include <memory>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/tsi/alts/crypt/gsec.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_integrity_only_record_protocol.h"
@@ -33,6 +32,7 @@
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_iovec_record_protocol.h"
 #include "src/core/tsi/transport_security_grpc.h"
+#include "src/core/util/grpc_check.h"
 
 constexpr size_t kMinFrameLength = 1024;
 constexpr size_t kDefaultFrameLength = 16 * 1024;
@@ -84,7 +84,7 @@ static bool read_frame_size(const grpc_slice_buffer* sb,
       remaining -= slice_length;
     }
   }
-  CHECK_EQ(remaining, 0u);
+  GRPC_CHECK_EQ(remaining, 0u);
   // Gets little-endian frame size.
   uint32_t frame_size = (static_cast<uint32_t>(frame_size_buffer[3]) << 24) |
                         (static_cast<uint32_t>(frame_size_buffer[2]) << 16) |
@@ -300,7 +300,7 @@ tsi_result alts_zero_copy_grpc_protector_create(
       impl->max_unprotected_data_size =
           alts_grpc_record_protocol_max_unprotected_data_size(
               impl->record_protocol, max_protected_frame_size_to_set);
-      CHECK_GT(impl->max_unprotected_data_size, 0u);
+      GRPC_CHECK_GT(impl->max_unprotected_data_size, 0u);
       // Allocates internal slice buffers.
       grpc_slice_buffer_init(&impl->unprotected_staging_sb);
       grpc_slice_buffer_init(&impl->protected_sb);

data/src/core/tsi/fake_transport_security.cc

@@ -23,12 +23,12 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/tsi/transport_security_grpc.h"
 #include "src/core/tsi/transport_security_interface.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/memory.h"
 
 // --- Constants. ---
@@ -124,8 +124,8 @@ static void store32_little_endian(uint32_t value, unsigned char* buf) {
 }
 
 static uint32_t read_frame_size(const grpc_slice_buffer* sb) {
-  CHECK(sb != nullptr);
-  CHECK(sb->length >= TSI_FAKE_FRAME_HEADER_SIZE);
+  GRPC_CHECK(sb != nullptr);
+  GRPC_CHECK(sb->length >= TSI_FAKE_FRAME_HEADER_SIZE);
   uint8_t frame_size_buffer[TSI_FAKE_FRAME_HEADER_SIZE];
   uint8_t* buf = frame_size_buffer;
   // Copies the first 4 bytes to a temporary buffer.
@@ -142,7 +142,7 @@ static uint32_t read_frame_size(const grpc_slice_buffer* sb) {
       remaining -= slice_length;
     }
   }
-  CHECK_EQ(remaining, 0u);
+  GRPC_CHECK_EQ(remaining, 0u);
   return load32_little_endian(frame_size_buffer);
 }
 

data/src/core/tsi/ssl/key_logging/ssl_key_logging.cc

@@ -18,11 +18,11 @@
 
 #include <map>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/sync.h"
 
 using TlsSessionKeyLogger = tsi::TlsSessionKeyLoggerCache::TlsSessionKeyLogger;
@@ -48,8 +48,8 @@ TlsSessionKeyLoggerCache::TlsSessionKeyLogger::TlsSessionKeyLogger(
     grpc_core::RefCountedPtr<TlsSessionKeyLoggerCache> cache)
     : tls_session_key_log_file_path_(std::move(tls_session_key_log_file_path)),
       cache_(std::move(cache)) {
-  CHECK(!tls_session_key_log_file_path_.empty());
-  CHECK(cache_ != nullptr);
+  GRPC_CHECK(!tls_session_key_log_file_path_.empty());
+  GRPC_CHECK(cache_ != nullptr);
   fd_ = fopen(tls_session_key_log_file_path_.c_str(), "a");
   if (fd_ == nullptr) {
     grpc_error_handle error = GRPC_OS_ERROR(errno, "fopen");
@@ -108,7 +108,7 @@ TlsSessionKeyLoggerCache::~TlsSessionKeyLoggerCache() {
 grpc_core::RefCountedPtr<TlsSessionKeyLogger> TlsSessionKeyLoggerCache::Get(
     std::string tls_session_key_log_file_path) {
   gpr_once_init(&g_cache_mutex_init, do_cache_mutex_init);
-  DCHECK_NE(g_tls_session_key_log_cache_mu, nullptr);
+  GRPC_DCHECK_NE(g_tls_session_key_log_cache_mu, nullptr);
   if (tls_session_key_log_file_path.empty()) {
     return nullptr;
   }

data/src/core/tsi/ssl/session_cache/ssl_session_cache.cc

@@ -21,11 +21,11 @@
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/tsi/ssl/session_cache/ssl_session.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/sync.h"
 
 namespace tsi {
@@ -112,7 +112,7 @@ void SslSessionLRUCache::Put(const char* key, SslSessionPtr session) {
   entry_by_key_.emplace(key, node);
   AssertInvariants();
   if (use_order_list_size_ > capacity_) {
-    CHECK(use_order_list_tail_);
+    GRPC_CHECK(use_order_list_tail_);
     node = use_order_list_tail_;
     Remove(node);
     // Order matters, key is destroyed after deleting node.
@@ -143,7 +143,7 @@ void SslSessionLRUCache::Remove(SslSessionLRUCache::Node* node) {
   } else {
     node->next_->prev_ = node->prev_;
   }
-  CHECK_GE(use_order_list_size_, 1u);
+  GRPC_CHECK_GE(use_order_list_size_, 1u);
   use_order_list_size_--;
 }
 
@@ -169,16 +169,16 @@ void SslSessionLRUCache::AssertInvariants() {
   Node* current = use_order_list_head_;
   while (current != nullptr) {
     size++;
-    CHECK(current->prev_ == prev);
+    GRPC_CHECK(current->prev_ == prev);
     auto it = entry_by_key_.find(current->key());
-    CHECK(it != entry_by_key_.end());
-    CHECK(it->second == current);
+    GRPC_CHECK(it != entry_by_key_.end());
+    GRPC_CHECK(it->second == current);
     prev = current;
     current = current->next_;
   }
-  CHECK(prev == use_order_list_tail_);
-  CHECK(size == use_order_list_size_);
-  CHECK(entry_by_key_.size() == use_order_list_size_);
+  GRPC_CHECK(prev == use_order_list_tail_);
+  GRPC_CHECK(size == use_order_list_size_);
+  GRPC_CHECK(entry_by_key_.size() == use_order_list_size_);
 }
 #else
 void SslSessionLRUCache::AssertInvariants() {}

data/src/core/tsi/ssl/session_cache/ssl_session_openssl.cc

@@ -17,9 +17,9 @@
 //
 #include <grpc/support/port_platform.h>
 
-#include "absl/log/check.h"
 #include "src/core/tsi/ssl/session_cache/ssl_session.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 
 #ifndef OPENSSL_IS_BORINGSSL
 
@@ -41,11 +41,11 @@ class OpenSslCachedSession : public SslCachedSession {
  public:
   OpenSslCachedSession(SslSessionPtr session) {
     int size = i2d_SSL_SESSION(session.get(), nullptr);
-    CHECK_GT(size, 0);
+    GRPC_CHECK_GT(size, 0);
     grpc_slice slice = grpc_slice_malloc(size_t(size));
     unsigned char* start = GRPC_SLICE_START_PTR(slice);
     int second_size = i2d_SSL_SESSION(session.get(), &start);
-    CHECK(size == second_size);
+    GRPC_CHECK(size == second_size);
     serialized_session_ = slice;
   }