Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(291)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/quic/quic_packet_creator_test.cc

Issue 2104633002: Landing recent QUIC changes until 6/24/2016 14:00 UTC (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Rebase Created 4 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/quic/quic_packet_creator.cc ('k') | net/quic/quic_protocol.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/quic/quic_packet_creator_test.cc
diff --git a/net/quic/quic_packet_creator_test.cc b/net/quic/quic_packet_creator_test.cc
index 145d50fa4b8a9a60d4759f5e1a6dcb10630bdd1c..df2e399ddc3675880bce35a2aca7ad885c0bce89 100644
--- a/net/quic/quic_packet_creator_test.cc
+++ b/net/quic/quic_packet_creator_test.cc
@@ -179,10 +179,17 @@ class QuicPacketCreatorTest : public ::testing::TestWithParam<TestParams> {
// Returns the number of bytes consumed by the header of packet, including
// the version.
size_t GetPacketHeaderOverhead(QuicVersion version) {
- return GetPacketHeaderSize(
- version, creator_.connection_id_length(), kIncludeVersion,
- !kIncludePathId, !kIncludeDiversificationNonce,
- QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
+ if (FLAGS_quic_simple_packet_number_length) {
+ return GetPacketHeaderSize(
+ version, creator_.connection_id_length(), kIncludeVersion,
+ !kIncludePathId, !kIncludeDiversificationNonce,
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+ } else {
+ return GetPacketHeaderSize(
+ version, creator_.connection_id_length(), kIncludeVersion,
+ !kIncludePathId, !kIncludeDiversificationNonce,
+ QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
+ }
}
// Returns the number of bytes of overhead that will be added to a packet
@@ -273,6 +280,7 @@ TEST_P(QuicPacketCreatorTest, SerializeFrames) {
}
TEST_P(QuicPacketCreatorTest, SerializeChangingSequenceNumberLength) {
+ FLAGS_quic_simple_packet_number_length = false;
frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u))));
creator_.AddSavedFrame(frames_[0]);
QuicPacketCreatorPeer::SetNextPacketNumberLength(&creator_,
@@ -321,6 +329,7 @@ TEST_P(QuicPacketCreatorTest, SerializeChangingSequenceNumberLength) {
}
TEST_P(QuicPacketCreatorTest, ChangeSequenceNumberLengthMidPacket) {
+ FLAGS_quic_simple_packet_number_length = false;
// Changing the packet number length with queued frames in the creator
// should hold the change until after any currently queued frames are
// serialized.
@@ -402,12 +411,33 @@ TEST_P(QuicPacketCreatorTest, ChangeSequenceNumberLengthMidPacket) {
delete ack_frame.ack_frame;
}
+TEST_P(QuicPacketCreatorTest, ChangeSequenceNumberLengthMidPacketDoesNothing) {
+ FLAGS_quic_simple_packet_number_length = true;
+ EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+ // Changing the packet number length with queued frames in the creator
+ // should do nothing.
+ EXPECT_FALSE(creator_.HasPendingFrames());
+ QuicFrame ack_frame = QuicFrame(new QuicAckFrame(MakeAckFrame(0u)));
+ creator_.AddSavedFrame(ack_frame);
+
+ // Now change packet number length and expect a QUIC_BUG and no change in
+ // packet number length.
+ EXPECT_DFATAL(creator_.UpdatePacketNumberLength(0, 256),
+ "Called UpdatePacketNumberLength with 1 queued_frames.");
+ EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+ delete ack_frame.ack_frame;
+}
+
TEST_P(QuicPacketCreatorTest, ReserializeFramesWithSequenceNumberLength) {
// If the original packet number length, the current packet number
// length, and the configured send packet number length are different, the
// retransmit must sent with the original length and the others do not change.
- QuicPacketCreatorPeer::SetNextPacketNumberLength(&creator_,
- PACKET_4BYTE_PACKET_NUMBER);
+ if (!FLAGS_quic_simple_packet_number_length) {
+ QuicPacketCreatorPeer::SetNextPacketNumberLength(
+ &creator_, PACKET_4BYTE_PACKET_NUMBER);
+ }
QuicPacketCreatorPeer::SetPacketNumberLength(&creator_,
PACKET_2BYTE_PACKET_NUMBER);
QuicStreamFrame* stream_frame =
@@ -421,10 +451,17 @@ TEST_P(QuicPacketCreatorTest, ReserializeFramesWithSequenceNumberLength) {
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
- EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
- QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
- EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
- QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+ if (FLAGS_quic_simple_packet_number_length) {
+ // The packet number length is updated after every packet is sent,
+ // so there is no need to restore the old length after sending.
+ EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+ } else {
+ EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
+ QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
+ EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+ }
EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
serialized_packet_.packet_number_length);
@@ -453,7 +490,7 @@ TEST_P(QuicPacketCreatorTest, ReserializeCryptoFrameWithForwardSecurity) {
PendingRetransmission retransmission(CreateRetransmission(
frames, true /* has_crypto_handshake */, -1 /* needs full padding */,
ENCRYPTION_NONE,
- QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)));
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
@@ -471,7 +508,7 @@ TEST_P(QuicPacketCreatorTest, ReserializeFrameWithForwardSecurity) {
PendingRetransmission retransmission(CreateRetransmission(
frames, false /* has_crypto_handshake */, 0 /* no padding */,
ENCRYPTION_NONE,
- QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)));
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
@@ -490,7 +527,7 @@ TEST_P(QuicPacketCreatorTest, ReserializeFramesWithFullPadding) {
PendingRetransmission retransmission(CreateRetransmission(
frames, true /* has_crypto_handshake */, -1 /* needs full padding */,
ENCRYPTION_NONE,
- QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)));
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
@@ -513,7 +550,9 @@ TEST_P(QuicPacketCreatorTest, ReserializeFramesWithSpecifiedPadding) {
PendingRetransmission retransmission(CreateRetransmission(
frames, false /* has_crypto_handshake */,
kNumPaddingBytes1 /* padding bytes */, ENCRYPTION_NONE,
- QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)));
+ FLAGS_quic_simple_packet_number_length
+ ? QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)
+ : QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)));
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
@@ -527,7 +566,7 @@ TEST_P(QuicPacketCreatorTest, ReserializeFramesWithSpecifiedPadding) {
PendingRetransmission retransmission(CreateRetransmission(
frames, false /* has_crypto_handshake */,
kNumPaddingBytes2 /* padding bytes */, ENCRYPTION_NONE,
- QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)));
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
@@ -556,7 +595,7 @@ TEST_P(QuicPacketCreatorTest, ReserializeFramesWithFullPacketAndPadding) {
PendingRetransmission retransmission(CreateRetransmission(
frames, true /* has_crypto_handshake */, -1 /* needs full padding */,
ENCRYPTION_NONE,
- QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)));
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
@@ -772,7 +811,8 @@ TEST_P(QuicPacketCreatorTest, SerializeVersionNegotiationPacket) {
client_framer_.ProcessPacket(*encrypted);
}
-TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthLeastAwaiting) {
+TEST_P(QuicPacketCreatorTest, UpdatePacketNumberLengthLeastAwaiting_Old) {
+ FLAGS_quic_simple_packet_number_length = false;
EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
@@ -798,7 +838,8 @@ TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthLeastAwaiting) {
QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
}
-TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthBandwidth) {
+TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthBandwidth_old) {
+ FLAGS_quic_simple_packet_number_length = false;
EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
@@ -821,6 +862,57 @@ TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthBandwidth) {
QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
}
+TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthLeastAwaiting) {
+ FLAGS_quic_simple_packet_number_length = true;
+ EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+
+ QuicPacketCreatorPeer::SetPacketNumber(&creator_, 64);
+ creator_.UpdatePacketNumberLength(2, 10000 / kDefaultMaxPacketSize);
+ EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+
+ QuicPacketCreatorPeer::SetPacketNumber(&creator_, 64 * 256);
+ creator_.UpdatePacketNumberLength(2, 10000 / kDefaultMaxPacketSize);
+ EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+
+ QuicPacketCreatorPeer::SetPacketNumber(&creator_, 64 * 256 * 256);
+ creator_.UpdatePacketNumberLength(2, 10000 / kDefaultMaxPacketSize);
+ EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+
+ QuicPacketCreatorPeer::SetPacketNumber(&creator_,
+ UINT64_C(64) * 256 * 256 * 256 * 256);
+ creator_.UpdatePacketNumberLength(2, 10000 / kDefaultMaxPacketSize);
+ EXPECT_EQ(PACKET_6BYTE_PACKET_NUMBER,
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+}
+
+TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthCwnd) {
+ FLAGS_quic_simple_packet_number_length = true;
+ EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+
+ creator_.UpdatePacketNumberLength(1, 10000 / kDefaultMaxPacketSize);
+ EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+
+ creator_.UpdatePacketNumberLength(1, 10000 * 256 / kDefaultMaxPacketSize);
+ EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+
+ creator_.UpdatePacketNumberLength(1,
+ 10000 * 256 * 256 / kDefaultMaxPacketSize);
+ EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+
+ creator_.UpdatePacketNumberLength(
+ 1, UINT64_C(1000) * 256 * 256 * 256 * 256 / kDefaultMaxPacketSize);
+ EXPECT_EQ(PACKET_6BYTE_PACKET_NUMBER,
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+}
+
TEST_P(QuicPacketCreatorTest, SerializeFrame) {
if (!GetParam().version_serialization) {
creator_.StopSendingVersion();
@@ -1075,7 +1167,7 @@ TEST_P(QuicPacketCreatorTest, SetCurrentPath) {
EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_));
EXPECT_EQ(0u, creator_.packet_number());
EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
- QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
// Add a stream frame to the creator.
QuicFrame frame;
QuicIOVector io_vector(MakeIOVector("test"));
@@ -1102,14 +1194,14 @@ TEST_P(QuicPacketCreatorTest, SetCurrentPath) {
EXPECT_FALSE(creator_.HasPendingFrames());
EXPECT_EQ(0u, creator_.packet_number());
EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
- QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
// Change current path back.
creator_.SetCurrentPath(kDefaultPathId, 2, 1);
EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_));
EXPECT_EQ(1u, creator_.packet_number());
EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
- QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
// Add a stream frame to the creator.
ASSERT_TRUE(
creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame));
@@ -1124,14 +1216,17 @@ TEST_P(QuicPacketCreatorTest, SetCurrentPath) {
EXPECT_TRUE(creator_.HasPendingFrames());
EXPECT_EQ(1u, creator_.packet_number());
EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
- QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
}
TEST_P(QuicPacketCreatorTest,
SetCurrentPathAndUpdatePacketSequenceNumberLength) {
+ FLAGS_quic_simple_packet_number_length = false;
// Current path is the default path.
EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_));
EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
+ EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
QuicPacketCreatorPeer::SetPacketNumber(&creator_, 64 * 256 - 2);
// Add a stream frame to the creator and send the packet.
@@ -1194,7 +1289,7 @@ TEST_P(QuicPacketCreatorTest, SerializePacketOnDifferentPath) {
EXPECT_FALSE(creator_.HasPendingFrames());
EXPECT_EQ(0u, creator_.packet_number());
EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
- QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
+ QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
// Add a stream frame to the creator and flush the packet.
ASSERT_TRUE(
@@ -1219,7 +1314,6 @@ TEST_P(QuicPacketCreatorTest, AddUnencryptedStreamDataClosesConnection) {
}
TEST_P(QuicPacketCreatorTest, ChloTooLarge) {
- ValueRestore<bool> old_flag(&FLAGS_quic_disallow_multi_packet_chlo, true);
CryptoHandshakeMessage message;
message.set_tag(kCHLO);
message.set_minimum_size(kMaxPacketSize);
« no previous file with comments | « net/quic/quic_packet_creator.cc ('k') | net/quic/quic_protocol.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698