Refactor QuicStream constructor to take PendingStream by reference.

QuicStream constructor currently takes a PendingStream pointer. This pointer is never null. Refactoring it to take a reference instead improves code safety and readability by making it clear that the argument is required.

This change updates QuicStream and all its callers in derived classes and tests to use references.

PiperOrigin-RevId: 903879162

quiche/quic/core/http/quic_connection_migration_manager_test.cc

diff --git a/quiche/quic/core/http/quic_connection_migration_manager_test.cc b/quiche/quic/core/http/quic_connection_migration_manager_test.cc
index d1125c1..fba1256 100644
--- a/quiche/quic/core/http/quic_connection_migration_manager_test.cc
+++ b/quiche/quic/core/http/quic_connection_migration_manager_test.cc
@@ -287,7 +287,7 @@
   TestStream(QuicStreamId id, QuicSpdySession* session, StreamType type)
       : QuicSpdyStream(id, session, type) {}
 
-  TestStream(PendingStream* pending, QuicSpdySession* session)
+  TestStream(PendingStream& pending, QuicSpdySession* session)
       : QuicSpdyStream(pending, session) {}
 
   void OnBodyAvailable() override {}
@@ -401,7 +401,7 @@
   }
 
   TestStream* CreateIncomingStream(PendingStream* pending) override {
-    TestStream* stream = new TestStream(pending, this);
+    TestStream* stream = new TestStream(*pending, this);
     ActivateStream(absl::WrapUnique(stream));
     return stream;
   }

quiche/quic/core/http/quic_receive_control_stream.cc

diff --git a/quiche/quic/core/http/quic_receive_control_stream.cc b/quiche/quic/core/http/quic_receive_control_stream.cc
index 08edeb2..46b3a7c 100644
--- a/quiche/quic/core/http/quic_receive_control_stream.cc
+++ b/quiche/quic/core/http/quic_receive_control_stream.cc
@@ -22,7 +22,7 @@
 namespace quic {
 
 QuicReceiveControlStream::QuicReceiveControlStream(
-    PendingStream* pending, QuicSpdySession* spdy_session)
+    PendingStream& pending, QuicSpdySession* spdy_session)
     : QuicStream(pending, spdy_session,
                  /*is_static=*/true),
       settings_frame_received_(false),

quiche/quic/core/http/quic_receive_control_stream.h

