diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index ed375fa..e5945e1 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -523,8 +523,8 @@
       &bandwidth_recorder, max_bandwidth_estimate_kbytes_per_second,
       max_bandwidth_estimate_timestamp);
   // Queue up some pending data.
-  session_->MarkConnectionLevelWriteBlocked(QuicUtils::GetCryptoStreamId(
-      session_->connection()->transport_version()));
+  session_->MarkConnectionLevelWriteBlocked(
+      QuicUtils::GetHeadersStreamId(connection_->transport_version()));
   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 d528d1e..4e1dc9e 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -199,8 +199,10 @@
   EXPECT_TRUE(session_->IsEncryptionEstablished());
   QuicSpdyClientStream* stream = session_->CreateOutgoingBidirectionalStream();
   ASSERT_TRUE(stream != nullptr);
-  EXPECT_NE(QuicUtils::GetCryptoStreamId(connection_->transport_version()),
-            stream->id());
+  if (!QuicVersionUsesCryptoFrames(GetParam().transport_version)) {
+    EXPECT_NE(QuicUtils::GetCryptoStreamId(connection_->transport_version()),
+              stream->id());
+  }
 
   // Process an "inchoate" REJ from the server which will cause
   // an inchoate CHLO to be sent and will leave the encryption level
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 6e0dfff..980ef82 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -241,8 +241,9 @@
 
   QuicConsumedData SendStreamData(QuicStream* stream) {
     struct iovec iov;
-    if (stream->id() !=
-            QuicUtils::GetCryptoStreamId(connection()->transport_version()) &&
+    if ((QuicVersionUsesCryptoFrames(connection()->transport_version()) ||
+         stream->id() !=
+             QuicUtils::GetCryptoStreamId(connection()->transport_version())) &&
         connection()->encryption_level() != ENCRYPTION_FORWARD_SECURE) {
       this->connection()->SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
     }
@@ -330,9 +331,13 @@
   }
 
   void CheckClosedStreams() {
-    for (QuicStreamId i =
-             QuicUtils::GetCryptoStreamId(connection_->transport_version());
-         i < 100; i++) {
+    QuicStreamId first_stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+        connection_->transport_version(), Perspective::IS_CLIENT);
+    if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
+      first_stream_id =
+          QuicUtils::GetCryptoStreamId(connection_->transport_version());
+    }
+    for (QuicStreamId i = first_stream_id; i < 100; i++) {
       if (!QuicContainsKey(closed_streams_, i)) {
         EXPECT_FALSE(session_.IsClosedStream(i)) << " stream id: " << i;
       } else {
@@ -429,9 +434,13 @@
 
 TEST_P(QuicSpdySessionTestServer, IsClosedStreamDefault) {
   // Ensure that no streams are initially closed.
-  for (QuicStreamId i =
-           QuicUtils::GetCryptoStreamId(connection_->transport_version());
-       i < 100; i++) {
+  QuicStreamId first_stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+      connection_->transport_version(), Perspective::IS_CLIENT);
+  if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
+    first_stream_id =
+        QuicUtils::GetCryptoStreamId(connection_->transport_version());
+  }
+  for (QuicStreamId i = first_stream_id; i < 100; i++) {
     EXPECT_FALSE(session_.IsClosedStream(i)) << "stream id: " << i;
   }
 }
@@ -1656,9 +1665,6 @@
   TestStream* stream2 = session_.CreateOutgoingBidirectionalStream();
   TestStream* stream4 = session_.CreateOutgoingBidirectionalStream();
 
-  QuicStreamFrame frame1(
-      QuicUtils::GetCryptoStreamId(connection_->transport_version()), false, 0,
-      1300);
   QuicStreamFrame frame2(stream2->id(), false, 0, 9);
   QuicStreamFrame frame3(stream4->id(), false, 0, 9);
 
@@ -1671,6 +1677,9 @@
   EXPECT_CALL(*stream2, HasPendingRetransmission()).WillOnce(Return(true));
   session_.OnFrameLost(QuicFrame(frame3));
   if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
+    QuicStreamFrame frame1(
+        QuicUtils::GetCryptoStreamId(connection_->transport_version()), false,
+        0, 1300);
     session_.OnFrameLost(QuicFrame(frame1));
   } else {
     QuicCryptoFrame crypto_frame(ENCRYPTION_INITIAL, 0, 1300);
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index 8519510..4604a08 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -9858,22 +9858,25 @@
 }
 
 TEST_P(QuicFramerTest, StartsWithChlo) {
+  if (QuicVersionUsesCryptoFrames(framer_.transport_version())) {
+    // When client hellos are sent in crypto frames, this test doesn't make
+    // sense.
+    return;
+  }
   SimpleDataProducer producer;
   framer_.set_data_producer(&producer);
   QuicStringPiece data("CHLOCHLO");
   struct iovec iovec;
   iovec.iov_base = const_cast<char*>(data.data());
   iovec.iov_len = data.length();
-  producer.SaveStreamData(
-      QuicUtils::GetCryptoStreamId(framer_.transport_version()), &iovec, 1, 0,
-      data.length());
+  QuicStreamId stream_id =
+      QuicUtils::GetCryptoStreamId(framer_.transport_version());
+  producer.SaveStreamData(stream_id, &iovec, 1, 0, data.length());
   for (size_t offset = 0; offset < 5; ++offset) {
     if (offset == 0 || offset == 4) {
-      EXPECT_TRUE(framer_.StartsWithChlo(
-          QuicUtils::GetCryptoStreamId(framer_.transport_version()), offset));
+      EXPECT_TRUE(framer_.StartsWithChlo(stream_id, offset));
     } else {
-      EXPECT_FALSE(framer_.StartsWithChlo(
-          QuicUtils::GetCryptoStreamId(framer_.transport_version()), offset));
+      EXPECT_FALSE(framer_.StartsWithChlo(stream_id, offset));
     }
   }
 }
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index 1b3b015..0826b08 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -274,12 +274,14 @@
     EncryptionLevel level = static_cast<EncryptionLevel>(i);
     creator_.set_encryption_level(level);
     frames_.push_back(QuicFrame(new QuicAckFrame(InitAckFrame(1))));
-    frames_.push_back(QuicFrame(QuicStreamFrame(
-        QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), false,
-        0u, QuicStringPiece())));
-    frames_.push_back(QuicFrame(QuicStreamFrame(
-        QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), true,
-        0u, QuicStringPiece())));
+    QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+        client_framer_.transport_version(), Perspective::IS_CLIENT);
+    if (level != ENCRYPTION_INITIAL) {
+      frames_.push_back(
+          QuicFrame(QuicStreamFrame(stream_id, false, 0u, QuicStringPiece())));
+      frames_.push_back(
+          QuicFrame(QuicStreamFrame(stream_id, true, 0u, QuicStringPiece())));
+    }
     SerializedPacket serialized = SerializeAllFrames(frames_);
     EXPECT_EQ(level, serialized.encryption_level);
     delete frames_[0].ack_frame;
