grpc 1.62.0 → 1.65.1

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

@@ -16,26 +16,28 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol_common.h"
 
 #include <string.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/util/useful.h"
 
 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) {
-  GPR_ASSERT(rp != nullptr && sb != nullptr);
+  CHECK(rp != nullptr);
+  CHECK_NE(sb, nullptr);
   if (sb->count <= rp->iovec_buf_length) {
     return;
   }
@@ -50,7 +52,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) {
-  GPR_ASSERT(rp != nullptr && sb != nullptr);
+  CHECK(rp != nullptr);
+  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]);
@@ -60,7 +63,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) {
-  GPR_ASSERT(src != nullptr && dst != nullptr);
+  CHECK(src != nullptr);
+  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_iovec_record_protocol.cc

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_iovec_record_protocol.h"
 
 #include <stdlib.h>
@@ -25,6 +23,7 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/tsi/alts/frame_protector/alts_counter.h"

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

@@ -19,10 +19,10 @@
 #ifndef GRPC_SRC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_IOVEC_RECORD_PROTOCOL_H
 #define GRPC_SRC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_IOVEC_RECORD_PROTOCOL_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdbool.h>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/tsi/alts/crypt/gsec.h"
 
 constexpr size_t kZeroCopyFrameMessageType = 0x06;

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

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_zero_copy_grpc_protector.h"
 
 #include <string.h>
@@ -25,8 +23,12 @@
 #include <memory>
 #include <utility>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.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"
@@ -85,14 +87,14 @@ static bool read_frame_size(const grpc_slice_buffer* sb,
       remaining -= slice_length;
     }
   }
-  GPR_ASSERT(remaining == 0);
+  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) |
                         (static_cast<uint32_t>(frame_size_buffer[1]) << 8) |
                         static_cast<uint32_t>(frame_size_buffer[0]);
   if (frame_size > kMaxFrameLength) {
-    gpr_log(GPR_ERROR, "Frame size is larger than maximum frame size");
+    LOG(ERROR) << "Frame size is larger than maximum frame size";
     return false;
   }
   // Returns frame size including frame length field.
@@ -123,7 +125,7 @@ static tsi_result create_alts_grpc_record_protocol(
                                             kAesGcmTagLength, &crypter,
                                             &error_details);
   if (status != GRPC_STATUS_OK) {
-    gpr_log(GPR_ERROR, "Failed to create AEAD crypter, %s", error_details);
+    LOG(ERROR) << "Failed to create AEAD crypter, " << error_details;
     gpr_free(error_details);
     return TSI_INTERNAL_ERROR;
   }
@@ -152,7 +154,7 @@ static tsi_result alts_zero_copy_grpc_protector_protect(
     grpc_slice_buffer* protected_slices) {
   if (self == nullptr || unprotected_slices == nullptr ||
       protected_slices == nullptr) {
-    gpr_log(GPR_ERROR, "Invalid nullptr arguments to zero-copy grpc protect.");
+    LOG(ERROR) << "Invalid nullptr arguments to zero-copy grpc protect.";
     return TSI_INVALID_ARGUMENT;
   }
   alts_zero_copy_grpc_protector* protector =
@@ -295,7 +297,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);
-      GPR_ASSERT(impl->max_unprotected_data_size > 0);
+      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/alts/zero_copy_frame_protector/alts_zero_copy_grpc_protector.h

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

data/src/core/tsi/fake_transport_security.cc

@@ -16,21 +16,23 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/tsi/fake_transport_security.h"
 
 #include <stdlib.h>
 #include <string.h>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/memory.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"
 
 // --- Constants. ---
 #define TSI_FAKE_FRAME_HEADER_SIZE 4
@@ -90,7 +92,7 @@ static const char* tsi_fake_handshake_message_strings[] = {
 
 static const char* tsi_fake_handshake_message_to_string(int msg) {
   if (msg < 0 || msg >= TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
-    gpr_log(GPR_ERROR, "Invalid message %d", msg);
+    LOG(ERROR) << "Invalid message " << msg;
     return "UNKNOWN";
   }
   return tsi_fake_handshake_message_strings[msg];
@@ -106,7 +108,7 @@ static tsi_result tsi_fake_handshake_message_from_string(
       return TSI_OK;
     }
   }
-  gpr_log(GPR_ERROR, "Invalid handshake message.");
+  LOG(ERROR) << "Invalid handshake message.";
   if (error != nullptr) *error = "invalid handshake message";
   return TSI_DATA_CORRUPTED;
 }
