diff --git a/quic/core/http/quic_receive_control_stream.cc b/quic/core/http/quic_receive_control_stream.cc
index 82d1fe1..62c9ba8 100644
--- a/quic/core/http/quic_receive_control_stream.cc
+++ b/quic/core/http/quic_receive_control_stream.cc
@@ -20,7 +20,10 @@
 QuicReceiveControlStream::QuicReceiveControlStream(
     PendingStream* pending,
     QuicSpdySession* spdy_session)
-    : QuicStream(pending, READ_UNIDIRECTIONAL, /*is_static=*/true),
+    : QuicStream(pending,
+                 spdy_session,
+                 READ_UNIDIRECTIONAL,
+                 /*is_static=*/true),
       settings_frame_received_(false),
       decoder_(this),
       spdy_session_(spdy_session) {
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 6b3d0c8..dded232 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -1239,7 +1239,7 @@
         return false;
       }
       auto encoder_receive = std::make_unique<QpackReceiveStream>(
-          pending, qpack_decoder_->encoder_stream_receiver());
+          pending, this, qpack_decoder_->encoder_stream_receiver());
       qpack_encoder_receive_stream_ = encoder_receive.get();
       ActivateStream(std::move(encoder_receive));
       qpack_encoder_receive_stream_->SetUnblocked();
@@ -1256,7 +1256,7 @@
         return false;
       }
       auto decoder_receive = std::make_unique<QpackReceiveStream>(
-          pending, qpack_encoder_->decoder_stream_receiver());
+          pending, this, qpack_encoder_->decoder_stream_receiver());
       qpack_decoder_receive_stream_ = decoder_receive.get();
       ActivateStream(std::move(decoder_receive));
       qpack_decoder_receive_stream_->SetUnblocked();
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index a14c3e5..67c24e4 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -220,7 +220,7 @@
 QuicSpdyStream::QuicSpdyStream(PendingStream* pending,
                                QuicSpdySession* spdy_session,
                                StreamType type)
-    : QuicStream(pending, type, /*is_static=*/false),
+    : QuicStream(pending, spdy_session, type, /*is_static=*/false),
       spdy_session_(spdy_session),
       on_body_available_called_because_sequencer_is_closed_(false),
       visitor_(nullptr),
diff --git a/quic/core/qpack/qpack_receive_stream.cc b/quic/core/qpack/qpack_receive_stream.cc
index d2fc88b..b2f15c4 100644
--- a/quic/core/qpack/qpack_receive_stream.cc
+++ b/quic/core/qpack/qpack_receive_stream.cc
@@ -9,8 +9,9 @@
 
 namespace quic {
 QpackReceiveStream::QpackReceiveStream(PendingStream* pending,
+                                       QuicSession* session,
                                        QpackStreamReceiver* receiver)
-    : QuicStream(pending, READ_UNIDIRECTIONAL, /*is_static=*/true),
+    : QuicStream(pending, session, READ_UNIDIRECTIONAL, /*is_static=*/true),
       receiver_(receiver) {}
 
 void QpackReceiveStream::OnStreamReset(const QuicRstStreamFrame& /*frame*/) {
diff --git a/quic/core/qpack/qpack_receive_stream.h b/quic/core/qpack/qpack_receive_stream.h
index 0613871..0814985 100644
--- a/quic/core/qpack/qpack_receive_stream.h
+++ b/quic/core/qpack/qpack_receive_stream.h
@@ -19,7 +19,9 @@
  public:
   // Construct receive stream from pending stream, the |pending| object needs
   // to be deleted after the construction.
-  QpackReceiveStream(PendingStream* pending, QpackStreamReceiver* receiver);
+  QpackReceiveStream(PendingStream* pending,
+                     QuicSession* session,
+                     QpackStreamReceiver* receiver);
   QpackReceiveStream(const QpackReceiveStream&) = delete;
   QpackReceiveStream& operator=(const QpackReceiveStream&) = delete;
   ~QpackReceiveStream() override = default;
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 37f1305..62c012c 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -165,8 +165,8 @@
              StreamType type)
       : QuicStream(id, session, is_static, type) {}
 
-  TestStream(PendingStream* pending, StreamType type)
-      : QuicStream(pending, type, /*is_static=*/false) {}
+  TestStream(PendingStream* pending, QuicSession* session, StreamType type)
+      : QuicStream(pending, session, type, /*is_static=*/false) {}
 
   using QuicStream::CloseWriteSide;
   using QuicStream::WriteMemSlices;
@@ -257,8 +257,9 @@
   TestStream* CreateIncomingStream(PendingStream* pending) override {
     QuicStreamId id = pending->id();
     TestStream* stream = new TestStream(
-        pending, DetermineStreamType(id, connection()->version(), perspective(),
-                                     /*is_incoming=*/true, BIDIRECTIONAL));
+        pending, this,
+        DetermineStreamType(id, connection()->version(), perspective(),
+                            /*is_incoming=*/true, BIDIRECTIONAL));
     ActivateStream(QuicWrapUnique(stream));
     ++num_incoming_streams_created_;
     return stream;
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index d965fa7..a5be981 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -111,7 +111,6 @@
 
 PendingStream::PendingStream(QuicStreamId id, QuicSession* session)
     : id_(id),
-      session_(session),
       stream_delegate_(session),
       stream_bytes_read_(0),
       fin_received_(false),
@@ -122,8 +121,8 @@
                        GetReceivedFlowControlWindow(session, id),
                        GetInitialStreamFlowControlWindowToSend(session, id),
                        kStreamReceiveWindowLimit,
-                       session_->flow_controller()->auto_tune_receive_window(),
-                       session_->flow_controller()),
+                       session->flow_controller()->auto_tune_receive_window(),
+                       session->flow_controller()),
       sequencer_(this) {}
 
 void PendingStream::OnDataAvailable() {
@@ -264,9 +263,12 @@
   sequencer_.StopReading();
 }
 