@@ -299,8 +301,10 @@
           .WillOnce(Return(true));
       EXPECT_CALL(framer_visitor_, OnAckFrameEnd(QuicPacketNumber(1)))
           .WillOnce(Return(true));
-      EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
-      EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
+      if (level != ENCRYPTION_INITIAL) {
+        EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
+        EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
+      }
       EXPECT_CALL(framer_visitor_, OnPacketComplete());
     }
     ProcessPacket(serialized);
@@ -316,11 +320,18 @@
   // retransmit must sent with the original length and the others do not change.
   QuicPacketCreatorPeer::SetPacketNumberLength(&creator_,
                                                PACKET_2BYTE_PACKET_NUMBER);
-  QuicStreamFrame stream_frame(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
-      /*fin=*/false, 0u, QuicStringPiece());
   QuicFrames frames;
-  frames.push_back(QuicFrame(stream_frame));
+  std::string data("a");
+  if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
+    QuicStreamFrame stream_frame(
+        QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
+        /*fin=*/false, 0u, QuicStringPiece());
+    frames.push_back(QuicFrame(stream_frame));
+  } else {
+    producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
+    frames.push_back(
+        QuicFrame(new QuicCryptoFrame(ENCRYPTION_INITIAL, 0, data.length())));
+  }
   char buffer[kMaxPacketSize];
   QuicPendingRetransmission retransmission(CreateRetransmission(
       frames, true /* has_crypto_handshake */, -1 /* needs full padding */,
@@ -342,19 +353,31 @@
     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
+    if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
+      EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
+    } else {
+      EXPECT_CALL(framer_visitor_, OnCryptoFrame(_));
+    }
     EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
   ProcessPacket(serialized_packet_);
+  DeleteFrames(&frames);
 }
 
 TEST_P(QuicPacketCreatorTest, ReserializeCryptoFrameWithForwardSecurity) {
-  QuicStreamFrame stream_frame(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
-      /*fin=*/false, 0u, QuicStringPiece());
   QuicFrames frames;
-  frames.push_back(QuicFrame(stream_frame));
+  std::string data("a");
+  if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
+    QuicStreamFrame stream_frame(
+        QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
+        /*fin=*/false, 0u, QuicStringPiece());
+    frames.push_back(QuicFrame(stream_frame));
+  } else {
+    producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
+    frames.push_back(
+        QuicFrame(new QuicCryptoFrame(ENCRYPTION_INITIAL, 0, data.length())));
+  }
   creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   char buffer[kMaxPacketSize];
   QuicPendingRetransmission retransmission(CreateRetransmission(
@@ -365,6 +388,7 @@
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
   EXPECT_EQ(ENCRYPTION_INITIAL, serialized_packet_.encryption_level);
+  DeleteFrames(&frames);
 }
 
 TEST_P(QuicPacketCreatorTest, ReserializeFrameWithForwardSecurity) {
@@ -385,14 +409,21 @@
 
 TEST_P(QuicPacketCreatorTest, ReserializeFramesWithFullPadding) {
   QuicFrame frame;
-  MakeIOVector("fake handshake message data", &iov_);
-  producer_.SaveStreamData(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
-      1u, 0u, iov_.iov_len);
-  QuicPacketCreatorPeer::CreateStreamFrame(
-      &creator_,
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
-      iov_.iov_len, 0u, false, &frame);
+  std::string data = "fake handshake message data";
+  if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
+    MakeIOVector(data, &iov_);
+    producer_.SaveStreamData(
+        QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
+        1u, 0u, iov_.iov_len);
+    QuicPacketCreatorPeer::CreateStreamFrame(
+        &creator_,
+        QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
+        iov_.iov_len, 0u, false, &frame);
+  } else {
+    producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
+    EXPECT_TRUE(QuicPacketCreatorPeer::CreateCryptoFrame(
+        &creator_, ENCRYPTION_INITIAL, data.length(), 0, &frame));
+  }
   QuicFrames frames;
   frames.push_back(frame);
   char buffer[kMaxPacketSize];
@@ -404,18 +435,26 @@
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
   EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.encrypted_length);
+  DeleteFrames(&frames);
 }
 
 TEST_P(QuicPacketCreatorTest, DoNotRetransmitPendingPadding) {
   QuicFrame frame;
-  MakeIOVector("fake message data", &iov_);
-  producer_.SaveStreamData(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
-      1u, 0u, iov_.iov_len);
-  QuicPacketCreatorPeer::CreateStreamFrame(
-      &creator_,
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
-      iov_.iov_len, 0u, false, &frame);
+  std::string data = "fake message data";
+  if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
+    MakeIOVector(data, &iov_);
+    producer_.SaveStreamData(
+        QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
+        1u, 0u, iov_.iov_len);
+    QuicPacketCreatorPeer::CreateStreamFrame(
+        &creator_,
+        QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
+        iov_.iov_len, 0u, false, &frame);
+  } else {
+    producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
+    EXPECT_TRUE(QuicPacketCreatorPeer::CreateCryptoFrame(
+        &creator_, ENCRYPTION_INITIAL, data.length(), 0, &frame));
+  }
 
   const int kNumPaddingBytes1 = 4;
   int packet_size = 0;