diff --git a/quiche/quic/core/http/quic_receive_control_stream.h b/quiche/quic/core/http/quic_receive_control_stream.h
index b1cf610..0b33877 100644
--- a/quiche/quic/core/http/quic_receive_control_stream.h
+++ b/quiche/quic/core/http/quic_receive_control_stream.h
@@ -19,7 +19,7 @@
 class QUICHE_EXPORT QuicReceiveControlStream : public QuicStream,
                                                public HttpDecoder::Visitor {
  public:
-  explicit QuicReceiveControlStream(PendingStream* pending,
+  explicit QuicReceiveControlStream(PendingStream& pending,
                                     QuicSpdySession* spdy_session);
   QuicReceiveControlStream(const QuicReceiveControlStream&) = delete;
   QuicReceiveControlStream& operator=(const QuicReceiveControlStream&) = delete;

quiche/quic/core/http/quic_server_session_base_test.cc

diff --git a/quiche/quic/core/http/quic_server_session_base_test.cc b/quiche/quic/core/http/quic_server_session_base_test.cc
index 12ce32d..0cdca07 100644
--- a/quiche/quic/core/http/quic_server_session_base_test.cc
+++ b/quiche/quic/core/http/quic_server_session_base_test.cc
@@ -92,7 +92,7 @@
 
   QuicSpdyStream* CreateIncomingStream(PendingStream* pending) override {
     QuicSpdyStream* stream =
-        new QuicSimpleServerStream(pending, this, quic_simple_server_backend_);
+        new QuicSimpleServerStream(*pending, this, quic_simple_server_backend_);
     ActivateStream(absl::WrapUnique(stream));
     return stream;
   }

quiche/quic/core/http/quic_spdy_client_session.cc

diff --git a/quiche/quic/core/http/quic_spdy_client_session.cc b/quiche/quic/core/http/quic_spdy_client_session.cc
index 19dfe8e..ec5aabf 100644
--- a/quiche/quic/core/http/quic_spdy_client_session.cc
+++ b/quiche/quic/core/http/quic_spdy_client_session.cc
@@ -190,7 +190,7 @@
 
 QuicSpdyStream* QuicSpdyClientSession::CreateIncomingStream(
     PendingStream* pending) {
-  QuicSpdyStream* stream = new QuicSpdyClientStream(pending, this);
+  QuicSpdyStream* stream = new QuicSpdyClientStream(*pending, this);
   ActivateStream(absl::WrapUnique(stream));
   return stream;
 }

quiche/quic/core/http/quic_spdy_client_stream.cc

diff --git a/quiche/quic/core/http/quic_spdy_client_stream.cc b/quiche/quic/core/http/quic_spdy_client_stream.cc
index 3338d47..3b33ab6 100644
--- a/quiche/quic/core/http/quic_spdy_client_stream.cc
+++ b/quiche/quic/core/http/quic_spdy_client_stream.cc
@@ -33,7 +33,7 @@
       header_bytes_written_(0),
       session_(session) {}
 
-QuicSpdyClientStream::QuicSpdyClientStream(PendingStream* pending,
+QuicSpdyClientStream::QuicSpdyClientStream(PendingStream& pending,
                                            QuicSpdyClientSession* session)
     : QuicSpdyStream(pending, session),
       content_length_(-1),

quiche/quic/core/http/quic_spdy_client_stream.h

diff --git a/quiche/quic/core/http/quic_spdy_client_stream.h b/quiche/quic/core/http/quic_spdy_client_stream.h
index 66b0041..bf3dc2d 100644
--- a/quiche/quic/core/http/quic_spdy_client_stream.h
+++ b/quiche/quic/core/http/quic_spdy_client_stream.h
@@ -25,7 +25,7 @@
  public:
   QuicSpdyClientStream(QuicStreamId id, QuicSpdyClientSession* session,
                        StreamType type);
-  QuicSpdyClientStream(PendingStream* pending,
+  QuicSpdyClientStream(PendingStream& pending,
                        QuicSpdyClientSession* spdy_session);
   QuicSpdyClientStream(const QuicSpdyClientStream&) = delete;
   QuicSpdyClientStream& operator=(const QuicSpdyClientStream&) = delete;

quiche/quic/core/http/quic_spdy_server_stream_base.cc

diff --git a/quiche/quic/core/http/quic_spdy_server_stream_base.cc b/quiche/quic/core/http/quic_spdy_server_stream_base.cc
index bfcc565..27cfb1c 100644
--- a/quiche/quic/core/http/quic_spdy_server_stream_base.cc
+++ b/quiche/quic/core/http/quic_spdy_server_stream_base.cc
@@ -25,7 +25,7 @@
                                                    StreamType type)
     : QuicSpdyStream(id, session, type) {}
 
-QuicSpdyServerStreamBase::QuicSpdyServerStreamBase(PendingStream* pending,
+QuicSpdyServerStreamBase::QuicSpdyServerStreamBase(PendingStream& pending,
                                                    QuicSpdySession* session)
     : QuicSpdyStream(pending, session) {}
 

quiche/quic/core/http/quic_spdy_server_stream_base.h

diff --git a/quiche/quic/core/http/quic_spdy_server_stream_base.h b/quiche/quic/core/http/quic_spdy_server_stream_base.h
index d28d8ff..fc912d9 100644
--- a/quiche/quic/core/http/quic_spdy_server_stream_base.h
+++ b/quiche/quic/core/http/quic_spdy_server_stream_base.h
@@ -13,7 +13,7 @@
  public:
   QuicSpdyServerStreamBase(QuicStreamId id, QuicSpdySession* session,
                            StreamType type);
-  QuicSpdyServerStreamBase(PendingStream* pending, QuicSpdySession* session);
+  QuicSpdyServerStreamBase(PendingStream& pending, QuicSpdySession* session);
   QuicSpdyServerStreamBase(const QuicSpdyServerStreamBase&) = delete;
   QuicSpdyServerStreamBase& operator=(const QuicSpdyServerStreamBase&) = delete;
 

quiche/quic/core/http/quic_spdy_session.cc

diff --git a/quiche/quic/core/http/quic_spdy_session.cc b/quiche/quic/core/http/quic_spdy_session.cc
index 23395ff..9c73d32 100644
--- a/quiche/quic/core/http/quic_spdy_session.cc
+++ b/quiche/quic/core/http/quic_spdy_session.cc
@@ -1545,7 +1545,7 @@
         return nullptr;
       }
       auto receive_stream =
-          std::make_unique<QuicReceiveControlStream>(pending, this);
+          std::make_unique<QuicReceiveControlStream>(*pending, this);
       receive_control_stream_ = receive_stream.get();
       ActivateStream(std::move(receive_stream));
       QUIC_DVLOG(1) << ENDPOINT << "Receive Control stream is created";
@@ -1566,7 +1566,7 @@
         return nullptr;
       }
       auto encoder_receive = std::make_unique<QpackReceiveStream>(
-          pending, this, qpack_decoder_->encoder_stream_receiver());
+          *pending, this, qpack_decoder_->encoder_stream_receiver());
       qpack_encoder_receive_stream_ = encoder_receive.get();
       ActivateStream(std::move(encoder_receive));
       QUIC_DVLOG(1) << ENDPOINT << "Receive QPACK Encoder stream is created";
@@ -1582,7 +1582,7 @@
         return nullptr;
       }
       auto decoder_receive = std::make_unique<QpackReceiveStream>(
-          pending, this, qpack_encoder_->decoder_stream_receiver());
+          *pending, this, qpack_encoder_->decoder_stream_receiver());
       qpack_decoder_receive_stream_ = decoder_receive.get();
       ActivateStream(std::move(decoder_receive));
       QUIC_DVLOG(1) << ENDPOINT << "Receive QPACK Decoder stream is created";
