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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/quic/quic_packet_creator_test.cc

Issue 1495263002: QuicPacketCreator knows when to start FEC protection. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@108738647
Patch Set: Created 5 years 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_packet_generator.cc » ('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 a39784275b98adceef1e5244ab7f040c30ebcce0..80e855f1e22a3c6ff9c658f071170fae593f9f8e 100644
--- a/net/quic/quic_packet_creator_test.cc
+++ b/net/quic/quic_packet_creator_test.cc
@@ -184,13 +184,6 @@ class QuicPacketCreatorTest : public ::testing::TestWithParam<TestParams> {
true, is_in_fec_group);
}
- // Enables and turns on FEC protection. Returns true if FEC protection is on.
- bool SwitchFecProtectionOn(size_t max_packets_per_fec_group) {
- creator_.set_max_packets_per_fec_group(max_packets_per_fec_group);
- creator_.MaybeStartFecProtection();
- return QuicPacketCreatorPeer::IsFecProtected(&creator_);
- }
-
QuicIOVector MakeIOVector(StringPiece s) {
return ::net::MakeIOVector(s, &iov_);
}
@@ -253,16 +246,21 @@ TEST_P(QuicPacketCreatorTest, SerializeFrames) {
}
TEST_P(QuicPacketCreatorTest, SerializeWithFEC) {
- // Enable FEC protection, and send FEC packet every 6 packets.
- EXPECT_TRUE(SwitchFecProtectionOn(6));
+ // Send FEC packet every 6 packets.
+ creator_.set_max_packets_per_fec_group(6);
// Should return false since we do not have enough packets in the FEC group to
// trigger an FEC packet.
ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
-
- frames_.push_back(
- QuicFrame(new QuicStreamFrame(0u, false, 0u, StringPiece())));
- SerializedPacket serialized = SerializeAllFrames(frames_);
- delete frames_[0].stream_frame;
+ // Turn on FEC protection.
+ QuicFrame frame;
+ QuicIOVector io_vector(MakeIOVector("test"));
+ ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
+ MUST_FEC_PROTECT));
+ EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
+ // Serialize the packet.
+ EXPECT_CALL(delegate_, OnSerializedPacket(_))
+ .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
+ creator_.Flush();
{
InSequence s;
@@ -275,8 +273,8 @@ TEST_P(QuicPacketCreatorTest, SerializeWithFEC) {
EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
EXPECT_CALL(framer_visitor_, OnPacketComplete());
}
- ProcessPacket(serialized.packet);
- delete serialized.packet;
+ ProcessPacket(serialized_packet_.packet);
+ ClearSerializedPacket(&serialized_packet_);
// Should return false since we do not have enough packets in the FEC group to
// trigger an FEC packet.
@@ -286,7 +284,6 @@ TEST_P(QuicPacketCreatorTest, SerializeWithFEC) {
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
- creator_.set_should_fec_protect(true);
creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
/*is_fec_timeout=*/false);
ASSERT_EQ(2u, serialized_packet_.packet_number);
@@ -440,15 +437,17 @@ TEST_P(QuicPacketCreatorTest, SerializeWithFECChangingSequenceNumberLength) {
// and we expect that packet number length should not change until the end
// of the open FEC group.
- // Enable FEC protection, and send FEC packet every 6 packets.
- EXPECT_TRUE(SwitchFecProtectionOn(6));
+ // Send FEC packet every 6 packets.
+ creator_.set_max_packets_per_fec_group(6);
// Should return false since we do not have enough packets in the FEC group to
// trigger an FEC packet.
ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
- frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u))));
// Generate Packet 1.
- creator_.AddSavedFrame(frames_[0]);
+ QuicFrame frame;
+ QuicIOVector io_vector(MakeIOVector("test"));
+ ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
+ MUST_FEC_PROTECT));
// Change the packet number length mid-FEC group and it should not change.
QuicPacketCreatorPeer::SetNextPacketNumberLength(&creator_,
PACKET_4BYTE_PACKET_NUMBER);
@@ -467,14 +466,15 @@ TEST_P(QuicPacketCreatorTest, SerializeWithFECChangingSequenceNumberLength) {
EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_));
- EXPECT_CALL(framer_visitor_, OnAckFrame(_));
+ EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
EXPECT_CALL(framer_visitor_, OnPacketComplete());
}
ProcessPacket(serialized_packet_.packet);
ClearSerializedPacket(&serialized_packet_);
// Generate Packet 2.
- creator_.AddSavedFrame(frames_[0]);
+ ASSERT_TRUE(creator_.ConsumeData(2u, io_vector, 0u, 0u, false, false, &frame,
+ MUST_FEC_PROTECT));
creator_.Flush();
EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
serialized_packet_.packet_number_length);
@@ -487,7 +487,7 @@ TEST_P(QuicPacketCreatorTest, SerializeWithFECChangingSequenceNumberLength) {
EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_));
- EXPECT_CALL(framer_visitor_, OnAckFrame(_));
+ EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
EXPECT_CALL(framer_visitor_, OnPacketComplete());
}
ProcessPacket(serialized_packet_.packet);
@@ -502,7 +502,8 @@ TEST_P(QuicPacketCreatorTest, SerializeWithFECChangingSequenceNumberLength) {
// Force generation of FEC packet.
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
- creator_.set_should_fec_protect(true);
+ // Turn off FEC protection.
+ creator_.set_should_fec_protect_next_packet(false);
creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
/*is_fec_timeout=*/false);
EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
@@ -523,10 +524,15 @@ TEST_P(QuicPacketCreatorTest, SerializeWithFECChangingSequenceNumberLength) {
ClearSerializedPacket(&serialized_packet_);
// Ensure the next FEC group starts using the new packet number length.
- SerializedPacket serialized = SerializeAllFrames(frames_);
- EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER, serialized.packet_number_length);
- delete frames_[0].ack_frame;
- ClearSerializedPacket(&serialized);
+ ASSERT_TRUE(creator_.ConsumeData(3u, io_vector, 0u, 0u, false, false, &frame,
+ MUST_FEC_PROTECT));
+ EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
+ EXPECT_CALL(delegate_, OnSerializedPacket(_))
+ .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
+ creator_.Flush();
+ EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
+ serialized_packet_.packet_number_length);
+ ClearSerializedPacket(&serialized_packet_);
}
TEST_P(QuicPacketCreatorTest, ReserializeFramesWithSequenceNumberLength) {
@@ -645,34 +651,18 @@ TEST_P(QuicPacketCreatorTest, SerializeConnectionClose) {
delete serialized.packet;
}
-TEST_P(QuicPacketCreatorTest, SwitchFecOnOffWithNoGroup) {
- // Enable FEC protection.
+TEST_P(QuicPacketCreatorTest, SwitchFecOnOffWithGroupInProgress) {
+ // Send FEC packet every 6 packets.
creator_.set_max_packets_per_fec_group(6);
- EXPECT_TRUE(QuicPacketCreatorPeer::IsFecEnabled(&creator_));
- EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-
// Turn on FEC protection.
- creator_.MaybeStartFecProtection();
- EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
- // We have no packets in the FEC group, so no FEC packet can be created.
- EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/true));
- // Since no packets are in FEC group yet, we should be able to turn FEC
- // off with no trouble.
- creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
- /*is_fec_timeout=*/false);
- EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-}
-
-TEST_P(QuicPacketCreatorTest, SwitchFecOnOffWithGroupInProgress) {
- // Enable FEC protection, and send FEC packet every 6 packets.
- EXPECT_TRUE(SwitchFecProtectionOn(6));
- frames_.push_back(
- QuicFrame(new QuicStreamFrame(0u, false, 0u, StringPiece())));
- SerializedPacket serialized = SerializeAllFrames(frames_);
- delete frames_[0].stream_frame;
- delete serialized.packet;
-
+ QuicFrame frame;
+ QuicIOVector io_vector(MakeIOVector("test"));
+ ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
+ MUST_FEC_PROTECT));
EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
+ EXPECT_CALL(delegate_, OnSerializedPacket(_))
+ .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
+ creator_.Flush();
// We do not have enough packets in the FEC group to trigger an FEC packet.
EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
// Should return true since there are packets in the FEC group.
@@ -688,20 +678,20 @@ TEST_P(QuicPacketCreatorTest, SwitchFecOnOffWithGroupInProgress) {
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
- // Switching FEC on/off should work now.
+ // Turn off FEC protection.
+ creator_.set_should_fec_protect_next_packet(false);
creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
/*is_fec_timeout=*/false);
EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
- creator_.MaybeStartFecProtection();
- EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
}
TEST_P(QuicPacketCreatorTest, SwitchFecOnWithStreamFrameQueued) {
// Add a stream frame to the creator.
QuicFrame frame;
QuicIOVector io_vector(MakeIOVector("test"));
- ASSERT_TRUE(
- creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame));
+ ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
+ MAY_FEC_PROTECT));
+ EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
ASSERT_TRUE(frame.stream_frame);
size_t consumed = frame.stream_frame->frame_length;
EXPECT_EQ(4u, consumed);
@@ -717,16 +707,20 @@ TEST_P(QuicPacketCreatorTest, SwitchFecOnWithStreamFrameQueued) {
// Start FEC protection after current open packet is flushed.
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
- creator_.MaybeStartFecProtection();
- EXPECT_FALSE(creator_.HasPendingFrames());
+ ASSERT_TRUE(creator_.ConsumeData(2u, io_vector, 0u, 0u, false, false, &frame,
+ MUST_FEC_PROTECT));
+ ASSERT_TRUE(frame.stream_frame);
+ consumed = frame.stream_frame->frame_length;
+ EXPECT_EQ(4u, consumed);
+ EXPECT_TRUE(creator_.HasPendingFrames());
EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
}
TEST_P(QuicPacketCreatorTest, ConsumeData) {
QuicFrame frame;
QuicIOVector io_vector(MakeIOVector("test"));
- ASSERT_TRUE(
- creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame));
+ ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
+ MAY_FEC_PROTECT));
ASSERT_TRUE(frame.stream_frame);
size_t consumed = frame.stream_frame->frame_length;
EXPECT_EQ(4u, consumed);
@@ -737,8 +731,8 @@ TEST_P(QuicPacketCreatorTest, ConsumeData) {
TEST_P(QuicPacketCreatorTest, ConsumeDataFin) {
QuicFrame frame;
QuicIOVector io_vector(MakeIOVector("test"));
- ASSERT_TRUE(
- creator_.ConsumeData(1u, io_vector, 0u, 10u, true, false, &frame));
+ ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 10u, true, false, &frame,
+ MAY_FEC_PROTECT));
ASSERT_TRUE(frame.stream_frame);
size_t consumed = frame.stream_frame->frame_length;
EXPECT_EQ(4u, consumed);
@@ -749,7 +743,8 @@ TEST_P(QuicPacketCreatorTest, ConsumeDataFin) {
TEST_P(QuicPacketCreatorTest, ConsumeDataFinOnly) {
QuicFrame frame;
QuicIOVector io_vector(nullptr, 0, 0);
- ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, true, false, &frame));
+ ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, true, false, &frame,
+ MAY_FEC_PROTECT));
ASSERT_TRUE(frame.stream_frame);
size_t consumed = frame.stream_frame->frame_length;
EXPECT_EQ(0u, consumed);
@@ -757,6 +752,21 @@ TEST_P(QuicPacketCreatorTest, ConsumeDataFinOnly) {
EXPECT_TRUE(creator_.HasPendingFrames());
}
+TEST_P(QuicPacketCreatorTest, ConsumeDataWithFecProtect) {
+ creator_.set_max_packets_per_fec_group(6);
+ QuicFrame frame;
+ QuicIOVector io_vector(MakeIOVector("test"));
+ EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
+ ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
+ MUST_FEC_PROTECT));
+ ASSERT_TRUE(frame.stream_frame);
+ size_t consumed = frame.stream_frame->frame_length;
+ EXPECT_EQ(4u, consumed);
+ CheckStreamFrame(frame, 1u, "test", 0u, false);
+ EXPECT_TRUE(creator_.HasPendingFrames());
+ EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
+}
+
TEST_P(QuicPacketCreatorTest, CreateAllFreeBytesForStreamFrames) {
const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP)
+ GetEncryptionOverhead();
@@ -773,7 +783,8 @@ TEST_P(QuicPacketCreatorTest, CreateAllFreeBytesForStreamFrames) {
.WillRepeatedly(
Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
ASSERT_TRUE(creator_.ConsumeData(kClientDataStreamId1, io_vector, 0u,
- kOffset, false, false, &frame));
+ kOffset, false, false, &frame,
+ MAY_FEC_PROTECT));
ASSERT_TRUE(frame.stream_frame);
size_t bytes_consumed = frame.stream_frame->frame_length;
EXPECT_LT(0u, bytes_consumed);
@@ -814,8 +825,18 @@ TEST_P(QuicPacketCreatorTest, StreamFrameConsumption) {
}
TEST_P(QuicPacketCreatorTest, StreamFrameConsumptionWithFec) {
- // Enable FEC protection, and send FEC packet every 6 packets.
- EXPECT_TRUE(SwitchFecProtectionOn(6));
+ // Send FEC packet every 6 packets.
+ creator_.set_max_packets_per_fec_group(6);
+ // Turn on FEC protection.
+ QuicFrame frame;
+ QuicIOVector io_vector(MakeIOVector("test"));
+ ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
+ MUST_FEC_PROTECT));
+ EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
+ // Serialize the packet.
+ EXPECT_CALL(delegate_, OnSerializedPacket(_))
+ .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
+ creator_.Flush();
// Compute the total overhead for a single frame in packet.
const size_t overhead = GetPacketHeaderOverhead(IN_FEC_GROUP) +
GetEncryptionOverhead() +
@@ -864,7 +885,7 @@ TEST_P(QuicPacketCreatorTest, CryptoStreamFramePacketPadding) {
.WillRepeatedly(
Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
ASSERT_TRUE(creator_.ConsumeData(kCryptoStreamId, io_vector, 0u, kOffset,
- false, true, &frame));
+ false, true, &frame, MAY_FEC_PROTECT));
ASSERT_TRUE(frame.stream_frame);
size_t bytes_consumed = frame.stream_frame->frame_length;
EXPECT_LT(0u, bytes_consumed);
@@ -899,7 +920,8 @@ TEST_P(QuicPacketCreatorTest, NonCryptoStreamFramePacketNonPadding) {
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
ASSERT_TRUE(creator_.ConsumeData(kClientDataStreamId1, io_vector, 0u,
- kOffset, false, false, &frame));
+ kOffset, false, false, &frame,
+ MAY_FEC_PROTECT));
ASSERT_TRUE(frame.stream_frame);
size_t bytes_consumed = frame.stream_frame->frame_length;
EXPECT_LT(0u, bytes_consumed);
@@ -1030,7 +1052,8 @@ TEST_P(QuicPacketCreatorTest, ConsumeDataLargerThanOneStreamFrame) {
QuicIOVector io_vector(MakeIOVector(too_long_payload));
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
- ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, true, false, &frame));
+ ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, true, false, &frame,
+ MAY_FEC_PROTECT));
ASSERT_TRUE(frame.stream_frame);
size_t consumed = frame.stream_frame->frame_length;
EXPECT_EQ(payload_length, consumed);
@@ -1062,8 +1085,8 @@ TEST_P(QuicPacketCreatorTest, AddFrameAndFlush) {
QuicFrame frame;
QuicIOVector io_vector(MakeIOVector("test"));
- ASSERT_TRUE(
- creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame));
+ ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
+ MAY_FEC_PROTECT));
ASSERT_TRUE(frame.stream_frame);
size_t consumed = frame.stream_frame->frame_length;
EXPECT_EQ(4u, consumed);
@@ -1123,8 +1146,8 @@ TEST_P(QuicPacketCreatorTest, SerializeTruncatedAckFrameWithLargePacketSize) {
// Make sure that an additional stream frame can be added to the packet.
QuicFrame frame;
QuicIOVector io_vector(MakeIOVector("test"));
- ASSERT_TRUE(
- creator_.ConsumeData(2u, io_vector, 0u, 0u, false, false, &frame));
+ ASSERT_TRUE(creator_.ConsumeData(2u, io_vector, 0u, 0u, false, false, &frame,
+ MAY_FEC_PROTECT));
ASSERT_TRUE(frame.stream_frame);
size_t consumed = frame.stream_frame->frame_length;
EXPECT_EQ(4u, consumed);
@@ -1207,12 +1230,17 @@ TEST_P(QuicPacketCreatorTest, EntropyFlag) {
}
TEST_P(QuicPacketCreatorTest, ResetFecGroup) {
- // Enable FEC protection, and send FEC packet every 6 packets.
- EXPECT_TRUE(SwitchFecProtectionOn(6));
- frames_.push_back(
- QuicFrame(new QuicStreamFrame(0u, false, 0u, StringPiece())));
- SerializedPacket serialized = SerializeAllFrames(frames_);
- delete serialized.packet;
+ // Send FEC packet every 6 packets.
+ creator_.set_max_packets_per_fec_group(6);
+ // Add a stream frame and turn on FEC protection.
+ QuicFrame frame;
+ QuicIOVector io_vector(MakeIOVector("test"));
+ ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
+ MUST_FEC_PROTECT));
+ // Serialize the packet.
+ EXPECT_CALL(delegate_, OnSerializedPacket(_))
+ .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
+ creator_.Flush();
EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
EXPECT_TRUE(creator_.IsFecGroupOpen());
@@ -1225,7 +1253,7 @@ TEST_P(QuicPacketCreatorTest, ResetFecGroup) {
// not fire.
EXPECT_CALL(delegate_, OnResetFecGroup()).Times(1);
creator_.set_fec_send_policy(FEC_ALARM_TRIGGER);
- creator_.set_should_fec_protect(true);
+ creator_.set_should_fec_protect_next_packet(true);
creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
/*is_fec_timeout=*/false);
EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
@@ -1235,15 +1263,17 @@ TEST_P(QuicPacketCreatorTest, ResetFecGroup) {
// Confirm that there is no FEC packet under construction.
EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/true));
- EXPECT_DFATAL(serialized = QuicPacketCreatorPeer::SerializeFec(
- &creator_, buffer_, kMaxPacketSize),
- "SerializeFEC called but no group or zero packets in group.");
- delete serialized.packet;
+ char buffer[kMaxPacketSize];
+ EXPECT_DFATAL(
+ QuicPacketCreatorPeer::SerializeFec(&creator_, buffer, kMaxPacketSize),
+ "SerializeFEC called but no group or zero packets in group.");
- // Start a new FEC packet.
- serialized = SerializeAllFrames(frames_);
- delete frames_[0].stream_frame;
- delete serialized.packet;
+ // Create and send a new FEC protected packet.
+ ASSERT_TRUE(creator_.ConsumeData(2u, io_vector, 0u, 0u, false, false, &frame,
+ MUST_FEC_PROTECT));
+ EXPECT_CALL(delegate_, OnSerializedPacket(_))
+ .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
+ creator_.Flush();
EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
EXPECT_TRUE(creator_.IsFecGroupOpen());
@@ -1262,6 +1292,7 @@ TEST_P(QuicPacketCreatorTest, ResetFecGroup) {
creator_.set_fec_send_policy(FEC_ANY_TRIGGER);
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
+ creator_.set_should_fec_protect_next_packet(false);
creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
/*is_fec_timeout=*/false);
ASSERT_EQ(3u, serialized_packet_.packet_number);
@@ -1269,13 +1300,13 @@ TEST_P(QuicPacketCreatorTest, ResetFecGroup) {
}
TEST_P(QuicPacketCreatorTest, ResetFecGroupWithQueuedFrames) {
- // Enable FEC protection, and send FEC packet every 6 packets.
- EXPECT_TRUE(SwitchFecProtectionOn(6));
- // Add a stream frame to the creator.
+ // Send FEC packet every 6 packets.
+ creator_.set_max_packets_per_fec_group(6);
+ // Add a stream frame to the creator and turn on FEC protection.
QuicFrame frame;
QuicIOVector io_vector(MakeIOVector("test"));
- ASSERT_TRUE(
- creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame));
+ ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
+ MUST_FEC_PROTECT));
ASSERT_TRUE(frame.stream_frame);
size_t consumed = frame.stream_frame->frame_length;
EXPECT_EQ(4u, consumed);
@@ -1292,7 +1323,7 @@ TEST_P(QuicPacketCreatorTest, ResetFecGroupWithQueuedFrames) {
// not fire.
EXPECT_CALL(delegate_, OnResetFecGroup()).Times(1);
creator_.set_fec_send_policy(FEC_ALARM_TRIGGER);
- creator_.set_should_fec_protect(true);
+ creator_.set_should_fec_protect_next_packet(true);
creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
/*is_fec_timeout=*/false);
EXPECT_FALSE(creator_.IsFecGroupOpen());
« no previous file with comments | « net/quic/quic_packet_creator.cc ('k') | net/quic/quic_packet_generator.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698