@@ -440,7 +479,11 @@
     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
+    if (QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
+      EXPECT_CALL(framer_visitor_, OnCryptoFrame(_));
+    } else {
+      EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
+    }
     // Pending paddings are not retransmitted.
     EXPECT_CALL(framer_visitor_, OnPaddingFrame(_)).Times(0);
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
@@ -460,9 +503,11 @@
   creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
 
   EXPECT_EQ(packet_size, serialized_packet_.encrypted_length);
+  DeleteFrames(&frames);
 }
 
 TEST_P(QuicPacketCreatorTest, ReserializeFramesWithFullPacketAndPadding) {
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   const size_t overhead =
       GetPacketHeaderOverhead(client_framer_.transport_version()) +
       GetEncryptionOverhead() +
@@ -473,22 +518,20 @@
     size_t bytes_free = 0 - delta;
 
     QuicFrame frame;
-    MakeIOVector(data, &iov_);
     SimpleDataProducer producer;
-    producer.SaveStreamData(
-        QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
-        1u, 0u, iov_.iov_len);
     QuicPacketCreatorPeer::framer(&creator_)->set_data_producer(&producer);
-    QuicPacketCreatorPeer::CreateStreamFrame(
-        &creator_,
-        QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
-        iov_.iov_len, kOffset, false, &frame);
+    MakeIOVector(data, &iov_);
+    QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+        client_framer_.transport_version(), Perspective::IS_CLIENT);
+    producer.SaveStreamData(stream_id, &iov_, 1u, 0u, iov_.iov_len);
+    QuicPacketCreatorPeer::CreateStreamFrame(&creator_, stream_id, iov_.iov_len,
+                                             kOffset, false, &frame);
     QuicFrames frames;
     frames.push_back(frame);
     char buffer[kMaxPacketSize];
     QuicPendingRetransmission retransmission(CreateRetransmission(
-        frames, true /* has_crypto_handshake */, -1 /* needs full padding */,
-        ENCRYPTION_INITIAL,
+        frames, false /* has_crypto_handshake */, -1 /* needs full padding */,
+        ENCRYPTION_FORWARD_SECURE,
         QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
@@ -542,43 +585,43 @@
 }
 
 TEST_P(QuicPacketCreatorTest, ConsumeData) {
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   QuicFrame frame;
   MakeIOVector("test", &iov_);
-  ASSERT_TRUE(creator_.ConsumeData(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
-      1u, iov_.iov_len, 0u, 0u, false, false, NOT_RETRANSMISSION, &frame));
+  QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+      client_framer_.transport_version(), Perspective::IS_CLIENT);
+  ASSERT_TRUE(creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u,
+                                   false, false, NOT_RETRANSMISSION, &frame));
   size_t consumed = frame.stream_frame.data_length;
   EXPECT_EQ(4u, consumed);