-QuicStream::QuicStream(PendingStream* pending, StreamType type, bool is_static)
+QuicStream::QuicStream(PendingStream* pending,
+                       QuicSession* session,
+                       StreamType type,
+                       bool is_static)
     : QuicStream(pending->id_,
-                 pending->session_,
+                 session,
                  std::move(pending->sequencer_),
                  is_static,
                  type,
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index 8f669ca..f808d50 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -90,9 +90,7 @@
   // ID of this stream.
   QuicStreamId id_;
 
-  // Session which owns this.
-  // TODO(b/136274541): Remove session pointer from streams.
-  QuicSession* session_;
+  // |stream_delegate_| must outlive this stream.
   StreamDelegateInterface* stream_delegate_;
 
   // Bytes read refers to payload bytes only: they do not include framing,
@@ -133,7 +131,10 @@
              QuicSession* session,
              bool is_static,
              StreamType type);
-  QuicStream(PendingStream* pending, StreamType type, bool is_static);
+  QuicStream(PendingStream* pending,
+             QuicSession* session,
+             StreamType type,
+             bool is_static);
   QuicStream(const QuicStream&) = delete;
   QuicStream& operator=(const QuicStream&) = delete;
 
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index 2313852..f2b5563 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -58,8 +58,11 @@
     sequencer()->set_level_triggered(true);
   }
 
-  TestStream(PendingStream* pending, StreamType type, bool is_static)
-      : QuicStream(pending, type, is_static) {}
+  TestStream(PendingStream* pending,
+             QuicSession* session,
+             StreamType type,
+             bool is_static)
+      : QuicStream(pending, session, type, is_static) {}
 
   MOCK_METHOD(void, OnDataAvailable, (), (override));
 
@@ -169,11 +172,12 @@
   Initialize();
 
   PendingStream pending(kTestStreamId + 2, session_.get());
-  TestStream stream(&pending, StreamType::BIDIRECTIONAL, false);
+  TestStream stream(&pending, session_.get(), StreamType::BIDIRECTIONAL, false);
   EXPECT_FALSE(stream.is_static());
 
   PendingStream pending2(kTestStreamId + 3, session_.get());
-  TestStream stream2(&pending2, StreamType::BIDIRECTIONAL, true);
+  TestStream stream2(&pending2, session_.get(), StreamType::BIDIRECTIONAL,
+                     true);
   EXPECT_TRUE(stream2.is_static());
 }
 
@@ -233,7 +237,8 @@
   QuicStreamFrame frame2(kTestStreamId + 2, true, 3, ".");
   pending.OnStreamFrame(frame2);
 
-  TestStream stream(&pending, StreamType::READ_UNIDIRECTIONAL, false);
+  TestStream stream(&pending, session_.get(), StreamType::READ_UNIDIRECTIONAL,
+                    false);
   EXPECT_EQ(3, stream.num_frames_received());
   EXPECT_EQ(3u, stream.stream_bytes_read());
   EXPECT_EQ(1, stream.num_duplicate_frames_received());
@@ -251,8 +256,8 @@
   QuicStreamFrame frame(kTestStreamId + 2, false, 2, ".");
   pending.OnStreamFrame(frame);
 
-  auto stream =
-      new TestStream(&pending, StreamType::READ_UNIDIRECTIONAL, false);
+  auto stream = new TestStream(&pending, session_.get(),
+                               StreamType::READ_UNIDIRECTIONAL, false);
   session_->ActivateStream(QuicWrapUnique(stream));
 
   QuicStreamFrame frame2(kTestStreamId + 2, true, 3, ".");