grpc 1.63.2 → 1.64.0.pre1

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,6 +38,7 @@
 
 #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"
@@ -92,14 +92,12 @@ constexpr Base64InverseTable kBase64InverseTable;
 class HPackParser::Input {
  public:
   Input(grpc_slice_refcount* current_slice_refcount, const uint8_t* begin,
-        const uint8_t* end, absl::BitGenRef bitsrc,
-        HpackParseResult& frame_error, HpackParseResult& field_error)
+        const uint8_t* end, absl::BitGenRef bitsrc, HpackParseResult& error)
       : current_slice_refcount_(current_slice_refcount),
         begin_(begin),
         end_(end),
         frontier_(begin),
-        frame_error_(frame_error),
-        field_error_(field_error),
+        error_(error),
         bitsrc_(bitsrc) {}
 
   // If input is backed by a slice, retrieve its refcount. If not, return
@@ -197,7 +195,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
@@ -208,7 +206,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;
@@ -218,24 +216,20 @@ class HPackParser::Input {
 
   // Check if we saw an EOF
   bool eof_error() const {
-    return min_progress_size_ != 0 || frame_error_.connection_error();
-  }
-
-  // Reset the field error to be ok
-  void ClearFieldError() {
-    if (field_error_.ok()) return;
-    field_error_ = HpackParseResult();
+    return min_progress_size_ != 0 || error_.connection_error();
   }
 
   // Minimum number of bytes to unstuck the current parse
   size_t min_progress_size() const { return min_progress_size_; }
 
+  bool has_error() const { return !error_.ok(); }
+
   // Set the current error - tweaks the error to include a stream id so that
   // chttp2 does not close the connection.
   // 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));
   }
 
@@ -243,7 +237,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_;
   }
@@ -252,17 +246,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);
-    if (eof_error()) return;
+    CHECK_GT(min_progress_size, 0u);
+    if (min_progress_size_ != 0 || error_.connection_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_;
   }
 