-  CheckStreamFrame(
-      frame, QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
-      "test", 0u, false);
+  CheckStreamFrame(frame, stream_id, "test", 0u, false);
   EXPECT_TRUE(creator_.HasPendingFrames());
 }
 
 TEST_P(QuicPacketCreatorTest, ConsumeDataFin) {
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   QuicFrame frame;
   MakeIOVector("test", &iov_);
-  ASSERT_TRUE(creator_.ConsumeData(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
-      1u, iov_.iov_len, 0u, 0u, true, false, NOT_RETRANSMISSION, &frame));
+  QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+      client_framer_.transport_version(), Perspective::IS_CLIENT);
+  ASSERT_TRUE(creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u,
+                                   true, false, NOT_RETRANSMISSION, &frame));
   size_t consumed = frame.stream_frame.data_length;
   EXPECT_EQ(4u, consumed);
-  CheckStreamFrame(
-      frame, QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
-      "test", 0u, true);
+  CheckStreamFrame(frame, stream_id, "test", 0u, true);
   EXPECT_TRUE(creator_.HasPendingFrames());
 }
 
 TEST_P(QuicPacketCreatorTest, ConsumeDataFinOnly) {
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   QuicFrame frame;
-  ASSERT_TRUE(creator_.ConsumeData(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), nullptr,
-      0u, 0u, 0u, 0u, true, false, NOT_RETRANSMISSION, &frame));
+  QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+      client_framer_.transport_version(), Perspective::IS_CLIENT);
+  ASSERT_TRUE(creator_.ConsumeData(stream_id, nullptr, 0u, 0u, 0u, 0u, true,
+                                   false, NOT_RETRANSMISSION, &frame));
   size_t consumed = frame.stream_frame.data_length;
   EXPECT_EQ(0u, consumed);
-  CheckStreamFrame(
-      frame, QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
-      std::string(), 0u, true);
+  CheckStreamFrame(frame, stream_id, std::string(), 0u, true);
   EXPECT_TRUE(creator_.HasPendingFrames());
 }
 