@@ -1605,7 +1605,7 @@
       QUIC_DVLOG(1) << ENDPOINT << "Created an incoming WebTransport stream "
                     << pending->id();
       auto stream_owned =
-          std::make_unique<WebTransportHttp3UnidirectionalStream>(pending,
+          std::make_unique<WebTransportHttp3UnidirectionalStream>(*pending,
                                                                   this);
       WebTransportHttp3UnidirectionalStream* stream = stream_owned.get();
       ActivateStream(std::move(stream_owned));

quiche/quic/core/http/quic_spdy_session_test.cc

diff --git a/quiche/quic/core/http/quic_spdy_session_test.cc b/quiche/quic/core/http/quic_spdy_session_test.cc
index 3f8c88a..b9b3caa 100644
--- a/quiche/quic/core/http/quic_spdy_session_test.cc
+++ b/quiche/quic/core/http/quic_spdy_session_test.cc
@@ -242,7 +242,7 @@
   TestStream(QuicStreamId id, QuicSpdySession* session, StreamType type)
       : QuicSpdyStream(id, session, type) {}
 
-  TestStream(PendingStream* pending, QuicSpdySession* session)
+  TestStream(PendingStream& pending, QuicSpdySession* session)
       : QuicSpdyStream(pending, session) {}
 
   using QuicStream::CloseWriteSide;
@@ -314,7 +314,7 @@
   }
 
   TestStream* CreateIncomingStream(PendingStream* pending) override {
-    TestStream* stream = new TestStream(pending, this);
+    TestStream* stream = new TestStream(*pending, this);
     ActivateStream(absl::WrapUnique(stream));
     return stream;
   }

quiche/quic/core/http/quic_spdy_stream.cc

diff --git a/quiche/quic/core/http/quic_spdy_stream.cc b/quiche/quic/core/http/quic_spdy_stream.cc
index c46a77b..55f7824 100644
--- a/quiche/quic/core/http/quic_spdy_stream.cc
+++ b/quiche/quic/core/http/quic_spdy_stream.cc
@@ -246,7 +246,7 @@
   spdy_session_->OnStreamCreated(this);
 }
 
