grpc 1.63.0 → 1.65.2

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

@@ -16,21 +16,21 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder.h"
 
 #include <algorithm>
 #include <cstdint>
 
+#include "absl/log/check.h"
+
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/bin_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder_table.h"
-#include "src/core/ext/transport/chttp2/transport/http_trace.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/ext/transport/chttp2/transport/varint.h"
 #include "src/core/lib/debug/trace.h"
@@ -62,7 +62,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.
-  GPR_DEBUG_ASSERT(len <= 16777216);
+  DCHECK_LE(len, 16777216u);
   *p++ = static_cast<uint8_t>(len >> 16);
   *p++ = static_cast<uint8_t>(len >> 8);
   *p++ = static_cast<uint8_t>(len);
@@ -117,7 +117,7 @@ void HPackCompressor::SetMaxUsableSize(uint32_t max_table_size) {
 void HPackCompressor::SetMaxTableSize(uint32_t max_table_size) {
   if (table_.SetMaxSize(std::min(max_usable_size_, max_table_size))) {
     advertise_table_size_change_ = true;
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(http)) {
       gpr_log(GPR_INFO, "set max table size from encoder to %d",
               max_table_size);
     }
@@ -377,7 +377,8 @@ void Compressor<HttpSchemeMetadata, HttpSchemeCompressor>::EncodeWith(
       encoder->EmitIndexed(7);  // :scheme: https
       break;
     case HttpSchemeMetadata::ValueType::kInvalid:
-      Crash("invalid http scheme encoding");
+      LOG(ERROR) << "Not encoding bad http scheme";
+      encoder->NoteEncodingError();
       break;
   }
 }
@@ -434,7 +435,8 @@ void Compressor<HttpMethodMetadata, HttpMethodCompressor>::EncodeWith(
           Slice::FromStaticString(":method"), Slice::FromStaticString("PUT"));
       break;
     case HttpMethodMetadata::ValueType::kInvalid:
-      Crash("invalid http method encoding");
+      LOG(ERROR) << "Not encoding bad http method";
+      encoder->NoteEncodingError();
       break;
   }
 }

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

@@ -19,8 +19,6 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include <cstdint>
@@ -33,6 +31,7 @@
 
 #include <grpc/slice.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder_table.h"
@@ -83,10 +82,14 @@ class Encoder {
                                  const Slice& slice, uint32_t* index,
                                  size_t max_compression_size);
 
+  void NoteEncodingError() { saw_encoding_errors_ = true; }
+  bool saw_encoding_errors() const { return saw_encoding_errors_; }
+
   HPackEncoderTable& hpack_table();
 
  private:
   const bool use_true_binary_metadata_;
+  bool saw_encoding_errors_ = false;
   HPackCompressor* const compressor_;
   SliceBuffer& output_;
 };
@@ -208,6 +211,7 @@ class Compressor<
       gpr_log(GPR_ERROR, "%s",
               absl::StrCat("Not encoding bad ", MetadataTrait::key(), " header")
                   .c_str());
+      encoder->NoteEncodingError();
       return;
     }
     Slice encoded(MetadataTrait::Encode(known_value));
@@ -355,19 +359,21 @@ class HPackCompressor {
   };
 
   template <typename HeaderSet>