@@ -644,14 +687,19 @@
 
 TEST_P(QuicPacketCreatorTest, CryptoStreamFramePacketPadding) {
   // Compute the total overhead for a single frame in packet.
-  const size_t overhead =
+  size_t overhead =
       GetPacketHeaderOverhead(client_framer_.transport_version()) +
-      GetEncryptionOverhead() +
-      GetStreamFrameOverhead(client_framer_.transport_version());
+      GetEncryptionOverhead();
+  if (QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
+    overhead += QuicFramer::GetMinCryptoFrameSize(kOffset, kMaxPacketSize);
+  } else {
+    overhead += GetStreamFrameOverhead(client_framer_.transport_version());
+  }
   ASSERT_GT(kMaxPacketSize, overhead);
   size_t capacity = kDefaultMaxPacketSize - overhead;
   // Now, test various sizes around this size.
   for (int delta = -5; delta <= 5; ++delta) {
+    SCOPED_TRACE(delta);
     std::string data(capacity + delta, 'A');
     size_t bytes_free = delta > 0 ? 0 : 0 - delta;
 
@@ -660,18 +708,28 @@
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillRepeatedly(
             Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-    ASSERT_TRUE(creator_.ConsumeData(
-        QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
-        1u, iov_.iov_len, 0u, kOffset, false, true, NOT_RETRANSMISSION,
-        &frame));
-    size_t bytes_consumed = frame.stream_frame.data_length;
-    EXPECT_LT(0u, bytes_consumed);
+    if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
+      ASSERT_TRUE(creator_.ConsumeData(
+          QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
+          &iov_, 1u, iov_.iov_len, 0u, kOffset, false, true, NOT_RETRANSMISSION,
+          &frame));
+      size_t bytes_consumed = frame.stream_frame.data_length;
+      EXPECT_LT(0u, bytes_consumed);
+    } else {
+      producer_.SaveCryptoData(ENCRYPTION_INITIAL, kOffset, data);
+      ASSERT_TRUE(creator_.ConsumeCryptoData(ENCRYPTION_INITIAL, data.length(),
+                                             kOffset, NOT_RETRANSMISSION,
+                                             &frame));
+      size_t bytes_consumed = frame.crypto_frame->data_length;
+      EXPECT_LT(0u, bytes_consumed);
+    }
     creator_.Flush();
     ASSERT_TRUE(serialized_packet_.encrypted_buffer);
     // If there is not enough space in the packet to fit a padding frame
     // (1 byte) and to expand the stream frame (another 2 bytes) the packet
     // will not be padded.
-    if (bytes_free < 3) {
+    if (bytes_free < 3 &&
+        !QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
       EXPECT_EQ(kDefaultMaxPacketSize - bytes_free,
                 serialized_packet_.encrypted_length);
     } else {
@@ -1092,9 +1150,17 @@
   if (!GetParam().version_serialization) {
     creator_.StopSendingVersion();
   }
-  frames_.push_back(QuicFrame(QuicStreamFrame(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), false,
-      0u, QuicStringPiece())));
+  std::string data("a");
+  if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
+    QuicStreamFrame stream_frame(
+        QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
+        /*fin=*/false, 0u, QuicStringPiece());
+    frames_.push_back(QuicFrame(stream_frame));
+  } else {
+    producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
+    frames_.push_back(
+        QuicFrame(new QuicCryptoFrame(ENCRYPTION_INITIAL, 0, data.length())));
+  }
   SerializedPacket serialized = SerializeAllFrames(frames_);
 
   QuicPacketHeader header;
@@ -1106,17 +1172,23 @@
     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
     EXPECT_CALL(framer_visitor_, OnPacketHeader(_))
         .WillOnce(DoAll(SaveArg<0>(&header), Return(true)));
-    EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
+    if (QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
+      EXPECT_CALL(framer_visitor_, OnCryptoFrame(_));
+    } else {
+      EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
+    }
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
   ProcessPacket(serialized);
   EXPECT_EQ(GetParam().version_serialization, header.version_flag);
+  DeleteFrames(&frames_);
 }
 
 TEST_P(QuicPacketCreatorTest, ConsumeDataLargerThanOneStreamFrame) {
   if (!GetParam().version_serialization) {
     creator_.StopSendingVersion();
   }
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   // A string larger than fits into a frame.
   size_t payload_length;
   creator_.SetMaxPacketLength(GetPacketLengthForOneStream(
@@ -1133,15 +1205,14 @@
   MakeIOVector(too_long_payload, &iov_);
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-  ASSERT_TRUE(creator_.ConsumeData(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
-      1u, iov_.iov_len, 0u, 0u, true, false, NOT_RETRANSMISSION, &frame));
+  QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+      client_framer_.transport_version(), Perspective::IS_CLIENT);
+  ASSERT_TRUE(creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u,
+                                   true, false, NOT_RETRANSMISSION, &frame));
   size_t consumed = frame.stream_frame.data_length;
   EXPECT_EQ(payload_length, consumed);
   const std::string payload(payload_length, 'a');
-  CheckStreamFrame(
-      frame, QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
-      payload, 0u, false);
+  CheckStreamFrame(frame, stream_id, payload, 0u, false);
   creator_.Flush();
   DeleteSerializedPacket();
 }
@@ -1275,6 +1346,13 @@
     return;
   }
 
+  // This test only matters when the crypto handshake is sent in stream frames.
+  // TODO(b/128596274): Re-enable when this check is supported for CRYPTO
+  // frames.
+  if (QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
+    return;
+  }
+
   CryptoHandshakeMessage message;
   message.set_tag(kCHLO);
   message.set_minimum_size(kMaxPacketSize);