-QuicSpdyStream::QuicSpdyStream(PendingStream* pending,
+QuicSpdyStream::QuicSpdyStream(PendingStream& pending,
                                QuicSpdySession* spdy_session)
     : QuicStream(pending, spdy_session, /*is_static=*/false),
       spdy_session_(spdy_session),

quiche/quic/core/http/quic_spdy_stream.h

diff --git a/quiche/quic/core/http/quic_spdy_stream.h b/quiche/quic/core/http/quic_spdy_stream.h
index edc94ed..5adb54e 100644
--- a/quiche/quic/core/http/quic_spdy_stream.h
+++ b/quiche/quic/core/http/quic_spdy_stream.h
@@ -121,7 +121,7 @@
 
   QuicSpdyStream(QuicStreamId id, QuicSpdySession* spdy_session,
                  StreamType type);
-  QuicSpdyStream(PendingStream* pending, QuicSpdySession* spdy_session);
+  QuicSpdyStream(PendingStream& pending, QuicSpdySession* spdy_session);
   QuicSpdyStream(const QuicSpdyStream&) = delete;
   QuicSpdyStream& operator=(const QuicSpdyStream&) = delete;
   ~QuicSpdyStream() override;

quiche/quic/core/http/web_transport_http3.cc

diff --git a/quiche/quic/core/http/web_transport_http3.cc b/quiche/quic/core/http/web_transport_http3.cc
index 4044796..c7157d2 100644
--- a/quiche/quic/core/http/web_transport_http3.cc
+++ b/quiche/quic/core/http/web_transport_http3.cc
@@ -318,7 +318,7 @@
 void WebTransportHttp3::OnDrainSessionReceived() { OnGoAwayReceived(); }
 
 WebTransportHttp3UnidirectionalStream::WebTransportHttp3UnidirectionalStream(
-    PendingStream* pending, QuicSpdySession* session)
+    PendingStream& pending, QuicSpdySession* session)
     : QuicStream(pending, session, /*is_static=*/false),
       session_(session),
       adapter_(session, this, sequencer(), std::nullopt),

quiche/quic/core/http/web_transport_http3.h

