diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index e0e417a..8217cd7 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -395,12 +395,6 @@
     if (perspective == Perspective::IS_SERVER) {
       id |= 0x1;
     }
-    if (bidirectional && perspective == Perspective::IS_CLIENT &&
-        QuicVersionUsesCryptoFrames(transport_version())) {
-      // Once stream ID 0 is used as a normal client initiated bidirectional
-      // stream, this shouldn't be needed any more.
-      id += 4;
-    }
     return id;
   }
 
@@ -1564,7 +1558,7 @@
     EXPECT_CALL(
         *connection_,
         CloseConnection(QUIC_INVALID_STREAM_ID,
-                        "Stream id 28 would exceed stream count limit 6", _));
+                        "Stream id 24 would exceed stream count limit 6", _));
   }
   // Create one more data streams to exceed limit of open stream.
   QuicStreamFrame data1(kFinalStreamId, false, 0, QuicStringPiece("HT"));
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 96f98ad..abc6331 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -51,7 +51,7 @@
                          const ParsedQuicVersionVector& supported_versions)
     : connection_(connection),
       visitor_(owner),
-      write_blocked_streams_(),
+      write_blocked_streams_(connection->transport_version()),
       config_(config),
       stream_id_manager_(this,
                          kDefaultMaxStreamsPerConnection,
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index deb6643..5af49fa 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -423,10 +423,6 @@
     if (perspective == Perspective::IS_SERVER) {
       id |= 0x1;
     }
-    if (QuicVersionUsesCryptoFrames(connection_->transport_version()) &&
-        bidirectional && perspective == Perspective::IS_CLIENT) {
-      id += 4;
-    }
     return id;
   }
 
@@ -787,13 +783,16 @@
                            GetNthClientInitiatedBidirectionalId(49)));
     // and this should fail because it exceeds the bnidirectional limit
     // (but not the uni-)
+    std::string error_detail;
+    if (QuicVersionUsesCryptoFrames(transport_version())) {
+      error_detail = "Stream id 796 would exceed stream count limit 50";
+    } else {
+      error_detail = "Stream id 800 would exceed stream count limit 50";
+    }
     EXPECT_CALL(
         *connection_,
-        CloseConnection(QUIC_INVALID_STREAM_ID,
-                        "Stream id 800 would exceed stream count limit 50",
-                        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET
-
-                        ))
+        CloseConnection(QUIC_INVALID_STREAM_ID, error_detail,
+                        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET))
         .Times(1);
     EXPECT_EQ(nullptr, session_.GetOrCreateDynamicStream(
                            GetNthClientInitiatedBidirectionalId(199)));