@@ -1323,12 +1401,14 @@
 }
 
 TEST_P(QuicPacketCreatorTest, FullPaddingDoesNotConsumePendingPadding) {
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   creator_.AddPendingPadding(kMaxNumRandomPaddingBytes);
   QuicFrame frame;
   MakeIOVector("test", &iov_);
+  QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+      client_framer_.transport_version(), Perspective::IS_CLIENT);
   ASSERT_TRUE(creator_.ConsumeData(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
-      1u, iov_.iov_len, 0u, 0u, false,
+      stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false,
       /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
@@ -1337,14 +1417,16 @@
 }
 
 TEST_P(QuicPacketCreatorTest, SendPendingPaddingInRetransmission) {
-  QuicStreamFrame stream_frame(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
-      /*fin=*/false, 0u, QuicStringPiece());
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
+  QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+      client_framer_.transport_version(), Perspective::IS_CLIENT);
+  QuicStreamFrame stream_frame(stream_id,
+                               /*fin=*/false, 0u, QuicStringPiece());
   QuicFrames frames;
   frames.push_back(QuicFrame(stream_frame));
   char buffer[kMaxPacketSize];
   QuicPendingRetransmission retransmission(CreateRetransmission(
-      frames, true, /*num_padding_bytes=*/0, ENCRYPTION_INITIAL,
+      frames, true, /*num_padding_bytes=*/0, ENCRYPTION_FORWARD_SECURE,
       QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
@@ -1369,20 +1451,24 @@
   // Making sure needs_full_padding gets reset after a full padding
   // retransmission.
   EXPECT_EQ(0u, creator_.pending_padding_bytes());
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   QuicFrame frame;
-  MakeIOVector("fake handshake message data", &iov_);
-  producer_.SaveStreamData(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
-      1u, 0u, iov_.iov_len);
-  QuicPacketCreatorPeer::CreateStreamFrame(
-      &creator_,
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
-      iov_.iov_len, 0u, false, &frame);
+  std::string data = "fake handshake message data";
+  MakeIOVector(data, &iov_);
+  QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+      client_framer_.transport_version(), Perspective::IS_CLIENT);
+  if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
+    stream_id =
+        QuicUtils::GetCryptoStreamId(client_framer_.transport_version());
+  }
+  producer_.SaveStreamData(stream_id, &iov_, 1u, 0u, iov_.iov_len);
+  QuicPacketCreatorPeer::CreateStreamFrame(&creator_, stream_id, iov_.iov_len,
+                                           0u, false, &frame);
   QuicFrames frames;
   frames.push_back(frame);
   char buffer[kMaxPacketSize];
   QuicPendingRetransmission retransmission(CreateRetransmission(
-      frames, true, /*num_padding_bytes=*/-1, ENCRYPTION_INITIAL,
+      frames, true, /*num_padding_bytes=*/-1, ENCRYPTION_FORWARD_SECURE,
       QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillRepeatedly(
@@ -1403,9 +1489,8 @@
   }
   ProcessPacket(serialized_packet_);
 
-  creator_.ConsumeData(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
-      1u, iov_.iov_len, 0u, 0u, false, false, NOT_RETRANSMISSION, &frame);
+  creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false,
+                       NOT_RETRANSMISSION, &frame);
   creator_.Flush();
   {
     InSequence s;
@@ -1420,18 +1505,21 @@
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
   ProcessPacket(serialized_packet_);
+  DeleteFrames(&frames);
 }
 
 TEST_P(QuicPacketCreatorTest, ConsumeDataAndRandomPadding) {
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   const QuicByteCount kStreamFramePayloadSize = 100u;
   // Set the packet size be enough for one stream frame with 0 stream offset +
   // 1.
+  QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+      client_framer_.transport_version(), Perspective::IS_CLIENT);
   size_t length =
       GetPacketHeaderOverhead(client_framer_.transport_version()) +
       GetEncryptionOverhead() +
       QuicFramer::GetMinStreamFrameSize(
-          client_framer_.transport_version(),
-          QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), 0,
+          client_framer_.transport_version(), stream_id, 0,
           /*last_frame_in_packet=*/false, kStreamFramePayloadSize + 1) +
       kStreamFramePayloadSize + 1;
   creator_.SetMaxPacketLength(length);
@@ -1444,18 +1532,16 @@
           Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   // Send stream frame of size kStreamFramePayloadSize.
   MakeIOVector(QuicStringPiece(buf, kStreamFramePayloadSize), &iov_);
-  creator_.ConsumeData(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
-      1u, iov_.iov_len, 0u, 0u, false, false, NOT_RETRANSMISSION, &frame);
+  creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false,
+                       NOT_RETRANSMISSION, &frame);
   creator_.Flush();
   // 1 byte padding is sent.
   EXPECT_EQ(pending_padding_bytes - 1, creator_.pending_padding_bytes());
   // Send stream frame of size kStreamFramePayloadSize + 1.
   MakeIOVector(QuicStringPiece(buf, kStreamFramePayloadSize + 1), &iov_);
