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