@@ -1648,7 +1647,7 @@
     EXPECT_CALL(
         *connection_,
         CloseConnection(QUIC_INVALID_STREAM_ID,
-                        "Stream id 24 would exceed stream count limit 5", _));
+                        "Stream id 20 would exceed stream count limit 5", _));
   } else {
     EXPECT_CALL(*connection_, SendControlFrame(_)).Times(1);
     EXPECT_CALL(*connection_,
@@ -2385,7 +2384,7 @@
   EXPECT_CALL(
       *connection_,
       CloseConnection(QUIC_INVALID_STREAM_ID,
-                      "Stream id 404 would exceed stream count limit 100", _));
+                      "Stream id 400 would exceed stream count limit 100", _));
   session_.OnStreamFrame(bidirectional_stream_frame);
 
   QuicStreamId unidirectional_stream_id = StreamCountToId(
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index dc40122..a7fe40f 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -399,7 +399,7 @@
 
 // static
 QuicStreamId QuicUtils::GetHeadersStreamId(QuicTransportVersion version) {
-  return version == QUIC_VERSION_99 ? 4 : 3;
+  return GetFirstBidirectionalStreamId(version, Perspective::IS_CLIENT);
 }
 
 // static
@@ -461,19 +461,26 @@
 QuicStreamId QuicUtils::GetFirstBidirectionalStreamId(
     QuicTransportVersion version,
     Perspective perspective) {
-  if (perspective == Perspective::IS_CLIENT) {
-    // TODO(nharper): Return 0 instead of 4 when CRYPTO frames are used.
-    return version == QUIC_VERSION_99 ? 4 : 3;
+  if (version == QUIC_VERSION_99) {
+    return perspective == Perspective::IS_CLIENT ? 0 : 1;
+  } else if (QuicVersionUsesCryptoFrames(version)) {
+    return perspective == Perspective::IS_CLIENT ? 1 : 2;
   }
-  return version == QUIC_VERSION_99 ? 1 : 2;
+  return perspective == Perspective::IS_CLIENT ? 3 : 2;
 }
 
 // static
 QuicStreamId QuicUtils::GetFirstUnidirectionalStreamId(
     QuicTransportVersion version,
     Perspective perspective) {
+  if (version == QUIC_VERSION_99) {
+    return perspective == Perspective::IS_CLIENT ? 2 : 3;
+  } else if (QuicVersionUsesCryptoFrames(version)) {
+    return perspective == Perspective::IS_CLIENT ? 1 : 2;
+  }
+  return perspective == Perspective::IS_CLIENT ? 3 : 2;
   if (perspective == Perspective::IS_CLIENT) {
-    return version == QUIC_VERSION_99 ? 2 : 3;
+    return version == QUIC_VERSION_99 ? 2 : 1;
   }
   return version == QUIC_VERSION_99 ? 3 : 2;
 }
diff --git a/quic/core/quic_write_blocked_list.cc b/quic/core/quic_write_blocked_list.cc
index e392955..d7fe3c0 100644
--- a/quic/core/quic_write_blocked_list.cc
+++ b/quic/core/quic_write_blocked_list.cc
@@ -9,7 +9,11 @@
 
 namespace quic {
 
-QuicWriteBlockedList::QuicWriteBlockedList() : last_priority_popped_(0) {
+QuicWriteBlockedList::QuicWriteBlockedList(QuicTransportVersion version)
+    : priority_write_scheduler_(QuicVersionUsesCryptoFrames(version)
+                                    ? std::numeric_limits<QuicStreamId>::max()
+                                    : 0),
+      last_priority_popped_(0) {
   memset(batch_write_stream_id_, 0, sizeof(batch_write_stream_id_));
   memset(bytes_left_for_batch_write_, 0, sizeof(bytes_left_for_batch_write_));
 }
diff --git a/quic/core/quic_write_blocked_list.h b/quic/core/quic_write_blocked_list.h
index 83c2e20..eca7c1a 100644
--- a/quic/core/quic_write_blocked_list.h
+++ b/quic/core/quic_write_blocked_list.h
@@ -24,7 +24,7 @@
   typedef spdy::PriorityWriteScheduler<QuicStreamId> QuicPriorityWriteScheduler;
 
  public:
-  explicit QuicWriteBlockedList();
+  explicit QuicWriteBlockedList(QuicTransportVersion version);
   QuicWriteBlockedList(const QuicWriteBlockedList&) = delete;
   QuicWriteBlockedList& operator=(const QuicWriteBlockedList&) = delete;
   ~QuicWriteBlockedList();
diff --git a/quic/core/quic_write_blocked_list_test.cc b/quic/core/quic_write_blocked_list_test.cc
index a9319e3..30bb08e 100644
--- a/quic/core/quic_write_blocked_list_test.cc
+++ b/quic/core/quic_write_blocked_list_test.cc
@@ -14,218 +14,214 @@
 namespace test {
 namespace {
 
-class QuicWriteBlockedListTest : public QuicTest {};
+class QuicWriteBlockedListTest : public QuicTest {
+ public:
+  QuicWriteBlockedListTest()
+      : write_blocked_list_(AllSupportedVersions()[0].transport_version) {}
+
+ protected:
+  QuicWriteBlockedList write_blocked_list_;
+};
 
 TEST_F(QuicWriteBlockedListTest, PriorityOrder) {
-  QuicWriteBlockedList write_blocked_list;
-
   // Mark streams blocked in roughly reverse priority order, and
   // verify that streams are sorted.
-  write_blocked_list.RegisterStream(40, false, kV3LowestPriority);
-  write_blocked_list.RegisterStream(23, false, kV3HighestPriority);
-  write_blocked_list.RegisterStream(17, false, kV3HighestPriority);
-  write_blocked_list.RegisterStream(1, true, kV3HighestPriority);
-  write_blocked_list.RegisterStream(3, true, kV3HighestPriority);
+  write_blocked_list_.RegisterStream(40, false, kV3LowestPriority);
+  write_blocked_list_.RegisterStream(23, false, kV3HighestPriority);
+  write_blocked_list_.RegisterStream(17, false, kV3HighestPriority);
+  write_blocked_list_.RegisterStream(1, true, kV3HighestPriority);
+  write_blocked_list_.RegisterStream(3, true, kV3HighestPriority);
 
-  write_blocked_list.AddStream(40);
-  EXPECT_TRUE(write_blocked_list.IsStreamBlocked(40));
-  write_blocked_list.AddStream(23);
-  EXPECT_TRUE(write_blocked_list.IsStreamBlocked(23));
-  write_blocked_list.AddStream(17);
-  EXPECT_TRUE(write_blocked_list.IsStreamBlocked(17));
-  write_blocked_list.AddStream(3);
-  EXPECT_TRUE(write_blocked_list.IsStreamBlocked(3));
-  write_blocked_list.AddStream(1);
-  EXPECT_TRUE(write_blocked_list.IsStreamBlocked(1));
+  write_blocked_list_.AddStream(40);
+  EXPECT_TRUE(write_blocked_list_.IsStreamBlocked(40));
+  write_blocked_list_.AddStream(23);
+  EXPECT_TRUE(write_blocked_list_.IsStreamBlocked(23));
+  write_blocked_list_.AddStream(17);
+  EXPECT_TRUE(write_blocked_list_.IsStreamBlocked(17));
+  write_blocked_list_.AddStream(3);
+  EXPECT_TRUE(write_blocked_list_.IsStreamBlocked(3));
+  write_blocked_list_.AddStream(1);
+  EXPECT_TRUE(write_blocked_list_.IsStreamBlocked(1));
 
-  EXPECT_EQ(5u, write_blocked_list.NumBlockedStreams());
-  EXPECT_TRUE(write_blocked_list.HasWriteBlockedSpecialStream());
-  EXPECT_EQ(2u, write_blocked_list.NumBlockedSpecialStreams());
-  EXPECT_TRUE(write_blocked_list.HasWriteBlockedDataStreams());
+  EXPECT_EQ(5u, write_blocked_list_.NumBlockedStreams());
+  EXPECT_TRUE(write_blocked_list_.HasWriteBlockedSpecialStream());
+  EXPECT_EQ(2u, write_blocked_list_.NumBlockedSpecialStreams());
+  EXPECT_TRUE(write_blocked_list_.HasWriteBlockedDataStreams());
   // The Crypto stream is highest priority.
-  EXPECT_EQ(1u, write_blocked_list.PopFront());
-  EXPECT_EQ(1u, write_blocked_list.NumBlockedSpecialStreams());
-  EXPECT_FALSE(write_blocked_list.IsStreamBlocked(1));
+  EXPECT_EQ(1u, write_blocked_list_.PopFront());
+  EXPECT_EQ(1u, write_blocked_list_.NumBlockedSpecialStreams());
+  EXPECT_FALSE(write_blocked_list_.IsStreamBlocked(1));
   // Followed by the Headers stream.
-  EXPECT_EQ(3u, write_blocked_list.PopFront());
-  EXPECT_EQ(0u, write_blocked_list.NumBlockedSpecialStreams());
-  EXPECT_FALSE(write_blocked_list.IsStreamBlocked(3));
+  EXPECT_EQ(3u, write_blocked_list_.PopFront());
+  EXPECT_EQ(0u, write_blocked_list_.NumBlockedSpecialStreams());
+  EXPECT_FALSE(write_blocked_list_.IsStreamBlocked(3));
   // Streams with same priority are popped in the order they were inserted.
-  EXPECT_EQ(23u, write_blocked_list.PopFront());
-  EXPECT_FALSE(write_blocked_list.IsStreamBlocked(23));
-  EXPECT_EQ(17u, write_blocked_list.PopFront());
-  EXPECT_FALSE(write_blocked_list.IsStreamBlocked(17));
+  EXPECT_EQ(23u, write_blocked_list_.PopFront());
+  EXPECT_FALSE(write_blocked_list_.IsStreamBlocked(23));
+  EXPECT_EQ(17u, write_blocked_list_.PopFront());
+  EXPECT_FALSE(write_blocked_list_.IsStreamBlocked(17));
   // Low priority stream appears last.
-  EXPECT_EQ(40u, write_blocked_list.PopFront());
-  EXPECT_FALSE(write_blocked_list.IsStreamBlocked(40));
+  EXPECT_EQ(40u, write_blocked_list_.PopFront());
+  EXPECT_FALSE(write_blocked_list_.IsStreamBlocked(40));
 
-  EXPECT_EQ(0u, write_blocked_list.NumBlockedStreams());
-  EXPECT_FALSE(write_blocked_list.HasWriteBlockedSpecialStream());
-  EXPECT_FALSE(write_blocked_list.HasWriteBlockedDataStreams());
+  EXPECT_EQ(0u, write_blocked_list_.NumBlockedStreams());
+  EXPECT_FALSE(write_blocked_list_.HasWriteBlockedSpecialStream());
+  EXPECT_FALSE(write_blocked_list_.HasWriteBlockedDataStreams());
 }
 
 TEST_F(QuicWriteBlockedListTest, CryptoStream) {
-  QuicWriteBlockedList write_blocked_list;
-  write_blocked_list.RegisterStream(1, true, kV3HighestPriority);
-  write_blocked_list.AddStream(1);
+  write_blocked_list_.RegisterStream(1, true, kV3HighestPriority);
+  write_blocked_list_.AddStream(1);
 
-  EXPECT_EQ(1u, write_blocked_list.NumBlockedStreams());
-  EXPECT_TRUE(write_blocked_list.HasWriteBlockedSpecialStream());
-  EXPECT_EQ(1u, write_blocked_list.PopFront());
-  EXPECT_EQ(0u, write_blocked_list.NumBlockedStreams());
-  EXPECT_FALSE(write_blocked_list.HasWriteBlockedSpecialStream());
+  EXPECT_EQ(1u, write_blocked_list_.NumBlockedStreams());
+  EXPECT_TRUE(write_blocked_list_.HasWriteBlockedSpecialStream());
+  EXPECT_EQ(1u, write_blocked_list_.PopFront());
+  EXPECT_EQ(0u, write_blocked_list_.NumBlockedStreams());
+  EXPECT_FALSE(write_blocked_list_.HasWriteBlockedSpecialStream());
 }
 
 TEST_F(QuicWriteBlockedListTest, HeadersStream) {
-  QuicWriteBlockedList write_blocked_list;
-  write_blocked_list.RegisterStream(3, true, kV3HighestPriority);
-  write_blocked_list.AddStream(3);
+  write_blocked_list_.RegisterStream(3, true, kV3HighestPriority);
+  write_blocked_list_.AddStream(3);
 
-  EXPECT_EQ(1u, write_blocked_list.NumBlockedStreams());
-  EXPECT_TRUE(write_blocked_list.HasWriteBlockedSpecialStream());
-  EXPECT_EQ(3u, write_blocked_list.PopFront());
-  EXPECT_EQ(0u, write_blocked_list.NumBlockedStreams());
-  EXPECT_FALSE(write_blocked_list.HasWriteBlockedSpecialStream());
+  EXPECT_EQ(1u, write_blocked_list_.NumBlockedStreams());
+  EXPECT_TRUE(write_blocked_list_.HasWriteBlockedSpecialStream());
+  EXPECT_EQ(3u, write_blocked_list_.PopFront());
+  EXPECT_EQ(0u, write_blocked_list_.NumBlockedStreams());
+  EXPECT_FALSE(write_blocked_list_.HasWriteBlockedSpecialStream());
 }
 
 TEST_F(QuicWriteBlockedListTest, VerifyHeadersStream) {
-  QuicWriteBlockedList write_blocked_list;
-  write_blocked_list.RegisterStream(5, false, kV3HighestPriority);
-  write_blocked_list.RegisterStream(3, true, kV3HighestPriority);
-  write_blocked_list.AddStream(5);
-  write_blocked_list.AddStream(3);
+  write_blocked_list_.RegisterStream(5, false, kV3HighestPriority);
+  write_blocked_list_.RegisterStream(3, true, kV3HighestPriority);
+  write_blocked_list_.AddStream(5);
+  write_blocked_list_.AddStream(3);
 
-  EXPECT_EQ(2u, write_blocked_list.NumBlockedStreams());
-  EXPECT_TRUE(write_blocked_list.HasWriteBlockedSpecialStream());
-  EXPECT_TRUE(write_blocked_list.HasWriteBlockedDataStreams());
+  EXPECT_EQ(2u, write_blocked_list_.NumBlockedStreams());
+  EXPECT_TRUE(write_blocked_list_.HasWriteBlockedSpecialStream());
+  EXPECT_TRUE(write_blocked_list_.HasWriteBlockedDataStreams());
   // In newer QUIC versions, there is a headers stream which is
   // higher priority than data streams.
-  EXPECT_EQ(3u, write_blocked_list.PopFront());
-  EXPECT_EQ(5u, write_blocked_list.PopFront());
-  EXPECT_EQ(0u, write_blocked_list.NumBlockedStreams());
-  EXPECT_FALSE(write_blocked_list.HasWriteBlockedSpecialStream());
-  EXPECT_FALSE(write_blocked_list.HasWriteBlockedDataStreams());
+  EXPECT_EQ(3u, write_blocked_list_.PopFront());
+  EXPECT_EQ(5u, write_blocked_list_.PopFront());
+  EXPECT_EQ(0u, write_blocked_list_.NumBlockedStreams());
+  EXPECT_FALSE(write_blocked_list_.HasWriteBlockedSpecialStream());
+  EXPECT_FALSE(write_blocked_list_.HasWriteBlockedDataStreams());
 }
 
 TEST_F(QuicWriteBlockedListTest, NoDuplicateEntries) {
   // Test that QuicWriteBlockedList doesn't allow duplicate entries.
-  QuicWriteBlockedList write_blocked_list;
-
   // Try to add a stream to the write blocked list multiple times at the same
   // priority.
   const QuicStreamId kBlockedId = 3 + 2;
-  write_blocked_list.RegisterStream(kBlockedId, false, kV3HighestPriority);
-  write_blocked_list.AddStream(kBlockedId);
-  write_blocked_list.AddStream(kBlockedId);
-  write_blocked_list.AddStream(kBlockedId);
+  write_blocked_list_.RegisterStream(kBlockedId, false, kV3HighestPriority);
+  write_blocked_list_.AddStream(kBlockedId);
+  write_blocked_list_.AddStream(kBlockedId);
+  write_blocked_list_.AddStream(kBlockedId);
 
   // This should only result in one blocked stream being added.
-  EXPECT_EQ(1u, write_blocked_list.NumBlockedStreams());
-  EXPECT_TRUE(write_blocked_list.HasWriteBlockedDataStreams());
+  EXPECT_EQ(1u, write_blocked_list_.NumBlockedStreams());
+  EXPECT_TRUE(write_blocked_list_.HasWriteBlockedDataStreams());
 
   // There should only be one stream to pop off the front.
-  EXPECT_EQ(kBlockedId, write_blocked_list.PopFront());
-  EXPECT_EQ(0u, write_blocked_list.NumBlockedStreams());
-  EXPECT_FALSE(write_blocked_list.HasWriteBlockedDataStreams());
+  EXPECT_EQ(kBlockedId, write_blocked_list_.PopFront());
+  EXPECT_EQ(0u, write_blocked_list_.NumBlockedStreams());
+  EXPECT_FALSE(write_blocked_list_.HasWriteBlockedDataStreams());
 }
 
 TEST_F(QuicWriteBlockedListTest, BatchingWrites) {
-  QuicWriteBlockedList write_blocked_list;
-
   const QuicStreamId id1 = 3 + 2;
   const QuicStreamId id2 = id1 + 2;
   const QuicStreamId id3 = id2 + 2;
-  write_blocked_list.RegisterStream(id1, false, kV3LowestPriority);
-  write_blocked_list.RegisterStream(id2, false, kV3LowestPriority);
-  write_blocked_list.RegisterStream(id3, false, kV3HighestPriority);
+  write_blocked_list_.RegisterStream(id1, false, kV3LowestPriority);
+  write_blocked_list_.RegisterStream(id2, false, kV3LowestPriority);
+  write_blocked_list_.RegisterStream(id3, false, kV3HighestPriority);
 
-  write_blocked_list.AddStream(id1);
-  write_blocked_list.AddStream(id2);
-  EXPECT_EQ(2u, write_blocked_list.NumBlockedStreams());
+  write_blocked_list_.AddStream(id1);
+  write_blocked_list_.AddStream(id2);
+  EXPECT_EQ(2u, write_blocked_list_.NumBlockedStreams());
 
   // The first stream we push back should stay at the front until 16k is
   // written.
-  EXPECT_EQ(id1, write_blocked_list.PopFront());
-  write_blocked_list.UpdateBytesForStream(id1, 15999);
-  write_blocked_list.AddStream(id1);
-  EXPECT_EQ(2u, write_blocked_list.NumBlockedStreams());
-  EXPECT_EQ(id1, write_blocked_list.PopFront());
+  EXPECT_EQ(id1, write_blocked_list_.PopFront());
+  write_blocked_list_.UpdateBytesForStream(id1, 15999);
+  write_blocked_list_.AddStream(id1);
+  EXPECT_EQ(2u, write_blocked_list_.NumBlockedStreams());
+  EXPECT_EQ(id1, write_blocked_list_.PopFront());
 
   // Once 16k is written the first stream will yield to the next.
-  write_blocked_list.UpdateBytesForStream(id1, 1);
-  write_blocked_list.AddStream(id1);
-  EXPECT_EQ(2u, write_blocked_list.NumBlockedStreams());
-  EXPECT_EQ(id2, write_blocked_list.PopFront());
+  write_blocked_list_.UpdateBytesForStream(id1, 1);
+  write_blocked_list_.AddStream(id1);
+  EXPECT_EQ(2u, write_blocked_list_.NumBlockedStreams());
+  EXPECT_EQ(id2, write_blocked_list_.PopFront());
 
   // Set the new stream to have written all but one byte.
-  write_blocked_list.UpdateBytesForStream(id2, 15999);
-  write_blocked_list.AddStream(id2);
-  EXPECT_EQ(2u, write_blocked_list.NumBlockedStreams());
+  write_blocked_list_.UpdateBytesForStream(id2, 15999);
+  write_blocked_list_.AddStream(id2);
+  EXPECT_EQ(2u, write_blocked_list_.NumBlockedStreams());
 
   // Ensure higher priority streams are popped first.
-  write_blocked_list.AddStream(id3);
-  EXPECT_EQ(id3, write_blocked_list.PopFront());
+  write_blocked_list_.AddStream(id3);
+  EXPECT_EQ(id3, write_blocked_list_.PopFront());
 
   // Higher priority streams will always be popped first, even if using their
   // byte quota
-  write_blocked_list.UpdateBytesForStream(id3, 20000);
-  write_blocked_list.AddStream(id3);
-  EXPECT_EQ(id3, write_blocked_list.PopFront());
+  write_blocked_list_.UpdateBytesForStream(id3, 20000);
+  write_blocked_list_.AddStream(id3);
+  EXPECT_EQ(id3, write_blocked_list_.PopFront());
 
   // Once the higher priority stream is out of the way, id2 will resume its 16k
   // write, with only 1 byte remaining of its guaranteed write allocation.
-  EXPECT_EQ(id2, write_blocked_list.PopFront());
-  write_blocked_list.UpdateBytesForStream(id2, 1);
-  write_blocked_list.AddStream(id2);
-  EXPECT_EQ(2u, write_blocked_list.NumBlockedStreams());
-  EXPECT_EQ(id1, write_blocked_list.PopFront());
+  EXPECT_EQ(id2, write_blocked_list_.PopFront());
+  write_blocked_list_.UpdateBytesForStream(id2, 1);
+  write_blocked_list_.AddStream(id2);
+  EXPECT_EQ(2u, write_blocked_list_.NumBlockedStreams());
+  EXPECT_EQ(id1, write_blocked_list_.PopFront());
 }
 
 TEST_F(QuicWriteBlockedListTest, Ceding) {
-  QuicWriteBlockedList write_blocked_list;
-
-  write_blocked_list.RegisterStream(15, false, kV3HighestPriority);
-  write_blocked_list.RegisterStream(16, false, kV3HighestPriority);
-  write_blocked_list.RegisterStream(5, false, 5);
-  write_blocked_list.RegisterStream(4, false, 5);
-  write_blocked_list.RegisterStream(7, false, 7);
-  write_blocked_list.RegisterStream(1, true, kV3HighestPriority);
-  write_blocked_list.RegisterStream(3, true, kV3HighestPriority);
+  write_blocked_list_.RegisterStream(15, false, kV3HighestPriority);
+  write_blocked_list_.RegisterStream(16, false, kV3HighestPriority);
+  write_blocked_list_.RegisterStream(5, false, 5);
+  write_blocked_list_.RegisterStream(4, false, 5);
+  write_blocked_list_.RegisterStream(7, false, 7);
+  write_blocked_list_.RegisterStream(1, true, kV3HighestPriority);
+  write_blocked_list_.RegisterStream(3, true, kV3HighestPriority);
 
   // When nothing is on the list, nothing yields.
-  EXPECT_FALSE(write_blocked_list.ShouldYield(5));
+  EXPECT_FALSE(write_blocked_list_.ShouldYield(5));
 
-  write_blocked_list.AddStream(5);
+  write_blocked_list_.AddStream(5);
   // 5 should not yield to itself.
-  EXPECT_FALSE(write_blocked_list.ShouldYield(5));
+  EXPECT_FALSE(write_blocked_list_.ShouldYield(5));
   // 4 and 7 are equal or lower priority and should yield to 5.
-  EXPECT_TRUE(write_blocked_list.ShouldYield(4));
-  EXPECT_TRUE(write_blocked_list.ShouldYield(7));
+  EXPECT_TRUE(write_blocked_list_.ShouldYield(4));
+  EXPECT_TRUE(write_blocked_list_.ShouldYield(7));
   // 15, headers and crypto should preempt 5.
-  EXPECT_FALSE(write_blocked_list.ShouldYield(15));
-  EXPECT_FALSE(write_blocked_list.ShouldYield(3));
-  EXPECT_FALSE(write_blocked_list.ShouldYield(1));
+  EXPECT_FALSE(write_blocked_list_.ShouldYield(15));
+  EXPECT_FALSE(write_blocked_list_.ShouldYield(3));
+  EXPECT_FALSE(write_blocked_list_.ShouldYield(1));
 
   // Block a high priority stream.
-  write_blocked_list.AddStream(15);
+  write_blocked_list_.AddStream(15);
   // 16 should yield (same priority) but headers and crypto will still not.
-  EXPECT_TRUE(write_blocked_list.ShouldYield(16));
-  EXPECT_FALSE(write_blocked_list.ShouldYield(3));
-  EXPECT_FALSE(write_blocked_list.ShouldYield(1));
+  EXPECT_TRUE(write_blocked_list_.ShouldYield(16));
+  EXPECT_FALSE(write_blocked_list_.ShouldYield(3));
+  EXPECT_FALSE(write_blocked_list_.ShouldYield(1));
 
   // Block the headers stream.  All streams but crypto and headers should yield.
-  write_blocked_list.AddStream(3);
-  EXPECT_TRUE(write_blocked_list.ShouldYield(16));
-  EXPECT_TRUE(write_blocked_list.ShouldYield(15));
-  EXPECT_FALSE(write_blocked_list.ShouldYield(3));
-  EXPECT_FALSE(write_blocked_list.ShouldYield(1));
+  write_blocked_list_.AddStream(3);
+  EXPECT_TRUE(write_blocked_list_.ShouldYield(16));
+  EXPECT_TRUE(write_blocked_list_.ShouldYield(15));
+  EXPECT_FALSE(write_blocked_list_.ShouldYield(3));
+  EXPECT_FALSE(write_blocked_list_.ShouldYield(1));
 
   // Block the crypto stream.  All streams but crypto should yield.
-  write_blocked_list.AddStream(1);
-  EXPECT_TRUE(write_blocked_list.ShouldYield(16));
-  EXPECT_TRUE(write_blocked_list.ShouldYield(15));
-  EXPECT_TRUE(write_blocked_list.ShouldYield(3));
-  EXPECT_FALSE(write_blocked_list.ShouldYield(1));
+  write_blocked_list_.AddStream(1);
+  EXPECT_TRUE(write_blocked_list_.ShouldYield(16));
+  EXPECT_TRUE(write_blocked_list_.ShouldYield(15));
+  EXPECT_TRUE(write_blocked_list_.ShouldYield(3));
+  EXPECT_FALSE(write_blocked_list_.ShouldYield(1));
 }
 
 }  // namespace
diff --git a/quic/core/uber_quic_stream_id_manager_test.cc b/quic/core/uber_quic_stream_id_manager_test.cc
index b9420bf..8b1bace 100644
--- a/quic/core/uber_quic_stream_id_manager_test.cc
+++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -282,7 +282,7 @@
 
   std::string error_details =
       GetParam() == Perspective::IS_SERVER
-          ? "Stream id 404 would exceed stream count limit 100"
+          ? "Stream id 400 would exceed stream count limit 100"
           : "Stream id 401 would exceed stream count limit 100";
 
   EXPECT_CALL(*connection_,
diff --git a/quic/test_tools/quic_session_peer.cc b/quic/test_tools/quic_session_peer.cc
index ed7043d..9eee494 100644
--- a/quic/test_tools/quic_session_peer.cc
+++ b/quic/test_tools/quic_session_peer.cc
@@ -181,19 +181,16 @@
 
 // static
 bool QuicSessionPeer::IsStreamClosed(QuicSession* session, QuicStreamId id) {
-  DCHECK_NE(0u, id);
   return session->IsClosedStream(id);
 }
 
 // static
 bool QuicSessionPeer::IsStreamCreated(QuicSession* session, QuicStreamId id) {
-  DCHECK_NE(0u, id);
   return QuicContainsKey(session->dynamic_streams(), id);
 }
 
 // static
 bool QuicSessionPeer::IsStreamAvailable(QuicSession* session, QuicStreamId id) {
-  DCHECK_NE(0u, id);
   if (session->connection()->transport_version() == QUIC_VERSION_99) {
     if (id % QuicUtils::StreamIdDelta(QUIC_VERSION_99) < 2) {
       return QuicContainsKey(