-  creator_.ConsumeData(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
-      1u, iov_.iov_len, 0u, kStreamFramePayloadSize, false, false,
-      NOT_RETRANSMISSION, &frame);
+  creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u,
+                       kStreamFramePayloadSize, false, false,
+                       NOT_RETRANSMISSION, &frame);
   // No padding is sent.
   creator_.Flush();
   EXPECT_EQ(pending_padding_bytes - 1, creator_.pending_padding_bytes());
@@ -1467,15 +1553,17 @@
 }
 
 TEST_P(QuicPacketCreatorTest, FlushWithExternalBuffer) {
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   char external_buffer[kMaxPacketSize];
   char* expected_buffer = external_buffer;
   EXPECT_CALL(delegate_, GetPacketBuffer()).WillOnce(Return(expected_buffer));
 
   QuicFrame frame;
   MakeIOVector("test", &iov_);
+  QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+      client_framer_.transport_version(), Perspective::IS_CLIENT);
   ASSERT_TRUE(creator_.ConsumeData(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
-      1u, iov_.iov_len, 0u, 0u, false,
+      stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false,
       /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
 
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
@@ -1503,6 +1591,7 @@
   if (client_framer_.transport_version() <= QUIC_VERSION_44) {
     return;
   }
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .Times(3)
       .WillRepeatedly(
@@ -1535,9 +1624,10 @@
 
   QuicFrame frame;
   MakeIOVector("test", &iov_);
-  EXPECT_TRUE(creator_.ConsumeData(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
-      1u, iov_.iov_len, 0u, 0u, false, false, NOT_RETRANSMISSION, &frame));
+  QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+      client_framer_.transport_version(), Perspective::IS_CLIENT);
+  EXPECT_TRUE(creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u,
+                                   false, false, NOT_RETRANSMISSION, &frame));
   QuicMessageFrame* frame4 = new QuicMessageFrame(4);
   MakeSpan(&allocator_, "message", &storage).SaveMemSlicesAsMessageData(frame4);
   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(frame4), NOT_RETRANSMISSION));
@@ -1588,6 +1678,7 @@
 }
 
 TEST_P(QuicPacketCreatorTest, PacketTransmissionType) {
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   creator_.set_can_set_transmission_type(true);
   creator_.SetTransmissionType(NOT_RETRANSMISSION);
 
@@ -1595,9 +1686,10 @@
   QuicFrame ack_frame(&temp_ack_frame);
   ASSERT_FALSE(QuicUtils::IsRetransmittableFrame(ack_frame.type));
 
-  QuicFrame stream_frame(QuicStreamFrame(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
-      /*fin=*/false, 0u, QuicStringPiece()));
+  QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+      client_framer_.transport_version(), Perspective::IS_CLIENT);
+  QuicFrame stream_frame(QuicStreamFrame(stream_id,
+                                         /*fin=*/false, 0u, QuicStringPiece()));
   ASSERT_TRUE(QuicUtils::IsRetransmittableFrame(stream_frame.type));
 
   QuicFrame padding_frame{QuicPaddingFrame()};
@@ -1638,9 +1730,17 @@
   creator_.SetRetryToken(
       std::string(retry_token_bytes, sizeof(retry_token_bytes)));
 
-  frames_.push_back(QuicFrame(QuicStreamFrame(
-      QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), false,
-      0u, QuicStringPiece())));
+  std::string data("a");
+  if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
+    QuicStreamFrame stream_frame(
+        QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
+        /*fin=*/false, 0u, QuicStringPiece());
+    frames_.push_back(QuicFrame(stream_frame));
+  } else {
+    producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
+    frames_.push_back(
+        QuicFrame(new QuicCryptoFrame(ENCRYPTION_INITIAL, 0, data.length())));
+  }
   SerializedPacket serialized = SerializeAllFrames(frames_);
 
   QuicPacketHeader header;
@@ -1652,7 +1752,11 @@
     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
     EXPECT_CALL(framer_visitor_, OnPacketHeader(_))
         .WillOnce(DoAll(SaveArg<0>(&header), Return(true)));
