diff --git a/quic/core/congestion_control/general_loss_algorithm_test.cc b/quic/core/congestion_control/general_loss_algorithm_test.cc
index f2ebbb2..4fdd05f 100644
--- a/quic/core/congestion_control/general_loss_algorithm_test.cc
+++ b/quic/core/congestion_control/general_loss_algorithm_test.cc
@@ -34,8 +34,9 @@
 
   void SendDataPacket(uint64_t packet_number) {
     QuicStreamFrame frame;
-    frame.stream_id = QuicUtils::GetHeadersStreamId(
-        CurrentSupportedVersions()[0].transport_version);
+    frame.stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+        CurrentSupportedVersions()[0].transport_version,
+        Perspective::IS_CLIENT);
     SerializedPacket packet(QuicPacketNumber(packet_number),
                             PACKET_1BYTE_PACKET_NUMBER, nullptr, kDefaultLength,
                             false, false);
diff --git a/quic/core/congestion_control/uber_loss_algorithm_test.cc b/quic/core/congestion_control/uber_loss_algorithm_test.cc
index 0c79ac5..c70f176 100644
--- a/quic/core/congestion_control/uber_loss_algorithm_test.cc
+++ b/quic/core/congestion_control/uber_loss_algorithm_test.cc
@@ -32,7 +32,8 @@
     QuicStreamFrame frame;
     QuicTransportVersion version =
         CurrentSupportedVersions()[0].transport_version;
-    frame.stream_id = QuicUtils::GetHeadersStreamId(version);
+    frame.stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+        version, Perspective::IS_CLIENT);
     if (encryption_level == ENCRYPTION_INITIAL) {
       if (QuicVersionUsesCryptoFrames(version)) {
         frame.stream_id = QuicUtils::GetFirstBidirectionalStreamId(
diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index ecca4e7..2236d42 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -531,8 +531,14 @@
       &bandwidth_recorder, max_bandwidth_estimate_kbytes_per_second,
       max_bandwidth_estimate_timestamp);
   // Queue up some pending data.
-  session_->MarkConnectionLevelWriteBlocked(
-      QuicUtils::GetHeadersStreamId(connection_->transport_version()));
+  if (!VersionUsesQpack(transport_version())) {
+    session_->MarkConnectionLevelWriteBlocked(
+        QuicUtils::GetHeadersStreamId(connection_->transport_version()));
+  } else {
+    session_->MarkConnectionLevelWriteBlocked(
+        QuicUtils::GetFirstUnidirectionalStreamId(
+            connection_->transport_version(), Perspective::IS_SERVER));
+  }
   EXPECT_TRUE(session_->HasDataToWrite());
 
   // There will be no update sent yet - not enough time has passed.
diff --git a/quic/core/http/quic_spdy_client_session_test.cc b/quic/core/http/quic_spdy_client_session_test.cc
index fc42d52..6819e9a 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -431,10 +431,24 @@
   trailers.OnHeader(kFinalOffsetHeaderKey, "0");
   trailers.OnHeaderBlockEnd(0, 0);
 
-  EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(1);
-  session_->OnStreamHeaderList(
-      QuicUtils::GetHeadersStreamId(connection_->transport_version()),
-      /*fin=*/false, 0, trailers);
+  // Initialize H/3 control stream.
+  QuicStreamId id;
+  if (VersionUsesQpack(connection_->transport_version())) {
+    id = GetNthServerInitiatedUnidirectionalStreamId(
+        connection_->transport_version(), 3);
+    char type[] = {0x00};
+
+    QuicStreamFrame data1(id, false, 0, QuicStringPiece(type, 1));
+    session_->OnStreamFrame(data1);
+  } else {
+    id = QuicUtils::GetHeadersStreamId(connection_->transport_version());
+  }
+
+  EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
+                                            "stream is static", _))
+      .Times(1);
+  session_->OnStreamHeaderList(id,
+                               /*fin=*/false, 0, trailers);
 }
 
 TEST_P(QuicSpdyClientSessionTest, OnPromiseHeaderListWithStaticStream) {
@@ -459,7 +473,9 @@
   } else {
     id = QuicUtils::GetHeadersStreamId(connection_->transport_version());
   }
-  EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(1);
+  EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
+                                            "stream is static", _))
+      .Times(1);
   session_->OnPromiseHeaderList(id, promised_stream_id_, 0, trailers);
 }
 
