grpc 1.75.0.pre1 → 1.76.0.pre1

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

@@ -31,7 +31,6 @@
 #include <variant>
 
 #include "absl/base/attributes.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/match.h"
@@ -51,6 +50,7 @@
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/match.h"
 
 // IWYU pragma: no_include <type_traits>
@@ -193,7 +193,7 @@ class HPackParser::Input {
   std::optional<StringPrefix> ParseStringPrefix() {
     auto cur = Next();
     if (!cur.has_value()) {
-      DCHECK(eof_error());
+      GRPC_DCHECK(eof_error());
       return {};
     }
     // Huffman if the top bit is 1
@@ -204,7 +204,7 @@ class HPackParser::Input {
       // all ones ==> varint string length
       auto v = ParseVarint(0x7f);
       if (!v.has_value()) {
-        DCHECK(eof_error());
+        GRPC_DCHECK(eof_error());
         return {};
       }
       strlen = *v;
@@ -231,7 +231,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) {
-    DCHECK(error.stream_error());
+    GRPC_DCHECK(error.stream_error());
     SetError(std::move(error));
   }
 
@@ -239,7 +239,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) {
-    DCHECK(error.connection_error());
+    GRPC_DCHECK(error.connection_error());
     SetError(std::move(error));
     begin_ = end_;
   }
@@ -248,17 +248,17 @@ 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) {
-    CHECK_GT(min_progress_size, 0u);
+    GRPC_CHECK_GT(min_progress_size, 0u);
     if (eof_error()) return;
     // Set min progress size, taking into account bytes parsed already but not
     // consumed.
     min_progress_size_ = min_progress_size + (begin_ - frontier_);
-    DCHECK(eof_error());
+    GRPC_DCHECK(eof_error());
   }
 
   // Update the frontier - signifies we've successfully parsed another element
   void UpdateFrontier() {
-    DCHECK_EQ(skip_bytes_, 0u);
+    GRPC_DCHECK_EQ(skip_bytes_, 0u);
     frontier_ = begin_;
   }
 