-    EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
+    if (QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
+      EXPECT_CALL(framer_visitor_, OnCryptoFrame(_));
+    } else {
+      EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
+    }
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
   ProcessPacket(serialized);
@@ -1662,6 +1766,7 @@
   test::CompareCharArraysWithHexError(
       "retry token", header.retry_token.data(), header.retry_token.length(),
       retry_token_bytes, sizeof(retry_token_bytes));
+  DeleteFrames(&frames_);
 }
 
 }  // namespace
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 0fb8e37..f3016f4 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -325,9 +325,13 @@
   }
 
   void CheckClosedStreams() {
-    for (QuicStreamId i =
-             QuicUtils::GetCryptoStreamId(connection_->transport_version());
-         i < 100; i++) {
+    QuicStreamId first_stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+        connection_->transport_version(), Perspective::IS_CLIENT);
+    if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
+      first_stream_id =
+          QuicUtils::GetCryptoStreamId(connection_->transport_version());
+    }
+    for (QuicStreamId i = first_stream_id; i < 100; i++) {
       if (!QuicContainsKey(closed_streams_, i)) {
         EXPECT_FALSE(session_.IsClosedStream(i)) << " stream id: " << i;
       } else {
@@ -485,9 +489,13 @@
 
 TEST_P(QuicSessionTestServer, IsClosedStreamDefault) {
   // Ensure that no streams are initially closed.
-  for (QuicStreamId i =
-           QuicUtils::GetCryptoStreamId(connection_->transport_version());
-       i < 100; i++) {
+  QuicStreamId first_stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+      connection_->transport_version(), Perspective::IS_CLIENT);
+  if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
+    first_stream_id =
+        QuicUtils::GetCryptoStreamId(connection_->transport_version());
+  }
+  for (QuicStreamId i = first_stream_id; i < 100; i++) {
     EXPECT_FALSE(session_.IsClosedStream(i)) << "stream id: " << i;
   }
 }
diff --git a/quic/test_tools/quic_packet_creator_peer.cc b/quic/test_tools/quic_packet_creator_peer.cc
index f81375f..c5dd747 100644
--- a/quic/test_tools/quic_packet_creator_peer.cc
+++ b/quic/test_tools/quic_packet_creator_peer.cc
@@ -83,6 +83,15 @@
 }
 
 // static
+bool QuicPacketCreatorPeer::CreateCryptoFrame(QuicPacketCreator* creator,
+                                              EncryptionLevel level,
+                                              size_t write_length,
+                                              QuicStreamOffset offset,
+                                              QuicFrame* frame) {
+  return creator->CreateCryptoFrame(level, write_length, offset, frame);
+}
+
+// static
 SerializedPacket QuicPacketCreatorPeer::SerializeAllFrames(
     QuicPacketCreator* creator,
     const QuicFrames& frames,
diff --git a/quic/test_tools/quic_packet_creator_peer.h b/quic/test_tools/quic_packet_creator_peer.h
index 0fa962c..e040090 100644
--- a/quic/test_tools/quic_packet_creator_peer.h
+++ b/quic/test_tools/quic_packet_creator_peer.h
@@ -40,6 +40,11 @@
                                 QuicStreamOffset offset,
                                 bool fin,
                                 QuicFrame* frame);
+  static bool CreateCryptoFrame(QuicPacketCreator* creator,
+                                EncryptionLevel level,
+                                size_t write_length,
+                                QuicStreamOffset offset,
+                                QuicFrame* frame);
   static SerializedPacket SerializeAllFrames(QuicPacketCreator* creator,
                                              const QuicFrames& frames,
                                              char* buffer,
diff --git a/quic/test_tools/simple_data_producer.cc b/quic/test_tools/simple_data_producer.cc
index ab98fd1..89bf5b9 100644
--- a/quic/test_tools/simple_data_producer.cc
+++ b/quic/test_tools/simple_data_producer.cc
@@ -59,10 +59,11 @@
                                          QuicByteCount data_length,
                                          QuicDataWriter* writer) {
   auto it = crypto_buffer_map_.find(std::make_pair(level, offset));
-  if (it == crypto_buffer_map_.end() || it->second.length() != data_length) {
+  if (it == crypto_buffer_map_.end() || it->second.length() < data_length) {
     return false;
   }
-  return writer->WriteStringPiece(it->second);
+  return writer->WriteStringPiece(
+      QuicStringPiece(it->second.data(), data_length));
 }
 
 }  // namespace test