gfe-relnote: test-only changes to reduce usage of QuicUtils::GetCryptoStreamId PiperOrigin-RevId: 239456451 Change-Id: I93caa841e2fa34766a2efee31eee034d577aa481
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