diff --git a/quic/core/quic_packet_generator_test.cc b/quic/core/quic_packet_generator_test.cc
index 0e71e44..9c2e3f3 100644
--- a/quic/core/quic_packet_generator_test.cc
+++ b/quic/core/quic_packet_generator_test.cc
@@ -430,8 +430,9 @@
 
   MakeIOVector("foo", &iov_);
   QuicConsumedData consumed = generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len, 0, FIN);
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len, 0, FIN);
   EXPECT_EQ(0u, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
   EXPECT_FALSE(generator_.HasPendingFrames());
@@ -443,8 +444,9 @@
 
   MakeIOVector("foo", &iov_);
   QuicConsumedData consumed = generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len, 0, FIN);
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len, 0, FIN);
   EXPECT_EQ(3u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
   EXPECT_TRUE(generator_.HasPendingFrames());
@@ -458,8 +460,9 @@
       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
   MakeIOVector("foo", &iov_);
   QuicConsumedData consumed = generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len, 0, FIN);
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len, 0, FIN);
   generator_.Flush();
   EXPECT_EQ(3u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
@@ -564,9 +567,10 @@
 TEST_F(QuicPacketGeneratorTest, ConsumeData_EmptyData) {
   delegate_.SetCanWriteAnything();
 
-  EXPECT_QUIC_BUG(generator_.ConsumeData(QuicUtils::GetHeadersStreamId(
-                                             framer_.transport_version()),
-                                         nullptr, 0, 0, 0, NO_FIN),
+  EXPECT_QUIC_BUG(generator_.ConsumeData(
+                      QuicUtils::QuicUtils::GetFirstBidirectionalStreamId(
+                          framer_.transport_version(), Perspective::IS_CLIENT),
+                      nullptr, 0, 0, 0, NO_FIN),
                   "Attempt to consume empty data without FIN.");
 }
 
@@ -576,8 +580,9 @@
 
   MakeIOVector("foo", &iov_);
   generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len, 0, FIN);
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len, 0, FIN);
   MakeIOVector("quux", &iov_);
   QuicConsumedData consumed =
       generator_.ConsumeData(3, &iov_, 1u, iov_.iov_len, 3, NO_FIN);
@@ -592,12 +597,14 @@
 
   MakeIOVector("foo", &iov_);
   generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len, 0, FIN);
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len, 0, FIN);
   MakeIOVector("quux", &iov_);
   QuicConsumedData consumed = generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len, 3, NO_FIN);
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len, 3, NO_FIN);
   EXPECT_EQ(4u, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
   EXPECT_TRUE(generator_.HasPendingFrames());
@@ -650,8 +657,9 @@
   // fitting.
   MakeIOVector("foo", &iov_);
   QuicConsumedData consumed = generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len, 0, NO_FIN);
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len, 0, NO_FIN);
   EXPECT_EQ(3u, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
   EXPECT_TRUE(generator_.HasPendingFrames());
@@ -661,8 +669,9 @@
   // to be serialized, and it will be added to a new open packet.
   MakeIOVector("bar", &iov_);
   consumed = generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len, 3, FIN);
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len, 3, FIN);
   EXPECT_EQ(3u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
   EXPECT_TRUE(generator_.HasPendingFrames());
@@ -688,8 +697,9 @@
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillRepeatedly(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
   QuicConsumedData consumed = generator_.ConsumeDataFastPath(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len, 0, true);
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len, 0, true);
   EXPECT_EQ(10000u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
   EXPECT_FALSE(generator_.HasPendingFrames());
@@ -716,8 +726,9 @@
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillRepeatedly(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
   QuicConsumedData consumed = generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len, 0, FIN);
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len, 0, FIN);
   EXPECT_EQ(10000u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
   EXPECT_FALSE(generator_.HasPendingFrames());
@@ -759,8 +770,9 @@
       QuicFrame(CreateRstStreamFrame()),
       /*bundle_ack=*/true);
   QuicConsumedData consumed = generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len, 0, FIN);
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len, 0, FIN);
   generator_.Flush();
 
   EXPECT_EQ(10000u, consumed.bytes_consumed);
@@ -789,8 +801,9 @@
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillRepeatedly(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
   QuicConsumedData consumed = generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len, 0, FIN);
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len, 0, FIN);
   generator_.Flush();
 
   EXPECT_EQ(10000u, consumed.bytes_consumed);
@@ -925,8 +938,8 @@
 
   size_t data_len = 1324;
   CreateData(data_len);
-  QuicStreamId stream1_id =
-      QuicUtils::GetHeadersStreamId(framer_.transport_version());
+  QuicStreamId stream1_id = QuicUtils::GetFirstBidirectionalStreamId(
+      framer_.transport_version(), Perspective::IS_CLIENT);
   QuicConsumedData consumed =
       generator_.ConsumeData(stream1_id, &iov_, 1u, iov_.iov_len, 0, NO_FIN);
   EXPECT_EQ(data_len, consumed.bytes_consumed);
