grpc 1.81.1 → 1.85.0

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

@@ -19,24 +19,45 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_TRANSPORT_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_TRANSPORT_H
 
+#include <grpc/event_engine/event_engine.h>
+
+#include <algorithm>
 #include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <queue>
 #include <string>
 #include <type_traits>
+#include <utility>
+#include <variant>
+#include <vector>
 
+#include "src/core/call/metadata.h"
 #include "src/core/channelz/channelz.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
-#include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/ext/transport/chttp2/transport/stream.h"
 #include "src/core/ext/transport/chttp2/transport/write_cycle.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/promise/activity.h"
-#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/for_each.h"
+#include "src/core/lib/promise/if.h"
+#include "src/core/lib/promise/latch.h"
+#include "src/core/lib/promise/loop.h"
+#include "src/core/lib/promise/mpsc.h"
+#include "src/core/lib/promise/sleep.h"
+#include "src/core/lib/promise/status_flag.h"
+#include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/sync.h"
+#include "src/core/util/time.h"
 #include "absl/log/log.h"
-#include "absl/status/status.h"
 
 namespace grpc_core {
 namespace http2 {
@@ -45,8 +66,8 @@ namespace http2 {
 // and it is functions. The code will be written iteratively.
 // Do not use or edit any of these functions unless you are
 // familiar with the PH2 project (Moving chttp2 to promises.)
-// TODO(tjagtap) : [PH2][P3] : Update the experimental status of the code before
-// http2 rollout begins.
+// TODO(tjagtap) : [PH2][P3] : Update the experimental status of the code when
+// CHTTP2 is deleted.
 
 #define GRPC_HTTP2_CLIENT_DLOG \
   DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
@@ -67,55 +88,22 @@ struct CloseStreamArgs {
   bool close_writes;
 };
 
-// TODO(akshitpatel) [PH2][P3] : Write a way to measure the total size of a
+inline bool ShouldEnablePh2Client() {
+  return IsPh2ClientEnabled() || IsPh2ClientServerEnabled();
+}
+
+inline bool ShouldEnablePh2Server() {
+  return IsPh2ServerEnabled() || IsPh2ClientServerEnabled();
+}
+
+// TODO(akshitpatel) [PH2][P5] : Write a way to measure the total size of a
 // transport object. Reference :
 // https://github.com/grpc/grpc/pull/41294/files#diff-c685cc4847f228327938326e2a45083a2d0845bacff0ac004bd802027a670c4e
 
 ///////////////////////////////////////////////////////////////////////////////
 // Read and Write helpers
 
-class Http2ReadContext {
- public:
-  Http2ReadContext() = default;
-  Http2ReadContext(const Http2ReadContext&) = delete;
-  Http2ReadContext& operator=(const Http2ReadContext&) = delete;
-  Http2ReadContext(Http2ReadContext&&) = delete;
-  Http2ReadContext& operator=(Http2ReadContext&&) = delete;
-
-  // Signals that the read loop should pause. If it's already paused, this is a
-  // no-op.
-  void SetPauseReadLoop() {
-    // TODO(tjagtap) [PH2][P2][Settings] Plumb with when we receive urgent
-    // settings. Example - initial window size 0 is urgent because it indicates
-    // extreme memory pressure on the server.
-    should_pause_read_loop_ = true;
-  }
-
-  // If SetPauseReadLoop() was called, this returns Pending and
-  // registers a waker that will be woken by WakeReadLoop().
-  // If SetPauseReadLoop() was not called, this returns OkStatus.
-  // This should be polled by the read loop to yield control when requested.
-  Poll<absl::Status> MaybePauseReadLoop() {
-    if (should_pause_read_loop_) {
-      read_loop_waker_ = GetContext<Activity>()->MakeNonOwningWaker();
-      return Pending{};
-    }
-    return absl::OkStatus();
-  }
-
-  // If SetPauseReadLoop() was called, resumes it by
-  // waking up the ReadLoop. If not paused, this is a no-op.
-  void ResumeReadLoopIfPaused() {
-    if (should_pause_read_loop_) {
-      should_pause_read_loop_ = false;
-      read_loop_waker_.Wakeup();
-    }
-  }
-
- private:
-  bool should_pause_read_loop_ = false;
-  Waker read_loop_waker_;
-};
+constexpr uint32_t kMaxFramesReadPerReadCycle = 16u * 1024u;  // 16K frames
 
 Http2Status ValidateIncomingConnectionPreface(
     const absl::StatusOr<Slice>& status);
@@ -124,9 +112,9 @@ template <typename T, typename Tracker>
 inline Http2Status ValidateMetadataFrameState(
     T& frame, Stream& stream, Tracker& incoming_headers,
     const uint32_t max_header_list_size) {
-  if (stream.IsStreamHalfClosedRemote()) {
+  if (stream.IsClosedForReads()) {
     return incoming_headers.ParseAndDiscardHeaders(
-        std::move(frame.payload), frame.end_headers, &stream,
+        std::move(frame.payload), frame.end_headers,
         Http2Status::Http2StreamError(
             Http2ErrorCode::kStreamClosed,
             std::string(RFC9113::kHalfClosedRemoteState)),
@@ -138,7 +126,7 @@ inline Http2Status ValidateMetadataFrameState(
             stream.IsInitialMetadataReceived(),
             stream.IsTrailingMetadataReceived())) {
       return incoming_headers.ParseAndDiscardHeaders(
-          std::move(frame.payload), frame.end_headers, &stream,
+          std::move(frame.payload), frame.end_headers,
           Http2Status::Http2StreamError(
               Http2ErrorCode::kInternalError,
               std::string(GrpcErrors::kTooManyMetadata)),
@@ -163,9 +151,10 @@ struct TransportChannelArgs {
   Duration ping_timeout;
   Duration settings_timeout;
   bool keepalive_permit_without_calls;
-  bool enable_preferred_rx_crypto_frame_advertisement;
   // This is used to test peer behaviour when we never send a ping ack.
   bool test_only_ack_pings;
+  // This is only applicable to servers.
+  bool max_concurrent_streams_overload_protection;
   uint32_t max_header_list_size_soft_limit;
   int max_usable_hpack_table_size;
   int initial_sequence_number;
@@ -183,6 +172,15 @@ void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
                                  chttp2::TransportFlowControl& flow_control,
                                  bool is_client);
 
+uint32_t MaxNewStreamsPerRead(const ChannelArgs& channel_args);
+
+uint32_t GetMaxSecurityFrameSize(const ChannelArgs& channel_args);
+
+// Returns the percentage of RST streams on which we should send a ping.
+// Always returns 0 for client transport.
+uint8_t GetPingOnRstStreamPercent(const ChannelArgs& channel_args,
+                                  bool is_client);
+
 ///////////////////////////////////////////////////////////////////////////////
 // ChannelZ helpers
 
@@ -199,7 +197,7 @@ void ProcessOutgoingDataFrameFlowControl(
     uint32_t flow_control_tokens_consumed);
 
 ValueOrHttp2Status<chttp2::FlowControlAction>
-ProcessIncomingDataFrameFlowControl(Http2FrameHeader& frame,
+ProcessIncomingDataFrameFlowControl(const Http2FrameHeader& frame,
                                     chttp2::TransportFlowControl& flow_control,
                                     Stream* stream);
 
@@ -213,7 +211,293 @@ void MaybeAddTransportWindowUpdateFrame(
 
 void MaybeAddStreamWindowUpdateFrame(Stream& stream, FrameSender& frame_sender);
 
+// ===========================================================================
+// 3-Stage Transport Shutdown State Machine
+// ===========================================================================
+// Transport shutdown progresses through three distinct stages to ensure
+// thread-safe, lock-free (where possible), and protocol-compliant cleanup.
 //
+// Stage 1: Shutdown Initiated
+//   Triggered by MaybeSpawnCloseTransport(). Rejects new external watches
+//   and immediately clears stream_list_ (Snapshot 1) to stop read/write
+//   processing for active streams.
+//   Note: MaybeSpawnCloseTransport is invoked from both transport party and
+//   other threads (Orphan flow).
+//
+// Stage 2: Party Shutdown Initiated (Party Lockdown)
+//   Triggered when the CloseTransport promise starts running on the transport
+//   party. Thread-confined to the party (no locks/atomics needed).
+//   Clears stream_list_ again (Snapshot 2) to capture raced streams, and
+//   causes the transport to immediately reject any new or queued streams
+//   (via InitializeStream() on client, or IncomingStream() on server).
+//
+// Stage 3: Shutdown Completed (Final Termination)
+//   Triggered when CloseTransport() finishes (GOAWAY sent or timed out on
+//   client). Wakes up and cancels all remaining promises on the transport
+//   party.
+// ===========================================================================
+class TransportShutdownTracker {
+ public:
+  TransportShutdownTracker() = default;
+
+  // Transport shutdown is not copyable or movable.
+  TransportShutdownTracker(const TransportShutdownTracker&) = delete;
+  TransportShutdownTracker& operator=(const TransportShutdownTracker&) = delete;
+  TransportShutdownTracker(TransportShutdownTracker&&) = delete;
+  TransportShutdownTracker& operator=(TransportShutdownTracker&&) = delete;
+
+  // Stage 1: Shutdown Initiated
+  void InitiateShutdown(const Mutex& mu) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu) {
+    shutdown_initiated_ = true;
+  }
+  bool IsShutdownInitiated(const Mutex& mu) const
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu) {
+    return shutdown_initiated_;
+  }
+
+  // Stage 2: Party Shutdown Initiated (Party Lockdown)
+  void InitiatePartyShutdown() { party_shutdown_initiated_ = true; }
+  bool IsPartyShutdownInitiated() const { return party_shutdown_initiated_; }
+
+  // Stage 3: Shutdown Completed (Final Termination)
+  void MarkShutdownComplete() { shutdown_completed_latch_.Set(); }
+  auto WaitShutdownComplete() { return shutdown_completed_latch_.Wait(); }
+
+ private:
+  bool shutdown_initiated_ = false;
+  bool party_shutdown_initiated_ = false;
+  Latch<void> shutdown_completed_latch_;
+};
+
+// Represents a stream queued for tarpitting and its scheduled expiration time.
+// The payload variant defines the terminal action to perform once the tarpit
+// duration elapses:
+// - OutgoingResetPayload: sends a delayed RST_STREAM.
+// - OutgoingTrailingMetadataPayload: sends delayed server trailing metadata.
+// The functions in this class are not thread-safe.
+class TarpitEntry {
+ public:
+  struct OutgoingResetPayload {
+    absl::Status trailing_metadata_status;
+    uint32_t http2_error_code = 0;
+  };
+
+  struct OutgoingTrailingMetadataPayload {
+    ServerMetadataHandle metadata;
+  };
+
+  TarpitEntry(TarpitEntry&&) = default;
+  TarpitEntry& operator=(TarpitEntry&&) = default;
+  TarpitEntry(const TarpitEntry&) = delete;
+  TarpitEntry& operator=(const TarpitEntry&) = delete;
+
+  // Factory methods for constructing tarpit entries from producers across
+  // different parties.
+  static TarpitEntry CreateOutgoingReset(const uint32_t stream_id,
+                                         const uint32_t http2_error_code,
+                                         absl::Status trailing_metadata_status,
+                                         const Timestamp expire_time) {
+    return TarpitEntry(stream_id,
+                       OutgoingResetPayload{std::move(trailing_metadata_status),
+                                            http2_error_code},
+                       expire_time);
+  }
+  static TarpitEntry CreateOutgoingTrailingMetadata(
+      const uint32_t stream_id, ServerMetadataHandle metadata,
+      const Timestamp expire_time) {
+    return TarpitEntry(stream_id,
+                       OutgoingTrailingMetadataPayload{std::move(metadata)},
+                       expire_time);
+  }
+
+  Timestamp GetExpireTime() const { return expire_time_; }
+  uint32_t GetStreamId() const { return stream_id_; }
+
+  bool IsOutgoingReset() const {
+    return std::holds_alternative<OutgoingResetPayload>(payload_);
+  }
+  bool IsOutgoingTrailingMetadata() const {
+    return std::holds_alternative<OutgoingTrailingMetadataPayload>(payload_);
+  }
+
+  // Consumes and extracts the payload when executing the post-tarpit action.
+  // Returns std::nullopt if the payload type does not match.
+  std::optional<OutgoingResetPayload> TakeOutgoingResetPayload() {
+    OutgoingResetPayload* const p =
+        std::get_if<OutgoingResetPayload>(&payload_);
+    if (p != nullptr) {
+      return std::move(*p);
+    }
+    return std::nullopt;
+  }
+  std::optional<OutgoingTrailingMetadataPayload>
+  TakeOutgoingTrailingMetadataPayload() {
+    OutgoingTrailingMetadataPayload* const p =
+        std::get_if<OutgoingTrailingMetadataPayload>(&payload_);
+    if (p != nullptr) {
+      return std::move(*p);
+    }
+    return std::nullopt;
+  }
+
+  std::string DebugString() const;
+
+  bool operator>(const TarpitEntry& other) const {
+    return expire_time_ > other.expire_time_;
+  }
+
+ private:
+  using Payload =
+      std::variant<OutgoingResetPayload, OutgoingTrailingMetadataPayload>;
+
+  TarpitEntry(const uint32_t stream_id, Payload payload,
+              const Timestamp expire_time)
+      : stream_id_(stream_id),
+        expire_time_(expire_time),
+        payload_(std::move(payload)) {}
+
+  uint32_t stream_id_ = 0;
+  Timestamp expire_time_ = Timestamp::InfPast();
+  Payload payload_;
+};
+
+class TarpitQueue {
+ public:
+  TarpitQueue() = default;
+  TarpitQueue(const TarpitQueue&) = delete;
+  TarpitQueue& operator=(const TarpitQueue&) = delete;
+  TarpitQueue(TarpitQueue&&) = default;
+  TarpitQueue& operator=(TarpitQueue&&) = default;
+
+  bool IsEmpty() const { return entries_.empty(); }
+  size_t Size() const { return entries_.size(); }
+
+  const TarpitEntry& Top() const {
+    GRPC_DCHECK(!entries_.empty());
+    return entries_.front();
+  }
+
+  void Push(TarpitEntry entry) {
+    entries_.push_back(std::move(entry));
+    std::push_heap(entries_.begin(), entries_.end(), std::greater<>());
+  }
+
+  TarpitEntry Pop() {
+    GRPC_DCHECK(!entries_.empty());
+    std::pop_heap(entries_.begin(), entries_.end(), std::greater<>());
+    TarpitEntry top_entry = std::move(entries_.back());
+    entries_.pop_back();
+    return top_entry;
+  }
+
+  void Clear() { entries_.clear(); }
+
+ private:
+  std::vector<TarpitEntry> entries_;
+};
+
+class TarpitManager {
+ public:
+  explicit TarpitManager(const ChannelArgs& channel_args);
+
+  ~TarpitManager() = default;
+
+  // TarpitManager is neither copyable nor movable.
+  TarpitManager(const TarpitManager&) = delete;
+  TarpitManager& operator=(const TarpitManager&) = delete;
+  TarpitManager(TarpitManager&&) = delete;
+  TarpitManager& operator=(TarpitManager&&) = delete;
+
+  //----------------------------------------------------------------------------
+  // Off-Party Producer Methods (Can be called from any thread/party)
+  //----------------------------------------------------------------------------
+
+  // Producer APIs called by the transport to enqueue delayed stream actions.
+  //
+  // Note:
+  // - Callers MUST verify allow_tarpit() is true before invoking these APIs.
+  // - Returns StatusFlag::kFailure if the MPSC channel is closed or full, in
+  //   which case the caller MUST initiate transport teardown (connection
+  //   error). In theory the MPSC queue can never be full , because it cannot
+  //   have more than MAX_CONCURRENT_STREAMS number of streams in it.
+
+  // Sends a delayed RST_STREAM.
+  StatusFlag RequestCloseStream(uint32_t stream_id,
+                                uint32_t reset_stream_error_code,
+                                absl::Status trailing_metadata_status);
+
+  // Sends delayed server trailing metadata.
+  StatusFlag StartTarpitTrailers(uint32_t stream_id,
+                                 ServerMetadataHandle metadata);
+
+  //----------------------------------------------------------------------------
+  // Transport-Party Confined Methods (Must be run on TransportParty)
+  //----------------------------------------------------------------------------
+
+  // Prepares an incoming Stream on the transport party by marking the stream
+  // tarpitted and initiating read-silencing. Returns the StreamStateChange to
+  // be handled by the server transport.
+  StreamStateChange OnTarpit(Stream& stream);
+
+  void AddToQueue(TarpitEntry&& entry);
+  std::vector<TarpitEntry> OnTimerExpired();
+  void Shutdown();
+
+  channelz::PropertyList ChannelzProperties() const;
+
+  bool allow_tarpit() const { return allow_tarpit_; }
+
+  auto NextMessage() { return receiver_.Next(); }
+
+  // Returns a promise that waits for the earliest expiration time of tarpitted
+  // streams, or suspends if the queue is empty.
+  auto WaitForTimerExpire() {
+    return If(
+        [this]() -> Poll<bool> {
+          if (GPR_UNLIKELY(shutdown_)) {
+            return false;
+          }
+          if (tarpit_queue_.IsEmpty()) {
+            empty_queue_waker_ = GetContext<Activity>()->MakeNonOwningWaker();
+            return Pending{};
+          }
+          return true;
+        },
+        [this]() {
+          // Sleep at least for kMinTarpitSleepDuration to avoid potential
+          // busy-looping if there are lot of entries with expiration time in
+          // near future. This works for the tarpit use case as this guarantees
+          // we would close stream strictly after the expiration time.
+          return Sleep(std::max(tarpit_queue_.Top().GetExpireTime(),
+                                Timestamp::Now() + kMinTarpitSleepDuration));
+        },
+        []() -> Poll<absl::Status> {
+          return absl::CancelledError("TarpitManager shutdown");
+        });
+  }
+
+ private:
+  static constexpr Duration kMinTarpitSleepDuration =
+      Duration::Milliseconds(10);
+
+  Duration GetTarpitDuration() const;
+
+  const bool allow_tarpit_ = true;
+  const Duration min_tarpit_duration_;
+  const Duration max_tarpit_duration_;
+  bool shutdown_ = false;
+
+  MpscReceiver<TarpitEntry> receiver_;
+  MpscSender<TarpitEntry> sender_;
+
+  // Queue ordered by earliest expiration time for pending tarpitted streams.
+  TarpitQueue tarpit_queue_;
+
+  // Waker for resuming WaitForTimerExpire when transitioning from an empty
+  // queue to a non-empty queue.
+  Waker empty_queue_waker_;
+};
+
 }  // namespace http2
 }  // namespace grpc_core
 

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

@@ -72,6 +72,7 @@
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/lib/transport/transport_framing_endpoint_extension.h"
+#include "src/core/mitigation_engine/mitigation_engine.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/telemetry/context_list_entry.h"
 #include "src/core/telemetry/stats.h"
@@ -94,6 +95,9 @@
 //   bits being used for flags defined above)
 #define CLOSURE_BARRIER_FIRST_REF_BIT (1 << 16)
 
+constexpr uint32_t kMaxSecurityFrameSize = 16u * 1024u;
+constexpr int kMinMaxSecurityFrameSize = 0;
+
 // streams are kept in various linked lists depending on what things need to
 // happen to them... this enum labels each list
 typedef enum {
@@ -230,6 +234,9 @@ typedef enum {
   GRPC_CHTTP2_KEEPALIVE_STATE_DISABLED,
 } grpc_chttp2_keepalive_state;
 
+constexpr uint16_t kMaxNoopDataFrames = 16384u;
+constexpr uint16_t kMaxNoopContinuationFrames = 128u;
+
 struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
                                      public grpc_core::KeepsGrpcInitialized {
   grpc_chttp2_transport(const grpc_core::ChannelArgs& channel_args,
@@ -287,7 +294,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   void PerformOp(grpc_transport_op* op) override;
   // Callback for transport framing endpoint extension to send security frames
   // received directly from the endpoint on wire.
-  void WriteSecurityFrame(grpc_core::SliceBuffer* data);
+  void WriteSecurityFrame(grpc_core::SliceBuffer data);
   void WriteSecurityFrameLocked(grpc_core::SliceBuffer* data);
 
   void StartWatch(grpc_core::RefCountedPtr<StateWatcher> watcher) override;
@@ -458,6 +465,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   /// parser for goaway frames
   grpc_chttp2_goaway_parser goaway_parser;
   // parser for secure frames
+  uint32_t max_security_frame_size;
   grpc_chttp2_security_frame_parser security_frame_parser;
 
   grpc_core::chttp2::TransportFlowControl flow_control;
@@ -472,6 +480,8 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   uint8_t incoming_frame_flags = 0;
   uint8_t header_eof = 0;
   bool is_first_frame = true;
+  uint16_t noop_continuation_frames = 0u;
+  uint16_t noop_data_frames = 0u;
   uint32_t expect_continuation_stream_id = 0;
   uint32_t incoming_frame_size = 0;
 
@@ -618,6 +628,11 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   grpc_core::Timestamp last_ztrace_time = grpc_core::Timestamp::InfPast();
 
   GPR_NO_UNIQUE_ADDRESS grpc_core::latent_see::Flow write_flow;
+
+  std::optional<uint32_t> max_recv_message_length;
+
+  grpc_auth_context* auth_context = nullptr;
+  grpc_core::RefCountedPtr<grpc_core::MitigationEngine> mitigation_engine;
 };
 
 typedef enum {
@@ -705,6 +720,7 @@ struct grpc_chttp2_stream {
   grpc_metadata_batch trailing_metadata_buffer;
 
   grpc_slice_buffer frame_storage;  // protected by t combiner
+  size_t num_frames = 0;            // protected by t combiner
 
   grpc_core::Timestamp deadline = grpc_core::Timestamp::InfFuture();
 
@@ -764,6 +780,9 @@ struct grpc_chttp2_stream {
   // The last time a stream window update was received.
   grpc_core::Timestamp last_window_update_time =
       grpc_core::Timestamp::InfPast();
+
+  bool message_size_limit_exceeded = false;
+  std::optional<uint32_t> max_recv_message_length;
 };
 
 /// Transport writing call flow:
@@ -878,6 +897,11 @@ void grpc_chttp2_stream_unref(grpc_chttp2_stream* s);
 #endif
 
 void grpc_chttp2_ack_ping(grpc_chttp2_transport* t, uint64_t id);
+grpc_error_handle grpc_chttp2_increase_num_pending_induced_frames(
+    grpc_chttp2_transport* t);
+
+void grpc_chttp2_close_transport_locked(grpc_chttp2_transport* t,
+                                        grpc_error_handle error);
 
 /// Sends GOAWAY with error code ENHANCE_YOUR_CALM and additional debug data
 /// resembling "too_many_pings" followed by immediately closing the connection.

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

@@ -39,7 +39,7 @@ namespace http2 {
 
 #define GRPC_MESSAGE_ASSEMBLER_DEBUG VLOG(2)
 
-// TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
+// TODO(akshitpatel): [PH2][P4] : Write micro benchmarks for
 // assembler and disassembler code
 
 constexpr uint32_t kOneGb = (1024u * 1024u * 1024u);
@@ -81,7 +81,6 @@ class GrpcMessageAssembler {
   ValueOrHttp2Status<MessageHandle> ExtractMessage() {
     const size_t current_len = message_buffer_.Length();
     if (current_len < kGrpcHeaderSizeInBytes) {
-      // TODO(tjagtap) : [PH2][P3] : Write a test for this.
       return ReturnNullOrError();
     }
     ValueOrHttp2Status<GrpcMessageHeader> header =