diff --git a/quic/core/http/quic_spdy_client_stream_test.cc b/quic/core/http/quic_spdy_client_stream_test.cc
index 1aba000..ffd4590 100644
--- a/quic/core/http/quic_spdy_client_stream_test.cc
+++ b/quic/core/http/quic_spdy_client_stream_test.cc
@@ -48,6 +48,8 @@
 
   MOCK_METHOD(void, CloseStream, (QuicStreamId stream_id), (override));
 
+  using QuicSession::ActivateStream;
+
  private:
   QuicCryptoClientConfig crypto_config_;
 };
@@ -67,14 +69,18 @@
                  &push_promise_index_),
         body_("hello world") {
     session_.Initialize();
+    connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
 
     headers_[":status"] = "200";
     headers_["content-length"] = "11";
 
-    stream_ = std::make_unique<QuicSpdyClientStream>(
+    auto stream = std::make_unique<QuicSpdyClientStream>(
         GetNthClientInitiatedBidirectionalStreamId(
             connection_->transport_version(), 0),
         &session_, BIDIRECTIONAL);
+    stream_ = stream.get();
+    session_.ActivateStream(std::move(stream));
+
     stream_visitor_ = std::make_unique<StreamVisitor>();
     stream_->set_visitor(stream_visitor_.get());
   }
@@ -91,7 +97,7 @@
   QuicClientPushPromiseIndex push_promise_index_;
 
   MockQuicSpdyClientSession session_;
-  std::unique_ptr<QuicSpdyClientStream> stream_;
+  QuicSpdyClientStream* stream_;
   std::unique_ptr<StreamVisitor> stream_visitor_;
   SpdyHeaderBlock headers_;
   std::string body_;
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index fea8541..df83890 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -161,6 +161,9 @@
 
   MOCK_METHOD(bool, HasPendingRetransmission, (), (const, override));
 
+  void OnConnectionClosed(QuicErrorCode /*error*/,
+                          ConnectionCloseSource /*source*/) override {}
+
  private:
   using QuicCryptoStream::session;
 
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index d83823b..e09decf 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -867,17 +867,17 @@
   QUIC_DVLOG(1) << ENDPOINT << "Closing stream: " << stream_id;
   StreamMap::iterator it = stream_map_.find(stream_id);
   if (it == stream_map_.end()) {
-    QUIC_DVLOG(1) << ENDPOINT << "Stream is already closed: " << stream_id;
+    QUIC_BUG << ENDPOINT << "Stream is already closed: " << stream_id;
     return;
   }
   QuicStream* stream = it->second.get();
   StreamType type = stream->type();
 
   if (stream->IsWaitingForAcks()) {
-    zombie_streams_[stream->id()] = std::move(it->second);
+    zombie_streams_[stream_id] = std::move(it->second);
   } else {
     // Clean up the stream since it is no longer waiting for acks.
-    streams_waiting_for_acks_.erase(stream->id());
+    streams_waiting_for_acks_.erase(stream_id);
     closed_streams_.push_back(std::move(it->second));
     // Do not retransmit data of a closed stream.
     streams_with_pending_retransmission_.erase(stream_id);
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 8459269..54c7bfb 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -144,6 +144,9 @@
 
   MOCK_METHOD(bool, HasPendingRetransmission, (), (const, override));
 
+  void OnConnectionClosed(QuicErrorCode /*error*/,
+                          ConnectionCloseSource /*source*/) override {}
+
  private:
   using QuicCryptoStream::session;
 
