grpc 1.75.0 → 1.78.1

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

@@ -0,0 +1,128 @@
+//
+//
+// Copyright 2025 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INCOMING_METADATA_TRACKER_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INCOMING_METADATA_TRACKER_H
+
+#include <cstdint>
+#include <string>
+
+#include "src/core/call/metadata_info.h"
+#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/strings/str_cat.h"
+
+namespace grpc_core {
+namespace http2 {
+
+class IncomingMetadataTracker {
+  // Manages transport-wide state for incoming HEADERS and CONTINUATION frames.
+  // RFC 9113 (Section 6.10) requires that if a HEADERS frame does not have
+  // END_HEADERS set, it must be followed by a contiguous sequence of
+  // CONTINUATION frames for the same stream, ending with END_HEADERS. No other
+  // frame types or frames for other streams may be interleaved during this
+  // sequence. This constraint makes tracking header sequence state a
+  // transport-level concern, as only one stream can be receiving headers at
+  // a time. This class is distinct from HeaderAssembler, which buffers header
+  // payloads on a per-stream basis.
+ public:
+  IncomingMetadataTracker() = default;
+  ~IncomingMetadataTracker() = default;
+
+  IncomingMetadataTracker(IncomingMetadataTracker&& rvalue) = delete;
+  IncomingMetadataTracker& operator=(IncomingMetadataTracker&& rvalue) = delete;
+  IncomingMetadataTracker(const IncomingMetadataTracker&) = delete;
+  IncomingMetadataTracker& operator=(const IncomingMetadataTracker&) = delete;
+
+  void set_soft_limit(uint32_t limit) {
+    max_header_list_size_soft_limit_ = limit;
+  }
+  uint32_t soft_limit() const { return max_header_list_size_soft_limit_; }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Writing Header and Continuation State
+
+  // Called when a HEADER frame is received.
+  void OnHeaderReceived(const Http2HeaderFrame& frame) {
+    GRPC_CHECK(!incoming_header_in_progress_);
+    incoming_header_in_progress_ = !frame.end_headers;
+    incoming_header_stream_id_ = frame.stream_id;
+    incoming_header_end_stream_ = frame.end_stream;
+  }
+
+  // Called when a CONTINUATION frame is received.
+  void OnContinuationReceived(const Http2ContinuationFrame& frame) {
+    GRPC_CHECK(incoming_header_in_progress_);
+    GRPC_CHECK_EQ(frame.stream_id, incoming_header_stream_id_);
+    incoming_header_in_progress_ = !frame.end_headers;
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Reading Header and Continuation State
+
+  // Returns true if we are in the middle of receiving a header block
+  // (i.e., HEADERS without END_HEADERS was received, and we are waiting for
+  // CONTINUATION frames).
+  bool IsWaitingForContinuationFrame() const {
+    return incoming_header_in_progress_;
+  }
+
+  // Returns true if end_stream was set in the received header.
+  bool HeaderHasEndStream() const { return incoming_header_end_stream_; }
+
+  // Returns stream id of stream for which headers are being received.
+  uint32_t GetStreamId() const { return incoming_header_stream_id_; }
+
+  bool ClientReceivedDuplicateMetadata(
+      const bool did_receive_initial_metadata,
+      const bool did_receive_trailing_metadata) const {
+    const bool is_duplicate_initial_metadata =
+        !incoming_header_end_stream_ && did_receive_initial_metadata;
+    const bool is_duplicate_trailing_metadata =
+        incoming_header_end_stream_ && did_receive_trailing_metadata;
+    return is_duplicate_initial_metadata || is_duplicate_trailing_metadata;
+  }
+
+  bool ServerReceivedDuplicateMetadata(
+      const bool did_receive_initial_metadata) const {
+    // TODO(tjagtap) : [PH2][P2] : Verify this when implementing Server.
+    // Also write a small unit test for it.
+    return !incoming_header_end_stream_ && did_receive_initial_metadata;
+  }
+
+  std::string DebugString() const {
+    return absl::StrCat(
+        "{ incoming_header_in_progress : ",
+        incoming_header_in_progress_ ? "true" : "false",
+        ", incoming_header_end_stream : ",
+        incoming_header_end_stream_ ? "true" : "false",
+        ", incoming_header_stream_id : ", incoming_header_stream_id_, "}");
+  }
+
+ private:
+  bool incoming_header_in_progress_ = false;
+  bool incoming_header_end_stream_ = false;
+  uint32_t incoming_header_stream_id_ = 0;
+  uint32_t max_header_list_size_soft_limit_ =
+      DEFAULT_MAX_HEADER_LIST_SIZE_SOFT_LIMIT;
+};
+
+}  // namespace http2
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INCOMING_METADATA_TRACKER_H

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

@@ -34,10 +34,6 @@
 #include <utility>
 #include <variant>
 
-#include "absl/container/flat_hash_map.h"
-#include "absl/random/random.h"
-#include "absl/status/status.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
@@ -68,6 +64,7 @@
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
+#include "src/core/lib/resource_quota/stream_quota.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/init_internally.h"
@@ -83,6 +80,10 @@
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/time.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/random/random.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
 
 // Flag that this closure barrier may be covering a write in a pollset, and so
 //   we should not complete this closure until we can prove that the write got
@@ -115,6 +116,7 @@ typedef enum {
   GRPC_CHTTP2_WRITE_STATE_WRITING_WITH_MORE,
 } grpc_chttp2_write_state;
 
+// Not getting used anywhere AFAIK
 typedef enum {
   GRPC_CHTTP2_OPTIMIZE_FOR_LATENCY,
   GRPC_CHTTP2_OPTIMIZE_FOR_THROUGHPUT,
@@ -238,7 +240,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
    public:
     explicit ChannelzDataSource(grpc_chttp2_transport* transport)
         : grpc_core::channelz::DataSource(transport->channelz_socket),
-          transport_(transport) {
+          transport_(transport->Ref()) {  // Take a ref
       SourceConstructed();
     }
     ~ChannelzDataSource() { SourceDestructing(); }
@@ -248,7 +250,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
         absl::string_view name) override;
 
    private:
-    grpc_chttp2_transport* transport_;
+    grpc_core::RefCountedPtr<grpc_chttp2_transport> transport_;
   };
 
   void Orphan() override;
@@ -287,6 +289,19 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   void WriteSecurityFrame(grpc_core::SliceBuffer* data);
   void WriteSecurityFrameLocked(grpc_core::SliceBuffer* data);
 
+  void StartWatch(grpc_core::RefCountedPtr<StateWatcher> watcher) override;
+  void StopWatch(grpc_core::RefCountedPtr<StateWatcher> watcher) override;
+
+  void NotifyStateWatcherOnDisconnectLocked(
+      absl::Status status, StateWatcher::DisconnectInfo disconnect_info);
+
+  void OnPeerMaxConcurrentStreamsUpdateComplete();
+  void MaybeNotifyStateWatcherOfPeerMaxConcurrentStreamsLocked();
+  void NotifyStateWatcherOnPeerMaxConcurrentStreamsUpdateLocked();
+
+  void MaybeNotifyOnReceiveSettingsLocked(
+      absl::StatusOr<uint32_t> max_concurrent_streams);
+
   // We depend on the ep being available for the life of the transport in
   // at least one place - event callback in WriteEventSink. Hence, this should
   // only be orphaned in the destructor.
@@ -301,6 +316,8 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   grpc_core::MemoryOwner memory_owner;
   const grpc_core::MemoryAllocator::Reservation self_reservation;
   grpc_core::ReclamationSweep active_reclamation;
+  grpc_core::InstrumentStorageRefPtr<grpc_core::ResourceQuotaDomain>
+      resource_quota_telemetry_storage;
 
   std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine;
   grpc_core::Combiner* combiner;
@@ -313,7 +330,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   // starts a connectivity watch.
   grpc_pollset_set* interested_parties_until_recv_settings = nullptr;
 
-  grpc_closure* notify_on_receive_settings = nullptr;
+  absl::AnyInvocable<void(absl::StatusOr<uint32_t>)> notify_on_receive_settings;
   grpc_closure* notify_on_close = nullptr;
 
   /// has the upper layer closed the transport?
@@ -372,7 +389,12 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
       void* user_data, grpc_core::ServerMetadata* metadata) = nullptr;
   void* accept_stream_cb_user_data;
 
+  // There should be only a single watcher in use at any given time.
+  grpc_core::RefCountedPtr<StateWatcher> watcher;
+  uint32_t last_reported_max_concurrent_streams;
+  bool max_concurrent_streams_notification_in_flight;
   /// connectivity tracking
+  // TODO(roth): Get rid of this in favor of the new state watcher.
   grpc_core::ConnectivityStateTracker state_tracker;
 
   /// data to write now
@@ -590,6 +612,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
 
   std::shared_ptr<grpc_core::Http2StatsCollector> http2_stats;
   grpc_core::Http2ZTraceCollector http2_ztrace_collector;
+  grpc_core::Timestamp last_ztrace_time = grpc_core::Timestamp::InfPast();
 
   GPR_NO_UNIQUE_ADDRESS grpc_core::latent_see::Flow write_flow;
 };
