Turn `buffered_reset_stream_at_` into a heap-allocated object, since it's used infrequently.

Saves 32 bytes of memory per stream.

PiperOrigin-RevId: 947677356

quiche/quic/core/quic_stream.cc

diff --git a/quiche/quic/core/quic_stream.cc b/quiche/quic/core/quic_stream.cc
index d140e25..2b98540 100644
--- a/quiche/quic/core/quic_stream.cc
+++ b/quiche/quic/core/quic_stream.cc
@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <cstdint>
 #include <limits>
+#include <memory>
 #include <optional>
 #include <string>
 #include <utility>
@@ -281,13 +282,13 @@
             " greater than the FIN offset: ", sequencer()->close_offset()));
     return;
   }
-  if (buffered_reset_stream_at_.has_value() &&
+  if (buffered_reset_stream_at_ != nullptr &&
       (frame.reliable_offset > buffered_reset_stream_at_->reliable_offset)) {
     // Ignore a reliable reset that raises the reliable size. It might have
     // arrived out of sequence.
     return;
   }
-  buffered_reset_stream_at_ = frame;
+  buffered_reset_stream_at_ = std::make_unique<QuicResetStreamAtFrame>(frame);
   sequencer_.OnReliableReset(frame.reliable_offset);
 }
 
@@ -341,7 +342,7 @@
           (session->GetClock()->ApproximateNow() - pending.creation_time())) {
   QUICHE_DCHECK(session->version().IsIetfQuic());
   sequencer_.set_stream(this);
-  buffered_reset_stream_at_ = pending.buffered_reset_stream_at();
+  buffered_reset_stream_at_ = std::move(pending.buffered_reset_stream_at_);
 }
 
 namespace {
@@ -636,13 +637,13 @@
             " greater than the FIN offset: ", sequencer()->close_offset()));
     return;
   }
-  if (buffered_reset_stream_at_.has_value() &&
+  if (buffered_reset_stream_at_ != nullptr &&
       (frame.reliable_offset > buffered_reset_stream_at_->reliable_offset)) {
     // Ignore a reliable reset that raises the reliable size. It might have
     // arrived out of sequence.
     return;
   }
-  buffered_reset_stream_at_ = frame;
+  buffered_reset_stream_at_ = std::make_unique<QuicResetStreamAtFrame>(frame);
   MaybeCloseStreamWithBufferedReset();
   if (!rst_received_) {
     sequencer_.OnReliableReset(frame.reliable_offset);
@@ -1594,10 +1595,10 @@
 }
 
 void QuicStream::MaybeCloseStreamWithBufferedReset() {
-  if (buffered_reset_stream_at_.has_value() && !sequencer_.IsClosed() &&
+  if (buffered_reset_stream_at_ != nullptr && !sequencer_.IsClosed() &&
       NumBytesConsumed() >= buffered_reset_stream_at_->reliable_offset) {
     OnStreamReset(buffered_reset_stream_at_->ToRstStream());
-    buffered_reset_stream_at_ = std::nullopt;
+    buffered_reset_stream_at_.reset();
   }
 }
 

quiche/quic/core/quic_stream.h

diff --git a/quiche/quic/core/quic_stream.h b/quiche/quic/core/quic_stream.h
index a3a26f0..c45d40f 100644
--- a/quiche/quic/core/quic_stream.h
+++ b/quiche/quic/core/quic_stream.h
@@ -19,9 +19,11 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 #include <optional>
 #include <string>
 
+#include "absl/base/nullability.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 #include "quiche/quic/core/frames/quic_connection_close_frame.h"
@@ -110,8 +112,8 @@
 
   QuicTime creation_time() const { return creation_time_; }
 
-  std::optional<QuicResetStreamAtFrame> buffered_reset_stream_at() const {
-    return buffered_reset_stream_at_;
+  const QuicResetStreamAtFrame* absl_nullable buffered_reset_stream_at() const {
+    return buffered_reset_stream_at_.get();
   }
 
  private:
@@ -150,7 +152,7 @@
   const QuicTime creation_time_;
 
   // When RESET_STREAM_AT arrives,buffer it for when reliable_size is consumed.
-  std::optional<QuicResetStreamAtFrame> buffered_reset_stream_at_;
+  std::unique_ptr<QuicResetStreamAtFrame> buffered_reset_stream_at_;
 };
 
 class QUICHE_EXPORT QuicStream : public QuicStreamSequencer::StreamInterface {
@@ -626,8 +628,9 @@
   // before being moved to this QuicStream.
   const QuicTime::Delta pending_duration_;
 
-  // When RESET_STREAM_AT arrives,buffer it for when reliable_size is consumed.
-  std::optional<QuicResetStreamAtFrame> buffered_reset_stream_at_;
+  // When RESET_STREAM_AT arrives, buffer it for when reliable_size is consumed.
+  absl_nullable std::unique_ptr<QuicResetStreamAtFrame>
+      buffered_reset_stream_at_;
 
   // If the stream is reset, outgoing data up to reliable_size_will be
   // delivered (and acknowledged) before the write side of the stream is closed.