@@ -125,7 +127,8 @@ static void store32_little_endian(uint32_t value, unsigned char* buf) {
 }
 
 static uint32_t read_frame_size(const grpc_slice_buffer* sb) {
-  GPR_ASSERT(sb != nullptr && sb->length >= TSI_FAKE_FRAME_HEADER_SIZE);
+  CHECK(sb != nullptr);
+  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 +145,7 @@ static uint32_t read_frame_size(const grpc_slice_buffer* sb) {
       remaining -= slice_length;
     }
   }
-  GPR_ASSERT(remaining == 0);
+  CHECK_EQ(remaining, 0u);
   return load32_little_endian(frame_size_buffer);
 }
 
@@ -310,8 +313,8 @@ static tsi_result fake_protector_protect(tsi_frame_protector* self,
     result = tsi_fake_frame_decode(frame_header, &written_in_frame_size, frame,
                                    /*error=*/nullptr);
     if (result != TSI_INCOMPLETE_DATA) {
-      gpr_log(GPR_ERROR, "tsi_fake_frame_decode returned %s",
-              tsi_result_to_string(result));
+      LOG(ERROR) << "tsi_fake_frame_decode returned "
+                 << tsi_result_to_string(result);
       return result;
     }
   }
@@ -467,7 +470,7 @@ static tsi_result fake_zero_copy_grpc_protector_unprotect(
     if (impl->parsed_frame_size == 0) {
       impl->parsed_frame_size = read_frame_size(&impl->protected_sb);
       if (impl->parsed_frame_size <= 4) {
-        gpr_log(GPR_ERROR, "Invalid frame size.");
+        LOG(ERROR) << "Invalid frame size.";
         return TSI_DATA_CORRUPTED;
       }
     }
@@ -637,7 +640,7 @@ static tsi_result fake_handshaker_get_bytes_to_send_to_peer(
     if (next_message_to_send > TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
       next_message_to_send = TSI_FAKE_HANDSHAKE_MESSAGE_MAX;
     }
-    if (GRPC_TRACE_FLAG_ENABLED(tsi_tracing_enabled)) {
+    if (GRPC_TRACE_FLAG_ENABLED(tsi)) {
       gpr_log(GPR_INFO, "%s prepared %s.",
               impl->is_client ? "Client" : "Server",
               tsi_fake_handshake_message_to_string(impl->next_message_to_send));
@@ -650,9 +653,7 @@ static tsi_result fake_handshaker_get_bytes_to_send_to_peer(
   if (!impl->is_client &&
       impl->next_message_to_send == TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
     // We're done.
-    if (GRPC_TRACE_FLAG_ENABLED(tsi_tracing_enabled)) {
-      gpr_log(GPR_INFO, "Server is done.");
-    }
+    GRPC_TRACE_LOG(tsi, INFO) << "Server is done.";
     impl->result = TSI_OK;
   } else {
     impl->needs_incoming_message = 1;
@@ -691,17 +692,15 @@ static tsi_result fake_handshaker_process_bytes_from_peer(
             tsi_fake_handshake_message_to_string(received_msg),
             tsi_fake_handshake_message_to_string(expected_msg));
   }
-  if (GRPC_TRACE_FLAG_ENABLED(tsi_tracing_enabled)) {
-    gpr_log(GPR_INFO, "%s received %s.", impl->is_client ? "Client" : "Server",
-            tsi_fake_handshake_message_to_string(received_msg));
-  }
+  GRPC_TRACE_LOG(tsi, INFO)
+      << (impl->is_client ? "Client" : "Server") << " received "
+      << tsi_fake_handshake_message_to_string(received_msg);
   tsi_fake_frame_reset(&impl->incoming_frame, 0 /* needs_draining */);
   impl->needs_incoming_message = 0;
   if (impl->next_message_to_send == TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
     // We're done.
-    if (GRPC_TRACE_FLAG_ENABLED(tsi_tracing_enabled)) {
-      gpr_log(GPR_INFO, "%s is done.", impl->is_client ? "Client" : "Server");
-    }
+    GRPC_TRACE_LOG(tsi, INFO)
+        << (impl->is_client ? "Client" : "Server") << " is done.";
     impl->result = TSI_OK;
   }
   return TSI_OK;

data/src/core/tsi/local_transport_security.cc

@@ -16,16 +16,16 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/tsi/local_transport_security.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include "absl/log/log.h"
+
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gprpp/crash.h"
@@ -69,7 +69,7 @@ tsi_result handshaker_result_get_unused_bytes(const tsi_handshaker_result* self,
                                               const unsigned char** bytes,
                                               size_t* bytes_size) {
   if (self == nullptr || bytes == nullptr || bytes_size == nullptr) {
-    gpr_log(GPR_ERROR, "Invalid arguments to get_unused_bytes()");
+    LOG(ERROR) << "Invalid arguments to get_unused_bytes()";
     return TSI_INVALID_ARGUMENT;
   }
   auto* result = reinterpret_cast<local_tsi_handshaker_result*>(
@@ -102,7 +102,7 @@ tsi_result create_handshaker_result(const unsigned char* received_bytes,
                                     size_t received_bytes_size,
                                     tsi_handshaker_result** self) {
   if (self == nullptr) {
-    gpr_log(GPR_ERROR, "Invalid arguments to create_handshaker_result()");
+    LOG(ERROR) << "Invalid arguments to create_handshaker_result()";
     return TSI_INVALID_ARGUMENT;
   }
   local_tsi_handshaker_result* result =
@@ -129,7 +129,7 @@ tsi_result handshaker_next(tsi_handshaker* self,
                            tsi_handshaker_on_next_done_cb /*cb*/,
                            void* /*user_data*/, std::string* error) {
   if (self == nullptr) {
-    gpr_log(GPR_ERROR, "Invalid arguments to handshaker_next()");
+    LOG(ERROR) << "Invalid arguments to handshaker_next()";
     if (error != nullptr) *error = "invalid argument";
     return TSI_INVALID_ARGUMENT;
   }
@@ -165,7 +165,7 @@ const tsi_handshaker_vtable handshaker_vtable = {
 
 tsi_result tsi_local_handshaker_create(tsi_handshaker** self) {
   if (self == nullptr) {
-    gpr_log(GPR_ERROR, "Invalid arguments to local_tsi_handshaker_create()");
+    LOG(ERROR) << "Invalid arguments to local_tsi_handshaker_create()";
     return TSI_INVALID_ARGUMENT;
   }
   local_tsi_handshaker* handshaker = grpc_core::Zalloc<local_tsi_handshaker>();

data/src/core/tsi/local_transport_security.h

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

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

@@ -12,13 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/tsi/ssl/key_logging/ssl_key_logging.h"
 
 #include <map>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -48,8 +49,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)) {
-  GPR_ASSERT(!tls_session_key_log_file_path_.empty());
-  GPR_ASSERT(cache_ != nullptr);
+  CHECK(!tls_session_key_log_file_path_.empty());
+  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");
@@ -83,7 +84,7 @@ void TlsSessionKeyLoggerCache::TlsSessionKeyLogger::LogSessionKeys(
   if (fd_ == nullptr || session_keys_info.empty()) return;
   // Append to key log file under lock
   bool err =
-      fwrite((session_keys_info + "\r\n").c_str(), sizeof(char),
+      fwrite((session_keys_info + "\n").c_str(), sizeof(char),
              session_keys_info.length() + 1, fd_) < session_keys_info.length();
 
   if (err) {
@@ -110,7 +111,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);
-  GPR_DEBUG_ASSERT(g_tls_session_key_log_cache_mu != nullptr);
+  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/key_logging/ssl_key_logging.h

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_TSI_SSL_KEY_LOGGING_SSL_KEY_LOGGING_H
 #define GRPC_SRC_CORE_TSI_SSL_KEY_LOGGING_SSL_KEY_LOGGING_H
 
-#include <grpc/support/port_platform.h>
-
 #include <iostream>
 #include <map>
 
@@ -26,6 +24,7 @@
 
 #include <grpc/grpc_security.h>
 #include <grpc/slice.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/gprpp/memory.h"

data/src/core/tsi/ssl/session_cache/ssl_session.h

@@ -19,13 +19,12 @@
 #ifndef GRPC_SRC_CORE_TSI_SSL_SESSION_CACHE_SSL_SESSION_H
 #define GRPC_SRC_CORE_TSI_SSL_SESSION_CACHE_SSL_SESSION_H
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 
 #include <openssl/ssl.h>
 
 #include <grpc/slice.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/ref_counted.h"
 

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

@@ -16,11 +16,13 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/tsi/ssl/session_cache/ssl_session_cache.h"
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
+
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gprpp/crash.h"
@@ -63,9 +65,8 @@ class SslSessionLRUCache::Node {
 
 SslSessionLRUCache::SslSessionLRUCache(size_t capacity) : capacity_(capacity) {
   if (capacity == 0) {
-    gpr_log(
-        GPR_ERROR,
-        "SslSessionLRUCache capacity is zero. SSL sessions cannot be resumed.");
+    LOG(ERROR) << "SslSessionLRUCache capacity is zero. SSL sessions cannot be "
+                  "resumed.";
   }
 }
 
@@ -99,7 +100,7 @@ SslSessionLRUCache::Node* SslSessionLRUCache::FindLocked(
 
 void SslSessionLRUCache::Put(const char* key, SslSessionPtr session) {
   if (session == nullptr) {
-    gpr_log(GPR_ERROR, "Attempted to put null SSL session in session cache.");
+    LOG(ERROR) << "Attempted to put null SSL session in session cache.";
     return;
   }
   grpc_core::MutexLock lock(&lock_);
@@ -113,7 +114,7 @@ void SslSessionLRUCache::Put(const char* key, SslSessionPtr session) {
   entry_by_key_.emplace(key, node);
   AssertInvariants();
   if (use_order_list_size_ > capacity_) {
-    GPR_ASSERT(use_order_list_tail_);
+    CHECK(use_order_list_tail_);
     node = use_order_list_tail_;
     Remove(node);
     // Order matters, key is destroyed after deleting node.
@@ -144,7 +145,7 @@ void SslSessionLRUCache::Remove(SslSessionLRUCache::Node* node) {
   } else {
     node->next_->prev_ = node->prev_;
   }
-  GPR_ASSERT(use_order_list_size_ >= 1);
+  CHECK_GE(use_order_list_size_, 1u);
   use_order_list_size_--;
 }
 
@@ -170,16 +171,16 @@ void SslSessionLRUCache::AssertInvariants() {
   Node* current = use_order_list_head_;
   while (current != nullptr) {
     size++;
-    GPR_ASSERT(current->prev_ == prev);
+    CHECK(current->prev_ == prev);
     auto it = entry_by_key_.find(current->key());
-    GPR_ASSERT(it != entry_by_key_.end());
-    GPR_ASSERT(it->second == current);
+    CHECK(it != entry_by_key_.end());
+    CHECK(it->second == current);
     prev = current;
     current = current->next_;
   }
-  GPR_ASSERT(prev == use_order_list_tail_);
-  GPR_ASSERT(size == use_order_list_size_);
-  GPR_ASSERT(entry_by_key_.size() == use_order_list_size_);
+  CHECK(prev == use_order_list_tail_);
+  CHECK(size == use_order_list_size_);
+  CHECK(entry_by_key_.size() == use_order_list_size_);
 }
 #else
 void SslSessionLRUCache::AssertInvariants() {}

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

@@ -19,14 +19,13 @@
 #ifndef GRPC_SRC_CORE_TSI_SSL_SESSION_CACHE_SSL_SESSION_CACHE_H
 #define GRPC_SRC_CORE_TSI_SSL_SESSION_CACHE_SSL_SESSION_CACHE_H
 
-#include <grpc/support/port_platform.h>
-
 #include <map>
 
 #include <openssl/ssl.h>
 
 #include <grpc/impl/grpc_types.h>
 #include <grpc/slice.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/gprpp/cpp_impl_of.h"

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

@@ -15,11 +15,10 @@
 // limitations under the License.
 //
 //
+#include "absl/log/check.h"
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/log.h>
-
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/tsi/ssl/session_cache/ssl_session.h"
 
@@ -44,11 +43,11 @@ class OpenSslCachedSession : public SslCachedSession {
  public:
   OpenSslCachedSession(SslSessionPtr session) {
     int size = i2d_SSL_SESSION(session.get(), nullptr);
-    GPR_ASSERT(size > 0);
+    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);
-    GPR_ASSERT(size == second_size);
+    CHECK(size == second_size);
     serialized_session_ = slice;
   }