@@ -714,7 +737,7 @@ struct grpc_chttp2_stream {
   // annotations as soon as we have parsed initial metadata, but in our legacy
   // stack, we create the stream before parsing headers. In the new v3 stack,
   // that won't be an issue.
-  grpc_core::CallTracerInterface* call_tracer = nullptr;
+  grpc_core::CallTracer* call_tracer = nullptr;
   // TODO(yashykt): Remove this once call_tracer_transport_fix is rolled out
   grpc_core::CallTracerAnnotationInterface* parent_call_tracer = nullptr;
 
@@ -740,17 +763,6 @@ struct grpc_chttp2_stream {
       grpc_core::Timestamp::InfPast();
 };
 
-// EXPERIMENTAL: provide protection against overloading a server with too many
-// requests: wait for streams to be deallocated before they stop counting
-// against MAX_CONCURRENT_STREAMS
-#define GRPC_ARG_MAX_CONCURRENT_STREAMS_OVERLOAD_PROTECTION \
-  "grpc.http.overload_protection"
-
-// EXPERIMENTAL: Fail requests at the client if the client is over max
-// concurrent streams, so they may be retried elsewhere.
-#define GRPC_ARG_MAX_CONCURRENT_STREAMS_REJECT_ON_CLIENT \
-  "grpc.http.max_concurrent_streams_reject_on_client"
-
 /// Transport writing call flow:
 /// grpc_chttp2_initiate_write() is called anywhere that we know bytes need to
 /// go out on the wire.

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

@@ -17,21 +17,28 @@
 //
 #include "src/core/ext/transport/chttp2/transport/keepalive.h"
 
+#include <utility>
+
 #include "src/core/lib/promise/all_ok.h"
 #include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/loop.h"
+#include "src/core/lib/promise/party.h"
 #include "src/core/lib/promise/race.h"
 #include "src/core/lib/promise/sleep.h"
 #include "src/core/lib/promise/try_seq.h"
+#include "src/core/util/grpc_check.h"
+#include "src/core/util/time.h"
 
 namespace grpc_core {
 namespace http2 {
 KeepaliveManager::KeepaliveManager(
     std::unique_ptr<KeepAliveInterface> keep_alive_interface,
-    Duration keepalive_timeout, const Duration keepalive_time)
+    Duration keepalive_timeout, const Duration keepalive_time, Party* party)
     : keep_alive_interface_(std::move(keep_alive_interface)),
       keepalive_timeout_(keepalive_timeout),
-      keepalive_time_(keepalive_time) {}
+      keepalive_time_(keepalive_time) {
+  MaybeSpawnKeepaliveLoop(party);
+}
 
 auto KeepaliveManager::WaitForKeepAliveTimeout() {
   return AssertResultType<absl::Status>(
@@ -59,8 +66,8 @@ auto KeepaliveManager::WaitForKeepAliveTimeout() {
       }));
 }
 auto KeepaliveManager::TimeoutAndSendPing() {
-  DCHECK(!data_received_in_last_cycle_);
-  DCHECK(keepalive_timeout_ != Duration::Infinity());
+  GRPC_DCHECK(!data_received_in_last_cycle_);
+  GRPC_DCHECK(keepalive_timeout_ != Duration::Infinity());
 
   return AllOk<absl::Status>(Race(WaitForData(), WaitForKeepAliveTimeout()),
                              SendPingAndWaitForAck());
@@ -83,7 +90,7 @@ auto KeepaliveManager::MaybeSendKeepAlivePing() {
              }));
 }
 
