grpc 1.75.0.pre1 → 1.76.0.pre1

data/src/core/ext/transport/chttp2/transport/frame.cc

@@ -21,13 +21,14 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
+#include "src/core/util/memory_usage.h"
 
 // TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
 // framing code
@@ -119,7 +120,7 @@ uint16_t Read2b(const uint8_t* input) {
 }
 
 void Write3b(uint32_t x, uint8_t* output) {
-  CHECK_LT(x, 16777216u);
+  GRPC_CHECK_LT(x, 16777216u);
   output[0] = static_cast<uint8_t>(x >> 16);
   output[1] = static_cast<uint8_t>(x >> 8);
   output[2] = static_cast<uint8_t>(x);
@@ -206,9 +207,11 @@ class SerializeExtraBytesRequired {
 
 class SerializeHeaderAndPayload {
  public:
-  SerializeHeaderAndPayload(size_t extra_bytes, SliceBuffer& out)
+  SerializeHeaderAndPayload(size_t extra_bytes, SliceBuffer& out,
+                            SerializeReturn& serialize_return)
       : out_(out),
-        extra_bytes_(MutableSlice::CreateUninitialized(extra_bytes)) {}
+        extra_bytes_(MutableSlice::CreateUninitialized(extra_bytes)),
+        serialize_return_(serialize_return) {}
 
   void operator()(Http2DataFrame& frame) {
     auto hdr = extra_bytes_.TakeFirst(kFrameHeaderSize);
@@ -219,6 +222,7 @@ class SerializeHeaderAndPayload {
         .Serialize(hdr.begin());
     out_.AppendIndexed(Slice(std::move(hdr)));
     out_.TakeAndAppend(frame.payload);
+    serialize_return_.should_reset_ping_clock = true;
   }
 
   void operator()(Http2HeaderFrame& frame) {
@@ -232,6 +236,7 @@ class SerializeHeaderAndPayload {
         .Serialize(hdr.begin());
     out_.AppendIndexed(Slice(std::move(hdr)));
     out_.TakeAndAppend(frame.payload);
+    serialize_return_.should_reset_ping_clock = true;
   }
 
   void operator()(Http2ContinuationFrame& frame) {
@@ -244,6 +249,7 @@ class SerializeHeaderAndPayload {
         .Serialize(hdr.begin());
     out_.AppendIndexed(Slice(std::move(hdr)));
     out_.TakeAndAppend(frame.payload);
+    serialize_return_.should_reset_ping_clock = true;
   }
 
   void operator()(Http2RstStreamFrame& frame) {
@@ -311,6 +317,7 @@ class SerializeHeaderAndPayload {
     }
     Write31bits(frame.increment, hdr_and_payload.begin() + kFrameHeaderSize);
     out_.AppendIndexed(Slice(std::move(hdr_and_payload)));
+    serialize_return_.should_reset_ping_clock = true;
   }
 
   void operator()(Http2SecurityFrame& frame) {
@@ -329,6 +336,7 @@ class SerializeHeaderAndPayload {
  private:
   SliceBuffer& out_;
   MutableSlice extra_bytes_;
+  SerializeReturn& serialize_return_;
 };
 
 Http2Status StripPadding(const Http2FrameHeader& hdr, SliceBuffer& payload) {
@@ -642,23 +650,26 @@ std::string Http2FrameHeader::ToString() const {
                       ", length=", length, "}");
 }
 
-void Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out) {
+SerializeReturn Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out) {
   size_t buffer_needed = 0;
+  SerializeReturn serialize_return{/*should_reset_ping_clock=*/false};
   for (auto& frame : frames) {
     // Bytes needed for framing
     buffer_needed += kFrameHeaderSize;
     // Bytes needed for frame payload
     buffer_needed += std::visit(SerializeExtraBytesRequired(), frame);
   }
-  SerializeHeaderAndPayload serialize(buffer_needed, out);
+  SerializeHeaderAndPayload serialize(buffer_needed, out, serialize_return);
   for (auto& frame : frames) {
     std::visit(serialize, frame);
   }
+
+  return serialize_return;
 }
 
 http2::ValueOrHttp2Status<Http2Frame> ParseFramePayload(
     const Http2FrameHeader& hdr, SliceBuffer payload) {
-  CHECK(payload.Length() == hdr.length);
+  GRPC_CHECK(payload.Length() == hdr.length);
 
   switch (static_cast<FrameType>(hdr.type)) {
     case FrameType::kData:
@@ -688,9 +699,10 @@ http2::ValueOrHttp2Status<Http2Frame> ParseFramePayload(
   }
 }
 
-http2::Http2ErrorCode Http2ErrorCodeFromRstFrameErrorCode(uint32_t error_code) {
+http2::Http2ErrorCode RstFrameErrorCodeToHttp2ErrorCode(
+    const uint32_t error_code) {
   if (GPR_UNLIKELY(error_code > http2::GetMaxHttp2ErrorCode())) {
-    LOG(ERROR) << "Http2ErrorCodeFromRstFrameErrorCode: Invalid error code "
+    LOG(ERROR) << "RstFrameErrorCodeToHttp2ErrorCode: Invalid error code "
                   "received from RST_STREAM frame: "
                << error_code;
     return http2::Http2ErrorCode::kInternalError;
@@ -698,11 +710,21 @@ http2::Http2ErrorCode Http2ErrorCodeFromRstFrameErrorCode(uint32_t error_code) {
   return static_cast<http2::Http2ErrorCode>(error_code);
 }
 
+uint32_t Http2ErrorCodeToRstFrameErrorCode(
+    const http2::Http2ErrorCode error_code) {
+  DCHECK_LE(static_cast<uint8_t>(error_code), http2::GetMaxHttp2ErrorCode());
+  return static_cast<uint32_t>(error_code);
+}
+
+size_t GetFrameMemoryUsage(const Http2Frame& frame) {
+  return MemoryUsageOf(frame);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // GRPC Header
 
 GrpcMessageHeader ExtractGrpcHeader(SliceBuffer& payload) {
-  CHECK_GE(payload.Length(), kGrpcHeaderSizeInBytes);
+  GRPC_CHECK_GE(payload.Length(), kGrpcHeaderSizeInBytes);
   uint8_t buffer[kGrpcHeaderSizeInBytes];
   payload.CopyFirstNBytesIntoBuffer(kGrpcHeaderSizeInBytes, buffer);
   GrpcMessageHeader header;

data/src/core/ext/transport/chttp2/transport/frame.h

@@ -224,6 +224,10 @@ struct Http2FrameHeader {
 ///////////////////////////////////////////////////////////////////////////////
 // Parsing & serialization
 
+struct SerializeReturn {
+  bool should_reset_ping_clock;
+};
+
 // Given a frame header and a payload, parse the payload into a frame and
 // return it.
 // If this function returns an error, that should be considered a connection
@@ -236,9 +240,13 @@ http2::ValueOrHttp2Status<Http2Frame> ParseFramePayload(
 
 // Serialize frame and append to out, leaves frames in an unknown state (may
 // move things out of frames)
-void Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out);
+SerializeReturn Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out);
 
-http2::Http2ErrorCode Http2ErrorCodeFromRstFrameErrorCode(uint32_t error_code);
+http2::Http2ErrorCode RstFrameErrorCodeToHttp2ErrorCode(uint32_t error_code);
+uint32_t Http2ErrorCodeToRstFrameErrorCode(http2::Http2ErrorCode error_code);
+
+// Returns approximate memory usage of the frame.
+size_t GetFrameMemoryUsage(const Http2Frame& frame);
 
 ///////////////////////////////////////////////////////////////////////////////
 // GRPC Header
@@ -357,12 +365,18 @@ inline constexpr absl::string_view kIncorrectFrameSizeSetting =
     "RFC9113: The initial value is 2^14 (16,384) octets. The value advertised"
     " by an endpoint MUST be between this initial value and the maximum allowed"
     " frame size (2^24)-1 or 16,777,215 octets), inclusive. ";
+inline constexpr absl::string_view kSettingsTimeout =
+    "Settings timeout. The HTTP2 settings frame was not ACKed within the "
+    "timeout. Connection will be closed";
 
 inline constexpr uint32_t kMaxStreamId31Bit = 0x7fffffffu;
 inline constexpr uint32_t kMaxSize31Bit = 0x7fffffffu;
 inline constexpr uint32_t kMinimumFrameSize = 16384;
 inline constexpr uint32_t kMaximumFrameSize = 16777215;
 
+// Default Initial Window Size as per RFC 9113 Section 6.5.2
+inline constexpr uint32_t kHttp2InitialWindowSize = 65535u;
+
 }  // namespace RFC9113
 }  // namespace grpc_core
 

data/src/core/ext/transport/chttp2/transport/frame_data.cc

@@ -22,7 +22,6 @@
 #include <grpc/support/port_platform.h>
 #include <stdlib.h>
 
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
@@ -32,6 +31,7 @@
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/telemetry/stats.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/status_helper.h"
 
 absl::Status grpc_chttp2_data_parser_begin_frame(uint8_t flags,
@@ -63,7 +63,7 @@ void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
 
   hdr = GRPC_SLICE_MALLOC(header_size);
   p = GRPC_SLICE_START_PTR(hdr);
-  CHECK(write_bytes < (1 << 24));
+  GRPC_CHECK(write_bytes < (1 << 24));
   *p++ = static_cast<uint8_t>(write_bytes >> 16);
   *p++ = static_cast<uint8_t>(write_bytes >> 8);
   *p++ = static_cast<uint8_t>(write_bytes);

data/src/core/ext/transport/chttp2/transport/frame_goaway.cc

@@ -24,11 +24,11 @@
 #include <string.h>
 
 #include "absl/base/attributes.h"
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
+#include "src/core/util/grpc_check.h"
 
 void grpc_chttp2_goaway_parser_init(grpc_chttp2_goaway_parser* p) {
   p->debug_data = nullptr;
@@ -134,7 +134,7 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
         memcpy(p->debug_data + p->debug_pos, cur,
                static_cast<size_t>(end - cur));
       }
-      CHECK((size_t)(end - cur) < UINT32_MAX - p->debug_pos);
+      GRPC_CHECK((size_t)(end - cur) < UINT32_MAX - p->debug_pos);
       p->debug_pos += static_cast<uint32_t>(end - cur);
       p->state = GRPC_CHTTP2_GOAWAY_DEBUG;
       if (is_last) {
@@ -161,7 +161,7 @@ void grpc_chttp2_goaway_append(
   grpc_slice header = GRPC_SLICE_MALLOC(9 + 4 + 4);
   uint8_t* p = GRPC_SLICE_START_PTR(header);
   uint32_t frame_length;
-  CHECK(GRPC_SLICE_LENGTH(debug_data) < UINT32_MAX - 4 - 4);
+  GRPC_CHECK(GRPC_SLICE_LENGTH(debug_data) < UINT32_MAX - 4 - 4);
   frame_length = 4 + 4 + static_cast<uint32_t> GRPC_SLICE_LENGTH(debug_data);
 
   ztrace_collector->Append([last_stream_id, error_code, debug_data]() {
@@ -193,7 +193,7 @@ void grpc_chttp2_goaway_append(
   *p++ = static_cast<uint8_t>(error_code >> 16);
   *p++ = static_cast<uint8_t>(error_code >> 8);
   *p++ = static_cast<uint8_t>(error_code);
-  CHECK(p == GRPC_SLICE_END_PTR(header));
+  GRPC_CHECK(p == GRPC_SLICE_END_PTR(header));
   grpc_slice_buffer_add(slice_buffer, header);
   grpc_slice_buffer_add(slice_buffer, debug_data);
 }

data/src/core/ext/transport/chttp2/transport/frame_ping.cc

@@ -26,7 +26,6 @@
 #include <algorithm>
 
 #include "absl/container/flat_hash_map.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
@@ -34,6 +33,7 @@
 #include "src/core/ext/transport/chttp2/transport/ping_abuse_policy.h"
 #include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/util/grpc_check.h"
 
 grpc_slice grpc_chttp2_ping_create(uint8_t ack, uint64_t opaque_8bytes) {
   grpc_slice slice = GRPC_SLICE_MALLOC(9 + 8);
@@ -89,7 +89,7 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
   }
 
   if (p->byte == 8) {
-    CHECK(is_last);
+    GRPC_CHECK(is_last);
     t->http2_ztrace_collector.Append(
         grpc_core::H2PingTrace<true>{p->is_ack != 0, p->opaque_8bytes});
     if (p->is_ack) {

data/src/core/ext/transport/chttp2/transport/frame_rst_stream.cc

@@ -22,7 +22,6 @@
 #include <grpc/support/port_platform.h>
 #include <stddef.h>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/random/distributions.h"
 #include "absl/status/status.h"
@@ -36,6 +35,7 @@
 #include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/status_helper.h"
 
@@ -113,7 +113,7 @@ grpc_error_handle grpc_chttp2_rst_stream_parser_parse(void* parser,
   s->call_tracer_wrapper.RecordIncomingBytes({framing_bytes, 0, 0});
 
   if (p->byte == 4) {
-    CHECK(is_last);
+    GRPC_CHECK(is_last);
     uint32_t reason = ((static_cast<uint32_t>(p->reason_bytes[0])) << 24) |
                       ((static_cast<uint32_t>(p->reason_bytes[1])) << 16) |
                       ((static_cast<uint32_t>(p->reason_bytes[2])) << 8) |

data/src/core/ext/transport/chttp2/transport/frame_window_update.cc

@@ -21,7 +21,6 @@
 #include <grpc/support/port_platform.h>
 #include <stddef.h>
 
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
@@ -31,6 +30,7 @@
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/stream_lists.h"
 #include "src/core/telemetry/stats.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/time.h"
 
 grpc_slice grpc_chttp2_window_update_create(
@@ -43,7 +43,7 @@ grpc_slice grpc_chttp2_window_update_create(
   }
   uint8_t* p = GRPC_SLICE_START_PTR(slice);
 
-  CHECK(window_delta);
+  GRPC_CHECK(window_delta);
 
   *p++ = 0;
   *p++ = 0;
@@ -100,7 +100,7 @@ grpc_error_handle grpc_chttp2_window_update_parser_parse(
       return GRPC_ERROR_CREATE(
           absl::StrCat("invalid window update bytes: ", p->amount));
     }
-    CHECK(is_last);
+    GRPC_CHECK(is_last);
 
     t->http2_ztrace_collector.Append(grpc_core::H2WindowUpdateTrace<true>{
         t->incoming_stream_id, received_update});

data/src/core/ext/transport/chttp2/transport/header_assembler.h

@@ -24,7 +24,6 @@
 #include <cstddef>
 #include <cstdint>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
@@ -33,6 +32,7 @@
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/shared_bit_gen.h"
 
 // TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
@@ -88,7 +88,7 @@ class HeaderAssembler {
   // The payload of the Http2HeaderFrame will be cleared in this function.
   Http2Status AppendHeaderFrame(Http2HeaderFrame&& frame) {
     // Validate input frame
-    DCHECK_GT(frame.stream_id, 0u)
+    GRPC_DCHECK_GT(frame.stream_id, 0u)
         << "RFC9113 : HEADERS frames MUST be associated with a stream.";
 
     // Manage size constraints
@@ -145,7 +145,7 @@ class HeaderAssembler {
     ASSEMBLER_LOG << "ReadMetadata " << buffer_.Length() << " Bytes.";
 
     // Validate
-    DCHECK_EQ(is_ready_, true);
+    GRPC_DCHECK_EQ(is_ready_, true);
 
     // Generate the gRPC Metadata from buffer_
     // RFC9113 :  A receiver MUST terminate the connection with a connection
@@ -154,6 +154,14 @@ class HeaderAssembler {
     // connection error (Section 5.4.1) of type COMPRESSION_ERROR.
     Arena::PoolPtr<grpc_metadata_batch> metadata =
         Arena::MakePooledForOverwrite<grpc_metadata_batch>();
+    // TODO(tjagtap) : [PH2][P5] : Currently the transport does not enforce
+    // setting allow_true_binary_metadata_ sent to the peer.
+    // Ideally Hpack code must validate and enforce this setting but it is not
+    // doing so now. Given that this is complex code and also common between
+    // CHTTP2 and PH2, we must do this as a standalone project with an
+    // experiment of its own. For now we just honour allow_true_binary_metadata_
+    // while writing frames for the peer on the write path. We do not enforce it
+    // on the read path.
     parser.BeginFrame(
         /*grpc_metadata_batch*/ metadata.get(), max_header_list_size_soft_limit,
         max_header_list_size_hard_limit,
@@ -190,8 +198,12 @@ class HeaderAssembler {
   // This value MUST be checked before calling ReadMetadata()
   bool IsReady() const { return is_ready_; }
 
-  explicit HeaderAssembler(const uint32_t stream_id)
-      : header_in_progress_(false), is_ready_(false), stream_id_(stream_id) {}
+  explicit HeaderAssembler(const uint32_t stream_id,
+                           const bool allow_true_binary_metadata_acked)
+      : header_in_progress_(false),
+        is_ready_(false),
+        allow_true_binary_metadata_acked_(allow_true_binary_metadata_acked),
+        stream_id_(stream_id) {}
 
   ~HeaderAssembler() = default;
 
@@ -209,6 +221,7 @@ class HeaderAssembler {
 
   bool header_in_progress_;
   bool is_ready_;
+  GRPC_UNUSED const bool allow_true_binary_metadata_acked_;
   const uint32_t stream_id_;
   SliceBuffer buffer_;
 };
@@ -223,16 +236,17 @@ class HeaderDisassembler {
   bool PrepareForSending(Arena::PoolPtr<grpc_metadata_batch>&& metadata,
                          HPackCompressor& encoder) {
     // Validate disassembler state
-    DCHECK(!is_done_);
+    GRPC_DCHECK(!is_done_);
     // Prepare metadata for sending
-    return encoder.EncodeRawHeaders(*metadata.get(), buffer_);
+    return encoder.EncodeRawHeaders(*metadata.get(), buffer_,
+                                    allow_true_binary_metadata_peer_);
   }
 
   Http2Frame GetNextFrame(const uint32_t max_frame_length,
                           bool& out_end_headers) {
     if (buffer_.Length() == 0 || is_done_) {
-      DCHECK(false) << "Calling code must check size using HasMoreData() "
-                       "before GetNextFrame()";
+      GRPC_DCHECK(false) << "Calling code must check size using HasMoreData() "
+                            "before GetNextFrame()";
     }
     out_end_headers = buffer_.Length() <= max_frame_length;
     SliceBuffer temp;
@@ -260,11 +274,13 @@ class HeaderDisassembler {
   // A separate HeaderDisassembler object MUST be made for Initial Metadata and
   // Trailing Metadata
   explicit HeaderDisassembler(const uint32_t stream_id,
-                              const bool is_trailing_metadata)
+                              const bool is_trailing_metadata,
+                              const bool allow_true_binary_metadata_peer)
       : stream_id_(stream_id),
         end_stream_(is_trailing_metadata),
         did_send_header_frame_(false),
-        is_done_(false) {}
+        is_done_(false),
+        allow_true_binary_metadata_peer_(allow_true_binary_metadata_peer) {}
 
   ~HeaderDisassembler() = default;
 
@@ -280,7 +296,7 @@ class HeaderDisassembler {
   const bool end_stream_;
   bool did_send_header_frame_;
   bool is_done_;  // Protect against the same disassembler from being used twice
-
+  const bool allow_true_binary_metadata_peer_;
   SliceBuffer buffer_;
 };
 

data/src/core/ext/transport/chttp2/transport/hpack_encoder.cc

@@ -25,7 +25,6 @@
 #include <algorithm>
 #include <cstdint>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/ext/transport/chttp2/transport/bin_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
@@ -36,6 +35,7 @@
 #include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/lib/transport/timeout_encoding.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -61,7 +61,7 @@ static void FillHeader(uint8_t* p, uint8_t type, uint32_t id, size_t len,
   // max_frame_size is derived from GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE,
   // which has a max allowable value of 16777215 (see chttp_transport.cc).
   // Thus, the following assert can be a debug assert.
-  DCHECK_LE(len, 16777216u);
+  GRPC_DCHECK_LE(len, 16777216u);
   *p++ = static_cast<uint8_t>(len >> 16);
   *p++ = static_cast<uint8_t>(len >> 8);
   *p++ = static_cast<uint8_t>(len);

data/src/core/ext/transport/chttp2/transport/hpack_encoder.h

@@ -369,8 +369,10 @@ class HPackCompressor {
   }
 
   template <typename HeaderSet>
-  bool EncodeRawHeaders(const HeaderSet& headers, SliceBuffer& output) {
-    hpack_encoder_detail::Encoder encoder(this, true, output);
+  bool EncodeRawHeaders(const HeaderSet& headers, SliceBuffer& output,
+                        bool allow_true_binary_metadata) {
+    hpack_encoder_detail::Encoder encoder(this, allow_true_binary_metadata,
+                                          output);
     headers.Encode(&encoder);
     return !encoder.saw_encoding_errors();
   }

data/src/core/ext/transport/chttp2/transport/hpack_encoder_table.cc

@@ -18,15 +18,15 @@
 
 #include <algorithm>
 
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
 uint32_t HPackEncoderTable::AllocateIndex(size_t element_size) {
-  DCHECK_GE(element_size, 32u);
+  GRPC_DCHECK_GE(element_size, 32u);
 
   uint32_t new_index = tail_remote_index_ + table_elems_ + 1;
-  DCHECK(element_size <= MaxEntrySize());
+  GRPC_DCHECK_LE(element_size, MaxEntrySize());
 
   if (element_size > max_table_size_) {
     while (table_size_ > 0) {
@@ -41,7 +41,7 @@ uint32_t HPackEncoderTable::AllocateIndex(size_t element_size) {
   while (table_size_ + element_size > max_table_size_) {
     EvictOne();
   }
-  CHECK(table_elems_ < elem_size_.size());
+  GRPC_CHECK(table_elems_ < elem_size_.size());
   elem_size_[new_index % elem_size_.size()] =
       static_cast<uint16_t>(element_size);
   table_size_ += element_size;
@@ -70,17 +70,17 @@ bool HPackEncoderTable::SetMaxSize(uint32_t max_table_size) {
 
 void HPackEncoderTable::EvictOne() {
   tail_remote_index_++;
-  CHECK_GT(tail_remote_index_, 0u);
-  CHECK_GT(table_elems_, 0u);
+  GRPC_CHECK_GT(tail_remote_index_, 0u);
+  GRPC_CHECK_GT(table_elems_, 0u);
   auto removing_size = elem_size_[tail_remote_index_ % elem_size_.size()];
-  CHECK(table_size_ >= removing_size);
+  GRPC_CHECK(table_size_ >= removing_size);
   table_size_ -= removing_size;
   table_elems_--;
 }
 
 void HPackEncoderTable::Rebuild(uint32_t capacity) {
   decltype(elem_size_) new_elem_size(capacity);
-  CHECK_LE(table_elems_, capacity);
+  GRPC_CHECK_LE(table_elems_, capacity);
   for (uint32_t i = 0; i < table_elems_; i++) {
     uint32_t ofs = tail_remote_index_ + i + 1;
     new_elem_size[ofs % capacity] = elem_size_[ofs % elem_size_.size()];

data/src/core/ext/transport/chttp2/transport/hpack_parse_result.cc

@@ -17,11 +17,11 @@
 #include <grpc/support/port_platform.h>
 #include <stddef.h>
 
-#include "absl/log/check.h"
 #include "absl/strings/str_format.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/status_helper.h"
 
 namespace grpc_core {
@@ -52,7 +52,7 @@ class MetadataSizeLimitExceededEncoder {
 };
 
 absl::Status MakeStreamError(absl::Status error) {
-  DCHECK(!error.ok());
+  GRPC_DCHECK(!error.ok());
   return grpc_error_set_int(std::move(error), StatusIntProperty::kStreamId, 0);
 }
 }  // namespace

data/src/core/ext/transport/chttp2/transport/hpack_parse_result.h

@@ -23,13 +23,13 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 
@@ -191,7 +191,7 @@ class HpackParseResult {
 
   static HpackParseResult InvalidMetadataError(ValidateMetadataResult result,
                                                absl::string_view key) {
-    DCHECK(result != ValidateMetadataResult::kOk);
+    GRPC_DCHECK(result != ValidateMetadataResult::kOk);
     HpackParseResult p{HpackParseStatus::kInvalidMetadata};
     p.state_->key = std::string(key);
     p.state_->validate_metadata_result = result;