@@ -306,18 +303,13 @@ class HPackParser::Input {
   // Do not use this directly, instead use SetErrorAndContinueParsing or
   // SetErrorAndStopParsing.
   void SetError(HpackParseResult error) {
-    SetErrorFor(frame_error_, error);
-    SetErrorFor(field_error_, std::move(error));
-  }
-
-  void SetErrorFor(HpackParseResult& error, HpackParseResult new_error) {
-    if (!error.ok() || min_progress_size_ > 0) {
-      if (new_error.connection_error() && !error.connection_error()) {
-        error = std::move(new_error);  // connection errors dominate
+    if (!error_.ok() || min_progress_size_ > 0) {
+      if (error.connection_error() && !error_.connection_error()) {
+        error_ = std::move(error);  // connection errors dominate
       }
       return;
     }
-    error = std::move(new_error);
+    error_ = std::move(error);
   }
 
   // Refcount if we are backed by a slice
@@ -329,8 +321,7 @@ class HPackParser::Input {
   // Frontier denotes the first byte past successfully processed input
   const uint8_t* frontier_;
   // Current error
-  HpackParseResult& frame_error_;
-  HpackParseResult& field_error_;
+  HpackParseResult& error_;
   // If the error was EOF, we flag it here by noting how many more bytes would
   // be needed to make progress
   size_t min_progress_size_ = 0;
@@ -385,7 +376,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();
@@ -605,9 +596,8 @@ class HPackParser::Parser {
 
  private:
   bool ParseTop() {
-    GPR_DEBUG_ASSERT(state_.parse_state == ParseState::kTop);
+    DCHECK(state_.parse_state == ParseState::kTop);
     auto cur = *input_->Next();
-    input_->ClearFieldError();
     switch (cur >> 4) {
         // Literal header not indexed - First byte format: 0000xxxx
         // Literal header never indexed - First byte format: 0001xxxx
@@ -713,7 +703,7 @@ class HPackParser::Parser {
         break;
     }
     gpr_log(
-        GPR_INFO, "HTTP:%d:%s:%s: %s%s", log_info_.stream_id, type,
+        GPR_DEBUG, "HTTP:%d:%s:%s: %s%s", log_info_.stream_id, type,
         log_info_.is_client ? "CLI" : "SVR", memento.md.DebugString().c_str(),
         memento.parse_status == nullptr
             ? ""
@@ -776,7 +766,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)) {
@@ -792,14 +782,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();
@@ -834,7 +824,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;
@@ -855,14 +845,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(
@@ -902,7 +892,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;
@@ -910,7 +900,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;
@@ -920,7 +910,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;
@@ -931,7 +921,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;
@@ -955,17 +945,18 @@ 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,
                                   state_.string_length)
             : String::Parse(input_, state_.is_string_huff_compressed,
                             state_.string_length);
+    HpackParseResult& status = state_.frame_error;
     absl::string_view key_string;
     if (auto* s = absl::get_if<Slice>(&state_.key)) {
       key_string = s->as_string_view();
-      if (state_.field_error.ok()) {
+      if (status.ok()) {
         auto r = ValidateKey(key_string);
         if (r != ValidateMetadataResult::kOk) {
           input_->SetErrorAndContinueParsing(
@@ -975,7 +966,7 @@ class HPackParser::Parser {
     } else {
       const auto* memento = absl::get<const HPackTable::Memento*>(state_.key);
       key_string = memento->md.key();
-      if (state_.field_error.ok() && memento->parse_status != nullptr) {
+      if (status.ok() && memento->parse_status != nullptr) {
         input_->SetErrorAndContinueParsing(*memento->parse_status);
       }
     }
@@ -983,7 +974,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 =
@@ -1002,16 +993,16 @@ class HPackParser::Parser {
         key_string.size() + value.wire_size + hpack_constants::kEntryOverhead;
     auto md = grpc_metadata_batch::Parse(
         key_string, std::move(value_slice), state_.add_to_table, transport_size,
-        [key_string, this](absl::string_view message, const Slice&) {
-          if (!state_.field_error.ok()) return;
+        [key_string, &status, this](absl::string_view message, const Slice&) {
+          if (!status.ok()) return;
           input_->SetErrorAndContinueParsing(
               HpackParseResult::MetadataParseError(key_string));
           gpr_log(GPR_ERROR, "Error parsing '%s' metadata: %s",
                   std::string(key_string).c_str(),
                   std::string(message).c_str());
         });
-    HPackTable::Memento memento{
-        std::move(md), state_.field_error.PersistentStreamErrorOrNullptr()};
+    HPackTable::Memento memento{std::move(md),
+                                status.PersistentStreamErrorOrNullptr()};
     input_->UpdateFrontier();
     state_.parse_state = ParseState::kTop;
     if (state_.add_to_table) {
@@ -1124,13 +1115,13 @@ grpc_error_handle HPackParser::Parse(
     std::vector<uint8_t> buffer = std::move(unparsed_bytes_);
     return ParseInput(
         Input(nullptr, buffer.data(), buffer.data() + buffer.size(), bitsrc,
-              state_.frame_error, state_.field_error),
+              state_.frame_error),
         is_last, call_tracer);
   }
-  return ParseInput(Input(slice.refcount, GRPC_SLICE_START_PTR(slice),
-                          GRPC_SLICE_END_PTR(slice), bitsrc, state_.frame_error,
-                          state_.field_error),
-                    is_last, call_tracer);
+  return ParseInput(
+      Input(slice.refcount, GRPC_SLICE_START_PTR(slice),
+            GRPC_SLICE_END_PTR(slice), bitsrc, state_.frame_error),
+      is_last, call_tracer);
 }
 
 grpc_error_handle HPackParser::ParseInput(

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,6 +34,7 @@
 #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"
@@ -236,8 +235,6 @@ class HPackParser {
     HPackTable hpack_table;
     // Error so far for this frame (set by class Input)
     HpackParseResult frame_error;
-    // Error so far for this field (set by class Input)
-    HpackParseResult field_error;
     // Length of frame so far.
     uint32_t frame_length = 0;
     // Length of the string being parsed

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,11 +25,13 @@
 #include <cstring>
 #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 <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"
@@ -42,7 +42,7 @@
 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 +53,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 +91,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();
 }
 

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,12 +18,12 @@
 // 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"

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,6 +25,8 @@
 #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"

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

@@ -12,8 +12,8 @@
 // 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/http_trace.h"
 
+#include <grpc/support/port_platform.h>
+
 grpc_core::TraceFlag grpc_http_trace(false, "http");

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

@@ -16,10 +16,10 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/ext/transport/chttp2/transport/huffsyms.h"
 
+#include <grpc/support/port_platform.h>
+
 // Constants pulled from the HPACK spec, and converted to C using the vim
 // command:
 // :%s/.*   \([0-9a-f]\+\)  \[ *\([0-9]\+\)\]/{0x\1, \2},/g

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

@@ -19,8 +19,6 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 #include <stdint.h>
 
@@ -39,8 +37,10 @@
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/grpc.h>
 #include <grpc/slice.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
+#include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/context_list_entry.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/frame_goaway.h"
@@ -59,7 +59,6 @@
 #include "src/core/ext/transport/chttp2/transport/write_size_policy.h"
 #include "src/core/lib/channel/call_tracer.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/channel/tcp_tracer.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/bitset.h"
@@ -224,18 +223,19 @@ typedef enum {
   GRPC_CHTTP2_KEEPALIVE_STATE_DISABLED,
 } grpc_chttp2_keepalive_state;
 
-struct grpc_chttp2_transport final
-    : public grpc_core::Transport,
-      public grpc_core::FilterStackTransport,
-      public grpc_core::RefCounted<grpc_chttp2_transport,
-                                   grpc_core::NonPolymorphicRefCount>,
-      public grpc_core::KeepsGrpcInitialized {
+struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
+                                     public grpc_core::KeepsGrpcInitialized {
   grpc_chttp2_transport(const grpc_core::ChannelArgs& channel_args,
                         grpc_endpoint* ep, bool is_client);
   ~grpc_chttp2_transport() override;
 
   void Orphan() override;
 
+  grpc_core::RefCountedPtr<grpc_chttp2_transport> Ref() {
+    return grpc_core::FilterStackTransport::RefAsSubclass<
+        grpc_chttp2_transport>();
+  }
+
   size_t SizeOfStream() const override;
   bool HackyDisableStreamOpBatchCoalescingInConnectedChannel() const override;
   void PerformStreamOp(grpc_stream* gs,

data/src/core/ext/transport/chttp2/transport/max_concurrent_streams_policy.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/ext/transport/chttp2/transport/max_concurrent_streams_policy.h"
 
 #include <utility>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 
@@ -32,7 +33,7 @@ void Chttp2MaxConcurrentStreamsPolicy::FlushedSettings() {
 }
 
 void Chttp2MaxConcurrentStreamsPolicy::AckLastSend() {
-  GPR_ASSERT(unacked_demerits_ >= sent_demerits_);
+  CHECK(unacked_demerits_ >= sent_demerits_);
   unacked_demerits_ -= std::exchange(sent_demerits_, 0);
 }
 

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

@@ -15,11 +15,11 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_MAX_CONCURRENT_STREAMS_POLICY_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_MAX_CONCURRENT_STREAMS_POLICY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <cstdint>
 #include <limits>
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 class Chttp2MaxConcurrentStreamsPolicy {