diff --git a/quiche/quic/core/http/web_transport_http3.h b/quiche/quic/core/http/web_transport_http3.h
index a360986..80268bf 100644
--- a/quiche/quic/core/http/web_transport_http3.h
+++ b/quiche/quic/core/http/web_transport_http3.h
@@ -172,7 +172,7 @@
 class QUICHE_EXPORT WebTransportHttp3UnidirectionalStream : public QuicStream {
  public:
   // Incoming stream.
-  WebTransportHttp3UnidirectionalStream(PendingStream* pending,
+  WebTransportHttp3UnidirectionalStream(PendingStream& pending,
                                         QuicSpdySession* session);
   // Outgoing stream.
   WebTransportHttp3UnidirectionalStream(QuicStreamId id,

quiche/quic/core/http/web_transport_only_server_session.cc

diff --git a/quiche/quic/core/http/web_transport_only_server_session.cc b/quiche/quic/core/http/web_transport_only_server_session.cc
index 25cdf91..153d1ff 100644
--- a/quiche/quic/core/http/web_transport_only_server_session.cc
+++ b/quiche/quic/core/http/web_transport_only_server_session.cc
@@ -74,7 +74,7 @@
 
 QuicSpdyStream* WebTransportOnlyServerSession::CreateIncomingStream(
     PendingStream* pending) {
-  QuicSpdyStream* stream = new Stream(pending, this);
+  QuicSpdyStream* stream = new Stream(*pending, this);
   ActivateStream(absl::WrapUnique(stream));
   return stream;
 }

quiche/quic/core/qpack/qpack_receive_stream.cc

diff --git a/quiche/quic/core/qpack/qpack_receive_stream.cc b/quiche/quic/core/qpack/qpack_receive_stream.cc
index b00a06f..a3dd219 100644
--- a/quiche/quic/core/qpack/qpack_receive_stream.cc
+++ b/quiche/quic/core/qpack/qpack_receive_stream.cc
@@ -8,7 +8,7 @@
 #include "quiche/quic/core/quic_session.h"
 
 namespace quic {
-QpackReceiveStream::QpackReceiveStream(PendingStream* pending,
+QpackReceiveStream::QpackReceiveStream(PendingStream& pending,
                                        QuicSession* session,
                                        QpackStreamReceiver* receiver)
     : QuicStream(pending, session, /*is_static=*/true), receiver_(receiver) {}

quiche/quic/core/qpack/qpack_receive_stream.h

diff --git a/quiche/quic/core/qpack/qpack_receive_stream.h b/quiche/quic/core/qpack/qpack_receive_stream.h
index 07e7594..17e8a2f 100644
--- a/quiche/quic/core/qpack/qpack_receive_stream.h
+++ b/quiche/quic/core/qpack/qpack_receive_stream.h
@@ -19,7 +19,7 @@
  public:
   // Construct receive stream from pending stream, the |pending| object needs
   // to be deleted after the construction.
-  QpackReceiveStream(PendingStream* pending, QuicSession* session,
+  QpackReceiveStream(PendingStream& pending, QuicSession* session,
                      QpackStreamReceiver* receiver);
   QpackReceiveStream(const QpackReceiveStream&) = delete;
   QpackReceiveStream& operator=(const QpackReceiveStream&) = delete;

quiche/quic/core/quic_session_test.cc

diff --git a/quiche/quic/core/quic_session_test.cc b/quiche/quic/core/quic_session_test.cc
index e77ec26..e69d87c 100644
--- a/quiche/quic/core/quic_session_test.cc
+++ b/quiche/quic/core/quic_session_test.cc
@@ -222,7 +222,7 @@
              StreamType type)
       : QuicStream(id, session, is_static, type) {}
 
-  TestStream(PendingStream* pending, QuicSession* session)
+  TestStream(PendingStream& pending, QuicSession* session)
       : QuicStream(pending, session, /*is_static=*/false) {}
 
   using QuicStream::AddBytesConsumed;
@@ -306,7 +306,7 @@
   }
 
   TestStream* CreateIncomingStream(PendingStream* pending) override {
-    TestStream* stream = new TestStream(pending, this);
+    TestStream* stream = new TestStream(*pending, this);
     ActivateStream(absl::WrapUnique(stream));
     ++num_incoming_streams_created_;
     return stream;

quiche/quic/core/quic_stream.cc

diff --git a/quiche/quic/core/quic_stream.cc b/quiche/quic/core/quic_stream.cc
index 673a869..3f269ca 100644
--- a/quiche/quic/core/quic_stream.cc
+++ b/quiche/quic/core/quic_stream.cc
@@ -328,20 +328,20 @@
   sequencer_.StopReading();
 }
 
-QuicStream::QuicStream(PendingStream* pending, QuicSession* session,
+QuicStream::QuicStream(PendingStream& pending, QuicSession* session,
                        bool is_static)
     : QuicStream(
-          pending->id_, session, std::move(pending->sequencer_), is_static,
-          QuicUtils::GetStreamType(pending->id_, session->perspective(),
+          pending.id_, session, std::move(pending.sequencer_), is_static,
+          QuicUtils::GetStreamType(pending.id_, session->perspective(),
                                    /*peer_initiated = */ true,
                                    session->version()),
-          pending->stream_bytes_read_, pending->fin_received_,
-          std::move(pending->flow_controller_),
-          pending->connection_flow_controller_,
-          (session->GetClock()->ApproximateNow() - pending->creation_time())) {
+          pending.stream_bytes_read_, pending.fin_received_,
+          std::move(pending.flow_controller_),
+          pending.connection_flow_controller_,
+          (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_ = pending.buffered_reset_stream_at();
 }
 
 namespace {

quiche/quic/core/quic_stream.h

diff --git a/quiche/quic/core/quic_stream.h b/quiche/quic/core/quic_stream.h
index 2a11b8b..03244dd 100644
--- a/quiche/quic/core/quic_stream.h
+++ b/quiche/quic/core/quic_stream.h
@@ -163,7 +163,7 @@
   // TODO(fayang): Remove |type| when IETF stream ID numbering fully kicks in.
   QuicStream(QuicStreamId id, QuicSession* session, bool is_static,
              StreamType type);
-  QuicStream(PendingStream* pending, QuicSession* session, bool is_static);
+  QuicStream(PendingStream& pending, QuicSession* session, bool is_static);
   QuicStream(const QuicStream&) = delete;
   QuicStream& operator=(const QuicStream&) = delete;
 

quiche/quic/core/quic_stream_test.cc

diff --git a/quiche/quic/core/quic_stream_test.cc b/quiche/quic/core/quic_stream_test.cc
index e8b5cdc..fc216c8 100644
--- a/quiche/quic/core/quic_stream_test.cc
+++ b/quiche/quic/core/quic_stream_test.cc
@@ -66,7 +66,7 @@
     sequencer()->set_level_triggered(true);
   }
 
-  TestStream(PendingStream* pending, QuicSession* session, bool is_static)
+  TestStream(PendingStream& pending, QuicSession* session, bool is_static)
       : QuicStream(pending, session, is_static) {}
 
   MOCK_METHOD(void, OnDataAvailable, (), (override));
@@ -219,11 +219,11 @@
   Initialize();
 
   PendingStream pending(kTestPendingStreamId, *session_);
-  TestStream stream(&pending, session_.get(), false);
+  TestStream stream(pending, session_.get(), false);
   EXPECT_FALSE(stream.is_static());
 
   PendingStream pending2(kTestPendingStreamId + 4, *session_);
-  TestStream stream2(&pending2, session_.get(), true);
+  TestStream stream2(pending2, session_.get(), true);
   EXPECT_TRUE(stream2.is_static());
 }
 
@@ -231,7 +231,7 @@
   Initialize();
 
   PendingStream pending(kTestPendingStreamId, *session_);
-  TestStream stream(&pending, session_.get(), false);
+  TestStream stream(pending, session_.get(), false);
   EXPECT_EQ(stream.type(), READ_UNIDIRECTIONAL);
 }
 
@@ -242,7 +242,7 @@
       GetNthServerInitiatedUnidirectionalStreamId(session_->transport_version(),
                                                   1);
   PendingStream pending(server_initiated_pending_stream_id, *session_);
-  TestStream stream(&pending, session_.get(), false);
+  TestStream stream(pending, session_.get(), false);
   EXPECT_EQ(stream.type(), READ_UNIDIRECTIONAL);
 }
 
@@ -314,7 +314,7 @@
   QuicWindowUpdateFrame frame(kInvalidControlFrameId, bidirection_stream_id,
                               kDefaultFlowControlSendWindow * 2);
   pending.OnWindowUpdateFrame(frame);
-  TestStream stream(&pending, session_.get(), false);
+  TestStream stream(pending, session_.get(), false);
 
   EXPECT_EQ(QuicStreamPeer::SendWindowSize(&stream),
             kDefaultFlowControlSendWindow * 2);
@@ -345,7 +345,7 @@
   QuicStreamFrame frame2(kTestPendingStreamId, true, 3, ".");
   pending.OnStreamFrame(frame2);
 
-  TestStream stream(&pending, session_.get(), false);
+  TestStream stream(pending, session_.get(), false);
   EXPECT_EQ(3, stream.num_frames_received());
   EXPECT_EQ(3u, stream.stream_bytes_read());
   EXPECT_EQ(1, stream.num_duplicate_frames_received());
@@ -363,7 +363,7 @@
   QuicStreamFrame frame(kTestPendingStreamId, false, 2, ".");
   pending.OnStreamFrame(frame);
 
-  auto stream = new TestStream(&pending, session_.get(), false);
+  auto stream = new TestStream(pending, session_.get(), false);
   session_->ActivateStream(absl::WrapUnique(stream));
 
   QuicStreamFrame frame2(kTestPendingStreamId, true, 3, ".");
@@ -391,7 +391,7 @@
   QuicStreamFrame frame(kTestPendingStreamId, false, 2, ".");
   pending.OnStreamFrame(frame);
 
-  auto stream = new TestStream(&pending, session_.get(), false);
+  auto stream = new TestStream(pending, session_.get(), false);
   session_->ActivateStream(absl::WrapUnique(stream));
 
   EXPECT_FALSE(stream->rst_received());

quiche/quic/qbone/qbone_control_stream.cc

diff --git a/quiche/quic/qbone/qbone_control_stream.cc b/quiche/quic/qbone/qbone_control_stream.cc
index 38ef9f8..24f6bc5 100644
--- a/quiche/quic/qbone/qbone_control_stream.cc
+++ b/quiche/quic/qbone/qbone_control_stream.cc
@@ -26,12 +26,12 @@
           /*is_static=*/true, BIDIRECTIONAL),
       pending_message_size_(0) {}
 
-QboneControlStreamBase::QboneControlStreamBase(quic::PendingStream* pending,
+QboneControlStreamBase::QboneControlStreamBase(quic::PendingStream& pending,
                                                QuicSession* session)
     : QuicStream(pending, session, /*is_static=*/true),
       pending_message_size_(0) {
-  QUICHE_DCHECK_EQ(pending->id(), QboneConstants::GetControlStreamId(
-                                      session->transport_version()));
+  QUICHE_DCHECK_EQ(pending.id(), QboneConstants::GetControlStreamId(
+                                     session->transport_version()));
 }
 
 void QboneControlStreamBase::OnDataAvailable() {

quiche/quic/qbone/qbone_control_stream.h

diff --git a/quiche/quic/qbone/qbone_control_stream.h b/quiche/quic/qbone/qbone_control_stream.h
index 26d6a84..7e97770 100644
--- a/quiche/quic/qbone/qbone_control_stream.h
+++ b/quiche/quic/qbone/qbone_control_stream.h
@@ -16,7 +16,7 @@
 class QUIC_EXPORT_PRIVATE QboneControlStreamBase : public QuicStream {
  public:
   explicit QboneControlStreamBase(QuicSession* session);
-  QboneControlStreamBase(quic::PendingStream* pending, QuicSession* session);
+  QboneControlStreamBase(quic::PendingStream& pending, QuicSession* session);
 
   void OnDataAvailable() override;
 
@@ -47,7 +47,7 @@
 
   QboneControlStream(QuicSession* session, Handler* handler)
       : QboneControlStreamBase(session), handler_(handler) {}
-  QboneControlStream(quic::PendingStream* pending, QuicSession* session,
+  QboneControlStream(quic::PendingStream& pending, QuicSession* session,
                      Handler* handler)
       : QboneControlStreamBase(pending, session), handler_(handler) {}
 

quiche/quic/qbone/qbone_server_session.cc

diff --git a/quiche/quic/qbone/qbone_server_session.cc b/quiche/quic/qbone/qbone_server_session.cc
index 4c4ec18..a4354e7 100644
--- a/quiche/quic/qbone/qbone_server_session.cc
+++ b/quiche/quic/qbone/qbone_server_session.cc
@@ -67,7 +67,7 @@
   QUICHE_DCHECK(control_stream_ == nullptr);
   // Register the reserved control stream.
   auto control_stream =
-      std::make_unique<QboneServerControlStream>(pending, this, handler_);
+      std::make_unique<QboneServerControlStream>(*pending, this, handler_);
   control_stream_ = control_stream.get();
   ActivateStream(std::move(control_stream));
   return control_stream_;

quiche/quic/tools/quic_simple_server_session.cc

diff --git a/quiche/quic/tools/quic_simple_server_session.cc b/quiche/quic/tools/quic_simple_server_session.cc
index 6c74d90..7fd8ebf 100644
--- a/quiche/quic/tools/quic_simple_server_session.cc
+++ b/quiche/quic/tools/quic_simple_server_session.cc
@@ -72,7 +72,7 @@
 QuicSpdyStream* QuicSimpleServerSession::CreateIncomingStream(
     PendingStream* pending) {
   QuicSpdyStream* stream =
-      new QuicSimpleServerStream(pending, this, quic_simple_server_backend_);
+      new QuicSimpleServerStream(*pending, this, quic_simple_server_backend_);
   ActivateStream(absl::WrapUnique(stream));
   return stream;
 }

quiche/quic/tools/quic_simple_server_stream.cc

diff --git a/quiche/quic/tools/quic_simple_server_stream.cc b/quiche/quic/tools/quic_simple_server_stream.cc
index 0c53857..fee80f4 100644
--- a/quiche/quic/tools/quic_simple_server_stream.cc
+++ b/quiche/quic/tools/quic_simple_server_stream.cc
@@ -40,7 +40,7 @@
 }
 
 QuicSimpleServerStream::QuicSimpleServerStream(
-    PendingStream* pending, QuicSpdySession* session,
+    PendingStream& pending, QuicSpdySession* session,
     QuicSimpleServerBackend* quic_simple_server_backend)
     : QuicSpdyServerStreamBase(pending, session),
       content_length_(-1),

quiche/quic/tools/quic_simple_server_stream.h

diff --git a/quiche/quic/tools/quic_simple_server_stream.h b/quiche/quic/tools/quic_simple_server_stream.h
index 689f644..a83b5db 100644
--- a/quiche/quic/tools/quic_simple_server_stream.h
+++ b/quiche/quic/tools/quic_simple_server_stream.h
@@ -27,7 +27,7 @@
   QuicSimpleServerStream(QuicStreamId id, QuicSpdySession* session,
                          StreamType type,
                          QuicSimpleServerBackend* quic_simple_server_backend);
-  QuicSimpleServerStream(PendingStream* pending, QuicSpdySession* session,
+  QuicSimpleServerStream(PendingStream& pending, QuicSpdySession* session,
                          QuicSimpleServerBackend* quic_simple_server_backend);
   QuicSimpleServerStream(const QuicSimpleServerStream&) = delete;
   QuicSimpleServerStream& operator=(const QuicSimpleServerStream&) = delete;