-void KeepaliveManager::Spawn(Party* party) {
+void KeepaliveManager::MaybeSpawnKeepaliveLoop(Party* party) {
   if (!IsKeepAliveNeeded()) {
     GRPC_HTTP2_KEEPALIVE_LOG << "Not spawning keepalive loop.";
     return;

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

@@ -18,9 +18,10 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_KEEPALIVE_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_KEEPALIVE_H
 
-#include "absl/status/status.h"
 #include "src/core/lib/promise/party.h"
 #include "src/core/lib/promise/promise.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/status/status.h"
 
 namespace grpc_core {
 namespace http2 {
@@ -44,11 +45,8 @@ class KeepAliveInterface {
 class KeepaliveManager {
  public:
   KeepaliveManager(std::unique_ptr<KeepAliveInterface> keep_alive_interface,
-                   Duration keepalive_timeout, Duration keepalive_time);
-
-  // Spawns the keepalive loop on the given party. This MUST be called at most
-  // once during the lifetime of the keepalive manager.
-  void Spawn(Party* party);
+                   Duration keepalive_timeout, Duration keepalive_time,
+                   Party* party);
 
   // Needs to be called when any data is read from the endpoint.
   void GotData() {
@@ -69,6 +67,10 @@ class KeepaliveManager {
   }
 
  private:
+  // Spawns the keepalive loop on the given party. This MUST be called at most
+  // once during the lifetime of the keepalive manager.
+  void MaybeSpawnKeepaliveLoop(Party* party);
+
   // Returns a promise that sleeps for the keepalive_timeout_ and triggers the
   // keepalive timeout unless data is read within the keepalive timeout.
   auto WaitForKeepAliveTimeout();
@@ -104,7 +106,7 @@ class KeepaliveManager {
     };
   }
   auto SendPingAndWaitForAck() {
-    DCHECK_EQ(data_received_in_last_cycle_, false);
+    GRPC_DCHECK_EQ(data_received_in_last_cycle_, false);
     return keep_alive_interface_->SendPingAndWaitForAck();
   }
 
@@ -121,10 +123,12 @@ class KeepaliveManager {
   }
 
   std::unique_ptr<KeepAliveInterface> keep_alive_interface_;
-  // If the keepalive_timeout_ is set to infinity, then the timeout is dictated
-  // by the ping timeout. Otherwise, this field can be used to set a specific
-  // timeout for keepalive pings.
+  // Duration to wait before triggering a keepalive timeout. If the
+  // keepalive_timeout_ is set to infinity, then the timeout is dictated by the
+  // ping timeout. Otherwise, this field can be used to set a specific timeout
+  // for keepalive pings.
   Duration keepalive_timeout_;
+  // Duration between two consecutive keepalive pings.
   const Duration keepalive_time_;
   bool data_received_in_last_cycle_ = false;
   bool keep_alive_timeout_triggered_ = false;

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

@@ -19,21 +19,26 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_MESSAGE_ASSEMBLER_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_MESSAGE_ASSEMBLER_H
 
+#include <grpc/support/port_platform.h>
+
 #include <cstdint>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "src/core/call/message.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/lib/resource_quota/arena.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/ref_counted_ptr.h"
+#include "absl/log/log.h"
 
 namespace grpc_core {
 namespace http2 {
 
+#define GRPC_MESSAGE_ASSEMBLER_DEBUG VLOG(2)
+
 // TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
 // assembler and disassembler code
 
@@ -53,7 +58,7 @@ class GrpcMessageAssembler {
   // This function will move the payload into an internal buffer.
   Http2Status AppendNewDataFrame(SliceBuffer& payload,
                                  const bool is_end_stream) {
-    DCHECK(!is_end_stream_)
+    GRPC_DCHECK(!is_end_stream_)
         << "Calling this function when a previous frame was marked as the last "
            "frame does not make sense.";
     is_end_stream_ = is_end_stream;
@@ -66,7 +71,7 @@ class GrpcMessageAssembler {
       }
     }
     payload.MoveFirstNBytesIntoSliceBuffer(payload.Length(), message_buffer_);
-    DCHECK_EQ(payload.Length(), 0u);
+    GRPC_DCHECK_EQ(payload.Length(), 0u);
     return Http2Status::Ok();
   }
 
@@ -79,15 +84,21 @@ class GrpcMessageAssembler {
       // TODO(tjagtap) : [PH2][P3] : Write a test for this.
       return ReturnNullOrError();
     }
-    GrpcMessageHeader header = ExtractGrpcHeader(message_buffer_);
+    ValueOrHttp2Status<GrpcMessageHeader> header =
+        ExtractGrpcHeader(message_buffer_);
+    if (!header.IsOk()) {
+      return header.TakeStatus(std::move(header));
+    }
+    const uint32_t header_length = header.value().length;
+
     if constexpr (sizeof(size_t) == 4) {
-      if (GPR_UNLIKELY(header.length > kOneGb)) {
+      if (GPR_UNLIKELY(header_length > kOneGb)) {
         return Http2Status::Http2StreamError(
             Http2ErrorCode::kInternalError,
             "Stream Error: SliceBuffer overflow for 32 bit platforms.");
       }
     }
-    if (GPR_LIKELY(current_len - kGrpcHeaderSizeInBytes >= header.length)) {
+    if (GPR_LIKELY(current_len - kGrpcHeaderSizeInBytes >= header_length)) {
       SliceBuffer discard;
       message_buffer_.MoveFirstNBytesIntoSliceBuffer(kGrpcHeaderSizeInBytes,
                                                      discard);
@@ -98,9 +109,8 @@ class GrpcMessageAssembler {
       // bounds.
       MessageHandle grpc_message = Arena::MakePooled<Message>();
       message_buffer_.MoveFirstNBytesIntoSliceBuffer(
-          header.length, *(grpc_message->payload()));
-      uint32_t& flag = grpc_message->mutable_flags();
-      flag = header.flags;
+          header_length, *(grpc_message->payload()));
+      grpc_message->mutable_flags() = header.value().flags;
       return std::move(grpc_message);
     }
     return ReturnNullOrError();
@@ -112,21 +122,18 @@ class GrpcMessageAssembler {
       return Http2Status::Http2StreamError(Http2ErrorCode::kInternalError,
                                            "Incomplete gRPC frame received");
     }
-    VLOG(2) << "Incomplete gRPC message received. Return nullptr";
+    GRPC_MESSAGE_ASSEMBLER_DEBUG
+        << "Incomplete gRPC message received. Return nullptr";
     return ValueOrHttp2Status<MessageHandle>(nullptr);
   }
+
   bool is_end_stream_ = false;
   SliceBuffer message_buffer_;
 };
 
-constexpr uint32_t kMaxMessageBatchSize = (16 * 1024u);
-
 // This class is meant to convert gRPC Messages into Http2DataFrame ensuring
 // that the payload size of the data frame is configurable.
-// This class is not responsible for queueing or backpressure. That will be done
-// by other classes.
-// TODO(tjagtap) : [PH2][P2] Edit comment once this
-// class is integrated and exercised.
+// This class is not responsible for queueing or backpressure.
 class GrpcMessageDisassembler {
  public:
   // One GrpcMessageDisassembler instance MUST be associated with one stream
@@ -135,15 +142,17 @@ class GrpcMessageDisassembler {
 
   // GrpcMessageDisassembler object will take ownership of the message.
   void PrepareSingleMessageForSending(MessageHandle message) {
-    DCHECK_EQ(GetBufferedLength(), 0u);
+    GRPC_DCHECK_EQ(GetBufferedLength(), 0u);
     PrepareMessageForSending(std::move(message));
   }
 
   // GrpcMessageDisassembler object will take ownership of the message.
   void PrepareBatchedMessageForSending(MessageHandle message) {
+    // The size of the message is controlled by the application (and by using
+    // GRPC_ARG_MAX_SEND_MESSAGE_LENGTH). PH2 ensures that if the the message
+    // size is larger than the default stream queue size kStreamQueueSize, at
+    // max one message will be buffered in the disassembler.
     PrepareMessageForSending(std::move(message));
-    DCHECK_LE(GetBufferedLength(), kMaxMessageBatchSize)
-        << "Avoid batches larger than " << kMaxMessageBatchSize << "bytes";
   }
 
   size_t GetBufferedLength() const { return message_.Length(); }
@@ -152,8 +161,8 @@ class GrpcMessageDisassembler {
   Http2DataFrame GenerateNextFrame(const uint32_t stream_id,
                                    const uint32_t max_length,
                                    const bool is_end_stream = false) {
-    DCHECK_GT(max_length, 0u);
-    DCHECK_GT(GetBufferedLength(), 0u);
+    GRPC_DCHECK_GT(max_length, 0u);
+    GRPC_DCHECK_GT(GetBufferedLength(), 0u);
     SliceBuffer temp;
     const uint32_t current_length =
         message_.Length() >= max_length ? max_length : message_.Length();

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

@@ -31,15 +31,6 @@
 #include <utility>
 #include <variant>
 
-#include "absl/base/attributes.h"
-#include "absl/container/flat_hash_map.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/random/bit_gen_ref.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
@@ -73,10 +64,19 @@
 #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/random_early_detection.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/status_helper.h"
+#include "absl/base/attributes.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/log/log.h"
+#include "absl/random/bit_gen_ref.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
 
 using grpc_core::HPackParser;
 using grpc_core::http2::Http2ErrorCode;
@@ -274,7 +274,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_0:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_frame_size = (static_cast<uint32_t>(*cur)) << 16;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_1;
@@ -282,7 +282,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_1:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_frame_size |= (static_cast<uint32_t>(*cur)) << 8;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_2;
@@ -290,7 +290,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_2:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_frame_size |= *cur;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_3;
@@ -298,7 +298,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_3:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_frame_type = *cur;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_4;
@@ -306,7 +306,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_4:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_frame_flags = *cur;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_5;
@@ -314,7 +314,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_5:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_stream_id = ((static_cast<uint32_t>(*cur)) & 0x7f) << 24;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_6;
@@ -322,7 +322,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_6:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur)) << 16;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_7;
@@ -330,7 +330,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_7:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur)) << 8;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_8;
@@ -338,7 +338,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_8:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur));
       GRPC_TRACE_LOG(http, INFO)
           << "INCOMING[" << t << "]: "
@@ -372,7 +372,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FRAME:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       if (static_cast<uint32_t>(end - cur) == t->incoming_frame_size) {
         err = parse_frame_slice(
             t,
@@ -671,10 +671,12 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                         nullptr, &t->http2_ztrace_collector));
       grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
-    } else if (GPR_UNLIKELY(t->memory_owner.IsMemoryPressureHigh())) {
+    } else if (GPR_UNLIKELY(
+                   t->memory_owner.RejectNewStreamsUnderHighMemoryPressure())) {
       // We have more streams allocated than we'd like, so apply some pushback
       // by refusing this stream.
-      grpc_core::global_stats().IncrementRqCallsRejected();
+      t->memory_owner.telemetry_storage()->Increment(
+          grpc_core::ResourceQuotaDomain::kCallsRejected);
       ++t->num_pending_induced_frames;
       grpc_slice_buffer_add(
           &t->qbuf, grpc_chttp2_rst_stream_create(
@@ -766,7 +768,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
   } else {
     t->incoming_stream = s;
   }
-  DCHECK_NE(s, nullptr);
+  GRPC_DCHECK_NE(s, nullptr);
   s->call_tracer_wrapper.RecordIncomingBytes({9, 0, 0});
   if (GPR_UNLIKELY(s->read_closed)) {
     GRPC_CHTTP2_IF_TRACING(ERROR)
@@ -976,7 +978,7 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
                                                   const grpc_slice& slice,
                                                   int is_last) {
   auto* parser = static_cast<grpc_core::HPackParser*>(hpack_parser);
-  grpc_core::CallTracerAnnotationInterface* call_tracer = nullptr;
+  grpc_core::CallSpan* call_tracer = nullptr;
   if (s != nullptr) {
     s->call_tracer_wrapper.RecordIncomingBytes(
         {0, 0, GRPC_SLICE_LENGTH(slice)});