@@ -381,7 +381,7 @@ HPackParser::String::StringResult HPackParser::String::ParseUncompressed(
   // Check there's enough bytes
   if (input->remaining() < length) {
     input->UnexpectedEOF(/*min_progress_size=*/length);
-    DCHECK(input->eof_error());
+    GRPC_DCHECK(input->eof_error());
     return StringResult{HpackParseStatus::kEof, wire_size, String{}};
   }
   auto* refcount = input->slice_refcount();
@@ -601,7 +601,7 @@ class HPackParser::Parser {
 
  private:
   bool ParseTop() {
-    DCHECK(state_.parse_state == ParseState::kTop);
+    GRPC_DCHECK(state_.parse_state == ParseState::kTop);
     auto cur = *input_->Next();
     input_->ClearFieldError();
     switch (cur >> 4) {
@@ -773,7 +773,7 @@ class HPackParser::Parser {
 
   // Parse an index encoded key and a string encoded value
   bool StartIdxKey(uint32_t index, bool add_to_table) {
-    DCHECK(state_.parse_state == ParseState::kTop);
+    GRPC_DCHECK(state_.parse_state == ParseState::kTop);
     input_->UpdateFrontier();
     const auto* elem = state_.hpack_table.Lookup(index);
     if (GPR_UNLIKELY(elem == nullptr)) {
@@ -789,14 +789,14 @@ class HPackParser::Parser {
 
   // Parse a varint index encoded key and a string encoded value
   bool StartVarIdxKey(uint32_t offset, bool add_to_table) {
-    DCHECK(state_.parse_state == ParseState::kTop);
+    GRPC_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) {
-    DCHECK(state_.parse_state == ParseState::kTop);
+    GRPC_DCHECK(state_.parse_state == ParseState::kTop);
     state_.add_to_table = add_to_table;
     state_.parse_state = ParseState::kParsingKeyLength;
     input_->UpdateFrontier();
@@ -831,7 +831,7 @@ class HPackParser::Parser {
   }
 
   bool ParseKeyLength() {
-    DCHECK(state_.parse_state == ParseState::kParsingKeyLength);
+    GRPC_DCHECK(state_.parse_state == ParseState::kParsingKeyLength);
     auto pfx = input_->ParseStringPrefix();
     if (!pfx.has_value()) return false;
     state_.is_string_huff_compressed = pfx->huff;
@@ -852,14 +852,14 @@ class HPackParser::Parser {
   }
 
   bool ParseKeyBody() {
-    DCHECK(state_.parse_state == ParseState::kParsingKeyBody);
+    GRPC_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:
-        DCHECK(input_->eof_error());
+        GRPC_DCHECK(input_->eof_error());
         return false;
       default:
         input_->SetErrorAndStopParsing(
@@ -899,7 +899,7 @@ class HPackParser::Parser {
   }
 
   bool SkipKeyBody() {
-    DCHECK(state_.parse_state == ParseState::kSkippingKeyBody);
+    GRPC_DCHECK(state_.parse_state == ParseState::kSkippingKeyBody);
     if (!SkipStringBody()) return false;
     input_->UpdateFrontier();
     state_.parse_state = ParseState::kSkippingValueLength;
@@ -907,7 +907,7 @@ class HPackParser::Parser {
   }
 
   bool SkipValueLength() {
-    DCHECK(state_.parse_state == ParseState::kSkippingValueLength);
+    GRPC_DCHECK(state_.parse_state == ParseState::kSkippingValueLength);
     auto pfx = input_->ParseStringPrefix();
     if (!pfx.has_value()) return false;
     state_.string_length = pfx->length;
@@ -917,7 +917,7 @@ class HPackParser::Parser {
   }
 
   bool SkipValueBody() {
-    DCHECK(state_.parse_state == ParseState::kSkippingValueBody);
+    GRPC_DCHECK(state_.parse_state == ParseState::kSkippingValueBody);
     if (!SkipStringBody()) return false;
     input_->UpdateFrontier();
     state_.parse_state = ParseState::kTop;
@@ -928,7 +928,7 @@ class HPackParser::Parser {
   }
 
   bool ParseValueLength() {
-    DCHECK(state_.parse_state == ParseState::kParsingValueLength);
+    GRPC_DCHECK(state_.parse_state == ParseState::kParsingValueLength);
     auto pfx = input_->ParseStringPrefix();
     if (!pfx.has_value()) return false;
     state_.is_string_huff_compressed = pfx->huff;
@@ -952,7 +952,7 @@ class HPackParser::Parser {
   }
 
   bool ParseValueBody() {
-    DCHECK(state_.parse_state == ParseState::kParsingValueBody);
+    GRPC_DCHECK(state_.parse_state == ParseState::kParsingValueBody);
     auto value =
         state_.is_binary_header
             ? String::ParseBinary(input_, state_.is_string_huff_compressed,
@@ -980,7 +980,7 @@ class HPackParser::Parser {
       case HpackParseStatus::kOk:
         break;
       case HpackParseStatus::kEof:
-        DCHECK(input_->eof_error());
+        GRPC_DCHECK(input_->eof_error());
         return false;
       default: {
         auto result =
@@ -1106,9 +1106,9 @@ void HPackParser::BeginFrame(grpc_metadata_batch* metadata_buffer,
   log_info_ = log_info;
 }
 
-grpc_error_handle HPackParser::Parse(
-    const grpc_slice& slice, bool is_last, absl::BitGenRef bitsrc,
-    CallTracerAnnotationInterface* call_tracer) {
+grpc_error_handle HPackParser::Parse(const grpc_slice& slice, bool is_last,
+                                     absl::BitGenRef bitsrc,
+                                     CallSpan* call_tracer) {
   if (GPR_UNLIKELY(!unparsed_bytes_.empty())) {
     unparsed_bytes_.insert(unparsed_bytes_.end(), GRPC_SLICE_START_PTR(slice),
                            GRPC_SLICE_END_PTR(slice));
@@ -1129,8 +1129,8 @@ grpc_error_handle HPackParser::Parse(
                     is_last, call_tracer);
 }
 
-grpc_error_handle HPackParser::ParseInput(
-    Input input, bool is_last, CallTracerAnnotationInterface* call_tracer) {
+grpc_error_handle HPackParser::ParseInput(Input input, bool is_last,
+                                          CallSpan* call_tracer) {
   ParseInputInner(&input);
   if (is_last && is_boundary()) {
     if (state_.metadata_early_detection.Reject(state_.frame_length,

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

@@ -104,8 +104,7 @@ class HPackParser {
   void StopBufferingFrame() { metadata_buffer_ = nullptr; }
   // Parse one slice worth of data
   grpc_error_handle Parse(const grpc_slice& slice, bool is_last,
-                          absl::BitGenRef bitsrc,
-                          CallTracerAnnotationInterface* call_tracer);
+                          absl::BitGenRef bitsrc, CallSpan* call_tracer);
   // Reset state ready for the next BeginFrame
   void FinishFrame();
 
@@ -257,7 +256,7 @@ class HPackParser {
   };
 
   grpc_error_handle ParseInput(Input input, bool is_last,
-                               CallTracerAnnotationInterface* call_tracer);
+                               CallSpan* call_tracer);
   void ParseInputInner(Input* input);
   GPR_ATTRIBUTE_NOINLINE
   void HandleMetadataSoftSizeLimitExceeded(Input* input);

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

@@ -26,7 +26,6 @@
 #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"
@@ -37,11 +36,12 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/telemetry/stats.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
 void HPackTable::MementoRingBuffer::Put(Memento m) {
-  CHECK_LT(num_entries_, max_entries_);
+  GRPC_CHECK_LT(num_entries_, max_entries_);
   if (entries_.size() < max_entries_) {
     ++num_entries_;
     return entries_.push_back(std::move(m));
@@ -56,7 +56,7 @@ void HPackTable::MementoRingBuffer::Put(Memento m) {
 }
 
 auto HPackTable::MementoRingBuffer::PopOne() -> Memento {
-  CHECK_GT(num_entries_, 0u);
+  GRPC_CHECK_GT(num_entries_, 0u);
   size_t index = first_entry_ % max_entries_;
   if (index == timestamp_index_) {
     http2_stats_collector_->IncrementHttp2HpackEntryLifetime(
@@ -121,7 +121,7 @@ HPackTable::MementoRingBuffer::~MementoRingBuffer() {
 // Evict one element from the table
 void HPackTable::EvictOne() {
   auto first_entry = entries_.PopOne();
-  CHECK(first_entry.md.transport_size() <= mem_used_);
+  GRPC_CHECK(first_entry.md.transport_size() <= mem_used_);
   mem_used_ -= first_entry.md.transport_size();
 }