@@ -993,8 +1006,9 @@
       .WillRepeatedly(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
   CreateData(data_len);
   QuicConsumedData consumed = generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len,
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len,
       /*offset=*/0, FIN);
   EXPECT_EQ(data_len, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
@@ -1030,8 +1044,9 @@
   // Send two packets before packet size change.
   CreateData(data_len);
   QuicConsumedData consumed = generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len,
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len,
       /*offset=*/0, NO_FIN);
   generator_.Flush();
   EXPECT_EQ(data_len, consumed.bytes_consumed);
@@ -1050,8 +1065,9 @@
   CreateData(data_len);
   generator_.AttachPacketFlusher();
   consumed = generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len, data_len, FIN);
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len, data_len, FIN);
   generator_.Flush();
   EXPECT_EQ(data_len, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
@@ -1080,8 +1096,9 @@
   // should not cause packet serialization.
   CreateData(first_write_len);
   QuicConsumedData consumed = generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len,
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len,
       /*offset=*/0, NO_FIN);
   EXPECT_EQ(first_write_len, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
@@ -1113,8 +1130,9 @@
   // trigger serialization of one packet, and queue another one.
   CreateData(second_write_len);
   consumed = generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len,
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len,
       /*offset=*/first_write_len, FIN);
   EXPECT_EQ(second_write_len, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
@@ -1201,8 +1219,9 @@
   // Send data before the MTU probe.
   CreateData(data_len);
   QuicConsumedData consumed = generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len,
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len,
       /*offset=*/0, NO_FIN);
   generator_.Flush();
   EXPECT_EQ(data_len, consumed.bytes_consumed);
@@ -1219,8 +1238,9 @@
   CreateData(data_len);
   generator_.AttachPacketFlusher();
   consumed = generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len,
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len,
       /*offset=*/data_len, FIN);
   generator_.Flush();
   EXPECT_EQ(data_len, consumed.bytes_consumed);
@@ -1445,8 +1465,9 @@
 
   MakeIOVector("foo", &iov_);
   generator_.ConsumeData(
-      QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
-      iov_.iov_len, 0, FIN);
+      QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
+                                               Perspective::IS_CLIENT),
+      &iov_, 1u, iov_.iov_len, 0, FIN);
   EXPECT_EQ(MESSAGE_STATUS_SUCCESS,
             generator_.AddMessageFrame(
                 1, MakeSpan(&allocator_, "message", &storage)));
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index ee9676f..d371866 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -143,9 +143,9 @@
   uint32_t initial_flow_control_window_bytes_;
   QuicTime::Delta zero_;
   ParsedQuicVersionVector supported_versions_;
-  const QuicStreamId kTestStreamId =
-      QuicUtils::GetHeadersStreamId(GetParam().transport_version) +
-      QuicUtils::StreamIdDelta(GetParam().transport_version);
+  QuicStreamId kTestStreamId =
+      GetNthClientInitiatedBidirectionalStreamId(GetParam().transport_version,
+                                                 1);
 };
 
 // Non parameterized QuicStreamTest used for tests that do not
diff --git a/quic/core/quic_unacked_packet_map_test.cc b/quic/core/quic_unacked_packet_map_test.cc
index 807a959..5dda2ae 100644
--- a/quic/core/quic_unacked_packet_map_test.cc
+++ b/quic/core/quic_unacked_packet_map_test.cc
@@ -68,8 +68,9 @@
 
   SerializedPacket CreateRetransmittablePacket(uint64_t packet_number) {
     return CreateRetransmittablePacketForStream(
-        packet_number, QuicUtils::GetHeadersStreamId(
-                           CurrentSupportedVersions()[0].transport_version));
+        packet_number, QuicUtils::GetFirstBidirectionalStreamId(
+                           CurrentSupportedVersions()[0].transport_version,
+                           Perspective::IS_CLIENT));
   }
 
   SerializedPacket CreateRetransmittablePacketForStream(
@@ -174,8 +175,9 @@
     }
     QuicTransmissionInfo* info = unacked_packets_.GetMutableTransmissionInfo(
         QuicPacketNumber(old_packet_number));
-    QuicStreamId stream_id = QuicUtils::GetHeadersStreamId(
-        CurrentSupportedVersions()[0].transport_version);
+    QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+        CurrentSupportedVersions()[0].transport_version,
+        Perspective::IS_CLIENT);
     for (const auto& frame : info->retransmittable_frames) {
       if (frame.type == STREAM_FRAME) {
         stream_id = frame.stream_frame.stream_id;
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index 58996f6..1e2c5fc 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -401,7 +401,7 @@
 
 // static
 QuicStreamId QuicUtils::GetHeadersStreamId(QuicTransportVersion version) {
-  // TODO(b/138653948): Add DCHECK(!VersionUsesQpack(version));
+  DCHECK(!VersionUsesQpack(version));
   return GetFirstBidirectionalStreamId(version, Perspective::IS_CLIENT);
 }