-  void EncodeHeaders(const EncodeHeaderOptions& options,
+  bool EncodeHeaders(const EncodeHeaderOptions& options,
                      const HeaderSet& headers, grpc_slice_buffer* output) {
     SliceBuffer raw;
     hpack_encoder_detail::Encoder encoder(
         this, options.use_true_binary_metadata, raw);
     headers.Encode(&encoder);
     Frame(options, raw, output);
+    return !encoder.saw_encoding_errors();
   }
 
   template <typename HeaderSet>
-  void EncodeRawHeaders(const HeaderSet& headers, SliceBuffer& output) {
+  bool EncodeRawHeaders(const HeaderSet& headers, SliceBuffer& output) {
     hpack_encoder_detail::Encoder encoder(this, true, output);
     headers.Encode(&encoder);
+    return !encoder.saw_encoding_errors();
   }
 
  private:

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

@@ -12,21 +12,22 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder_table.h"
 
 #include <algorithm>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 
 uint32_t HPackEncoderTable::AllocateIndex(size_t element_size) {
-  GPR_DEBUG_ASSERT(element_size >= 32);
+  DCHECK_GE(element_size, 32u);
 
   uint32_t new_index = tail_remote_index_ + table_elems_ + 1;
-  GPR_DEBUG_ASSERT(element_size <= MaxEntrySize());
+  DCHECK(element_size <= MaxEntrySize());
 
   if (element_size > max_table_size_) {
     while (table_size_ > 0) {
@@ -41,7 +42,7 @@ uint32_t HPackEncoderTable::AllocateIndex(size_t element_size) {
   while (table_size_ + element_size > max_table_size_) {
     EvictOne();
   }
-  GPR_ASSERT(table_elems_ < elem_size_.size());
+  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 +71,17 @@ bool HPackEncoderTable::SetMaxSize(uint32_t max_table_size) {
 
 void HPackEncoderTable::EvictOne() {
   tail_remote_index_++;
-  GPR_ASSERT(tail_remote_index_ > 0);
-  GPR_ASSERT(table_elems_ > 0);
+  CHECK_GT(tail_remote_index_, 0u);
+  CHECK_GT(table_elems_, 0u);
   auto removing_size = elem_size_[tail_remote_index_ % elem_size_.size()];
-  GPR_ASSERT(table_size_ >= removing_size);
+  CHECK(table_size_ >= removing_size);
   table_size_ -= removing_size;
   table_elems_--;
 }
 
 void HPackEncoderTable::Rebuild(uint32_t capacity) {
   decltype(elem_size_) new_elem_size(capacity);
-  GPR_ASSERT(table_elems_ <= capacity);
+  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_encoder_table.h

@@ -15,14 +15,14 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_TABLE_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_TABLE_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <vector>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 
 namespace grpc_core {

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

@@ -12,14 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
 
 #include <stddef.h>
 
+#include "absl/log/check.h"
 #include "absl/strings/str_format.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/error.h"
@@ -53,7 +54,7 @@ class MetadataSizeLimitExceededEncoder {
 };
 
 absl::Status MakeStreamError(absl::Status error) {
-  GPR_DEBUG_ASSERT(!error.ok());
+  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

@@ -15,20 +15,20 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSE_RESULT_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSE_RESULT_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <memory>
 #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 "absl/types/optional.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -194,7 +194,7 @@ class HpackParseResult {
 
   static HpackParseResult InvalidMetadataError(ValidateMetadataResult result,
                                                absl::string_view key) {
-    GPR_DEBUG_ASSERT(result != ValidateMetadataResult::kOk);
+    DCHECK(result != ValidateMetadataResult::kOk);
     HpackParseResult p{HpackParseStatus::kInvalidMetadata};
     p.state_->key = std::string(key);
     p.state_->validate_metadata_result = result;

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

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 
 #include <stddef.h>
@@ -29,6 +27,7 @@
 #include <utility>
 
 #include "absl/base/attributes.h"
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
@@ -39,14 +38,12 @@
 
 #include <grpc/slice.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/decode_huff.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
-#include "src/core/lib/channel/call_tracer.h"
-#include "src/core/lib/debug/stats.h"
-#include "src/core/lib/debug/stats_data.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/slice/slice.h"
@@ -54,13 +51,14 @@
 #include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/lib/transport/metadata_info.h"
 #include "src/core/lib/transport/parsed_metadata.h"
+#include "src/core/telemetry/call_tracer.h"
+#include "src/core/telemetry/stats.h"
+#include "src/core/telemetry/stats_data.h"
 
 // IWYU pragma: no_include <type_traits>
 
 namespace grpc_core {
 
-TraceFlag grpc_trace_chttp2_hpack_parser(false, "chttp2_hpack_parser");
-
 namespace {
 // The alphabet used for base64 encoding binary metadata.
 constexpr char kBase64Alphabet[] =
@@ -195,7 +193,7 @@ class HPackParser::Input {
   absl::optional<StringPrefix> ParseStringPrefix() {
     auto cur = Next();
     if (!cur.has_value()) {
-      GPR_DEBUG_ASSERT(eof_error());
+      DCHECK(eof_error());
       return {};
     }
     // Huffman if the top bit is 1
@@ -206,7 +204,7 @@ class HPackParser::Input {
       // all ones ==> varint string length
       auto v = ParseVarint(0x7f);
       if (!v.has_value()) {
-        GPR_DEBUG_ASSERT(eof_error());
+        DCHECK(eof_error());
         return {};
       }
       strlen = *v;
@@ -229,7 +227,7 @@ class HPackParser::Input {
   // Intended for errors that are specific to a stream and recoverable.
   // Callers should ensure that any hpack table updates happen.
   void SetErrorAndContinueParsing(HpackParseResult error) {
-    GPR_DEBUG_ASSERT(error.stream_error());
+    DCHECK(error.stream_error());
     SetError(std::move(error));
   }
 
@@ -237,7 +235,7 @@ class HPackParser::Input {
   // Intended for unrecoverable errors, with the expectation that they will
   // close the connection on return to chttp2.
   void SetErrorAndStopParsing(HpackParseResult error) {
-    GPR_DEBUG_ASSERT(error.connection_error());
+    DCHECK(error.connection_error());
     SetError(std::move(error));
     begin_ = end_;
   }
@@ -246,20 +244,20 @@ class HPackParser::Input {
   // min_progress_size: how many bytes beyond the current frontier do we need to
   // read prior to being able to get further in this parse.
   void UnexpectedEOF(size_t min_progress_size) {
-    GPR_ASSERT(min_progress_size > 0);
+    CHECK_GT(min_progress_size, 0u);
     if (min_progress_size_ != 0 || error_.connection_error()) {
-      GPR_DEBUG_ASSERT(eof_error());
+      DCHECK(eof_error());
       return;
     }
     // Set min progress size, taking into account bytes parsed already but not
     // consumed.
     min_progress_size_ = min_progress_size + (begin_ - frontier_);
-    GPR_DEBUG_ASSERT(eof_error());
+    DCHECK(eof_error());
   }
 
   // Update the frontier - signifies we've successfully parsed another element
   void UpdateFrontier() {
-    GPR_DEBUG_ASSERT(skip_bytes_ == 0);
+    DCHECK_EQ(skip_bytes_, 0u);
     frontier_ = begin_;
   }
 
@@ -376,7 +374,7 @@ HPackParser::String::StringResult HPackParser::String::ParseUncompressed(
   // Check there's enough bytes
   if (input->remaining() < length) {
     input->UnexpectedEOF(/*min_progress_size=*/length);
-    GPR_DEBUG_ASSERT(input->eof_error());
+    DCHECK(input->eof_error());
     return StringResult{HpackParseStatus::kEof, wire_size, String{}};
   }
   auto* refcount = input->slice_refcount();
@@ -596,7 +594,7 @@ class HPackParser::Parser {
 
  private:
   bool ParseTop() {
-    GPR_DEBUG_ASSERT(state_.parse_state == ParseState::kTop);
+    DCHECK(state_.parse_state == ParseState::kTop);
     auto cur = *input_->Next();
     switch (cur >> 4) {
         // Literal header not indexed - First byte format: 0000xxxx
@@ -733,7 +731,7 @@ class HPackParser::Parser {
 
   bool FinishHeaderAndAddToTable(HPackTable::Memento md) {
     // Log if desired
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_chttp2_hpack_parser)) {
+    if (GRPC_TRACE_FLAG_ENABLED(chttp2_hpack_parser)) {
       LogHeader(md);
     }
     // Emit whilst we own the metadata.
@@ -758,7 +756,7 @@ class HPackParser::Parser {
 
   void FinishHeaderOmitFromTable(const HPackTable::Memento& md) {
     // Log if desired
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_chttp2_hpack_parser)) {
+    if (GRPC_TRACE_FLAG_ENABLED(chttp2_hpack_parser)) {
       LogHeader(md);
     }
     EmitHeader(md);
@@ -766,7 +764,7 @@ class HPackParser::Parser {
 
   // Parse an index encoded key and a string encoded value
   bool StartIdxKey(uint32_t index, bool add_to_table) {
-    GPR_DEBUG_ASSERT(state_.parse_state == ParseState::kTop);
+    DCHECK(state_.parse_state == ParseState::kTop);
     input_->UpdateFrontier();
     const auto* elem = state_.hpack_table.Lookup(index);
     if (GPR_UNLIKELY(elem == nullptr)) {
@@ -782,14 +780,14 @@ class HPackParser::Parser {
 
   // Parse a varint index encoded key and a string encoded value
   bool StartVarIdxKey(uint32_t offset, bool add_to_table) {
-    GPR_DEBUG_ASSERT(state_.parse_state == ParseState::kTop);
+    DCHECK(state_.parse_state == ParseState::kTop);
     auto index = input_->ParseVarint(offset);
     if (GPR_UNLIKELY(!index.has_value())) return false;
     return StartIdxKey(*index, add_to_table);
   }
 
   bool StartParseLiteralKey(bool add_to_table) {
-    GPR_DEBUG_ASSERT(state_.parse_state == ParseState::kTop);
+    DCHECK(state_.parse_state == ParseState::kTop);
     state_.add_to_table = add_to_table;
     state_.parse_state = ParseState::kParsingKeyLength;
     input_->UpdateFrontier();
@@ -824,7 +822,7 @@ class HPackParser::Parser {
   }
 
   bool ParseKeyLength() {
-    GPR_DEBUG_ASSERT(state_.parse_state == ParseState::kParsingKeyLength);
+    DCHECK(state_.parse_state == ParseState::kParsingKeyLength);
     auto pfx = input_->ParseStringPrefix();
     if (!pfx.has_value()) return false;
     state_.is_string_huff_compressed = pfx->huff;
@@ -845,14 +843,14 @@ class HPackParser::Parser {
   }
 
   bool ParseKeyBody() {
-    GPR_DEBUG_ASSERT(state_.parse_state == ParseState::kParsingKeyBody);
+    DCHECK(state_.parse_state == ParseState::kParsingKeyBody);
     auto key = String::Parse(input_, state_.is_string_huff_compressed,
                              state_.string_length);
     switch (key.status) {
       case HpackParseStatus::kOk:
         break;
       case HpackParseStatus::kEof:
-        GPR_DEBUG_ASSERT(input_->eof_error());
+        DCHECK(input_->eof_error());
         return false;
       default:
         input_->SetErrorAndStopParsing(
@@ -892,7 +890,7 @@ class HPackParser::Parser {
   }
 
   bool SkipKeyBody() {
-    GPR_DEBUG_ASSERT(state_.parse_state == ParseState::kSkippingKeyBody);
+    DCHECK(state_.parse_state == ParseState::kSkippingKeyBody);
     if (!SkipStringBody()) return false;
     input_->UpdateFrontier();
     state_.parse_state = ParseState::kSkippingValueLength;
@@ -900,7 +898,7 @@ class HPackParser::Parser {
   }
 
   bool SkipValueLength() {
-    GPR_DEBUG_ASSERT(state_.parse_state == ParseState::kSkippingValueLength);
+    DCHECK(state_.parse_state == ParseState::kSkippingValueLength);
     auto pfx = input_->ParseStringPrefix();
     if (!pfx.has_value()) return false;
     state_.string_length = pfx->length;
@@ -910,7 +908,7 @@ class HPackParser::Parser {
   }
 
   bool SkipValueBody() {
-    GPR_DEBUG_ASSERT(state_.parse_state == ParseState::kSkippingValueBody);
+    DCHECK(state_.parse_state == ParseState::kSkippingValueBody);
     if (!SkipStringBody()) return false;
     input_->UpdateFrontier();
     state_.parse_state = ParseState::kTop;
@@ -921,7 +919,7 @@ class HPackParser::Parser {
   }
 
   bool ParseValueLength() {
-    GPR_DEBUG_ASSERT(state_.parse_state == ParseState::kParsingValueLength);
+    DCHECK(state_.parse_state == ParseState::kParsingValueLength);
     auto pfx = input_->ParseStringPrefix();
     if (!pfx.has_value()) return false;
     state_.is_string_huff_compressed = pfx->huff;
@@ -945,7 +943,7 @@ class HPackParser::Parser {
   }
 
   bool ParseValueBody() {
-    GPR_DEBUG_ASSERT(state_.parse_state == ParseState::kParsingValueBody);
+    DCHECK(state_.parse_state == ParseState::kParsingValueBody);
     auto value =
         state_.is_binary_header
             ? String::ParseBinary(input_, state_.is_string_huff_compressed,
@@ -974,7 +972,7 @@ class HPackParser::Parser {
       case HpackParseStatus::kOk:
         break;
       case HpackParseStatus::kEof:
-        GPR_DEBUG_ASSERT(input_->eof_error());
+        DCHECK(input_->eof_error());
         return false;
       default: {
         auto result =

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

@@ -19,8 +19,6 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 #include <stdint.h>
 
@@ -36,16 +34,17 @@
 #include "absl/types/variant.h"
 
 #include <grpc/slice.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/backoff/random_early_detection.h"
-#include "src/core/lib/channel/call_tracer.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/telemetry/call_tracer.h"
 
 // IWYU pragma: no_include <type_traits>
 

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

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
 
 #include <stdlib.h>
@@ -27,22 +25,23 @@
 #include <cstring>
 #include <utility>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
-#include "src/core/ext/transport/chttp2/transport/http_trace.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/slice/slice.h"
 
 namespace grpc_core {
 
 void HPackTable::MementoRingBuffer::Put(Memento m) {
-  GPR_ASSERT(num_entries_ < max_entries_);
+  CHECK_LT(num_entries_, max_entries_);
   if (entries_.size() < max_entries_) {
     ++num_entries_;
     return entries_.push_back(std::move(m));
@@ -53,7 +52,7 @@ void HPackTable::MementoRingBuffer::Put(Memento m) {
 }
 
 auto HPackTable::MementoRingBuffer::PopOne() -> Memento {
-  GPR_ASSERT(num_entries_ > 0);
+  CHECK_GT(num_entries_, 0u);
   size_t index = first_entry_ % max_entries_;
   ++first_entry_;
   --num_entries_;
@@ -91,7 +90,7 @@ void HPackTable::MementoRingBuffer::ForEach(
 // Evict one element from the table
 void HPackTable::EvictOne() {
   auto first_entry = entries_.PopOne();
-  GPR_ASSERT(first_entry.md.transport_size() <= mem_used_);
+  CHECK(first_entry.md.transport_size() <= mem_used_);
   mem_used_ -= first_entry.md.transport_size();
 }
 
@@ -99,9 +98,7 @@ void HPackTable::SetMaxBytes(uint32_t max_bytes) {
   if (max_bytes_ == max_bytes) {
     return;
   }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
-    gpr_log(GPR_INFO, "Update hpack parser max size to %d", max_bytes);
-  }
+  GRPC_TRACE_LOG(http, INFO) << "Update hpack parser max size to " << max_bytes;
   while (mem_used_ > max_bytes) {
     EvictOne();
   }
@@ -111,9 +108,7 @@ void HPackTable::SetMaxBytes(uint32_t max_bytes) {
 bool HPackTable::SetCurrentTableSize(uint32_t bytes) {
   if (current_table_bytes_ == bytes) return true;
   if (bytes > max_bytes_) return false;
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
-    gpr_log(GPR_INFO, "Update hpack parser table size to %d", bytes);
-  }
+  GRPC_TRACE_LOG(http, INFO) << "Update hpack parser table size to " << bytes;
   while (mem_used_ > bytes) {
     EvictOne();
   }

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

@@ -19,8 +19,6 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_TABLE_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_TABLE_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <memory>
@@ -29,6 +27,8 @@
 
 #include "absl/functional/function_ref.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
 #include "src/core/lib/gprpp/no_destruct.h"

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

@@ -18,15 +18,15 @@
 // Automatically generated by tools/codegen/core/gen_settings_ids.py
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 
 #include "absl/strings/str_cat.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/ext/transport/chttp2/transport/frame.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/transport/http2_errors.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_core {
 

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

@@ -17,8 +17,6 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_SETTINGS_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_SETTINGS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <cstdint>
@@ -27,9 +25,11 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/ext/transport/chttp2/transport/frame.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/transport/http2_errors.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_core {