(n/a, not in use) Make IETF probing packets not always contribute to RTT measurement.
Probing packets can be sent on current path and alternative path. It is ideal that when it's sent on alternative path, its ACK doesn't contribute to the RTT measurement on the current path.
This change added a new state for SentPacketState for that purpose, and make SentPacketManager::OnPacketSent() take an extra parameter to indicate if the packet is sent on alternative path.
PiperOrigin-RevId: 328330767
Change-Id: Ibba53390097cfa8cd08362dca3595c13154a6db9
diff --git a/quic/core/congestion_control/general_loss_algorithm_test.cc b/quic/core/congestion_control/general_loss_algorithm_test.cc
index 9124e49..42b97bf 100644
--- a/quic/core/congestion_control/general_loss_algorithm_test.cc
+++ b/quic/core/congestion_control/general_loss_algorithm_test.cc
@@ -43,7 +43,7 @@
encrypted_length, false, false);
packet.retransmittable_frames.push_back(QuicFrame(frame));
unacked_packets_.AddSentPacket(&packet, NOT_RETRANSMISSION, clock_.Now(),
- true);
+ true, true);
}
void SendDataPacket(uint64_t packet_number) {
@@ -55,7 +55,7 @@
PACKET_1BYTE_PACKET_NUMBER, nullptr, kDefaultLength,
true, false);
unacked_packets_.AddSentPacket(&packet, NOT_RETRANSMISSION, clock_.Now(),
- false);
+ false, true);
}
void VerifyLosses(uint64_t largest_newly_acked,
diff --git a/quic/core/congestion_control/uber_loss_algorithm_test.cc b/quic/core/congestion_control/uber_loss_algorithm_test.cc
index 458152f..7a9d37e 100644
--- a/quic/core/congestion_control/uber_loss_algorithm_test.cc
+++ b/quic/core/congestion_control/uber_loss_algorithm_test.cc
@@ -53,7 +53,7 @@
packet.encryption_level = encryption_level;
packet.retransmittable_frames.push_back(QuicFrame(frame));
unacked_packets_->AddSentPacket(&packet, NOT_RETRANSMISSION, clock_.Now(),
- true);
+ true, true);
}
void AckPackets(const std::vector<uint64_t>& packets_acked) {
diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index c37bacc..12fc297 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -605,7 +605,7 @@
QuicPacketNumber(1) + kMinPacketsBetweenServerConfigUpdates,
PACKET_4BYTE_PACKET_NUMBER, nullptr, 1000, false, false);
sent_packet_manager->OnPacketSent(&packet, now, NOT_RETRANSMISSION,
- HAS_RETRANSMITTABLE_DATA);
+ HAS_RETRANSMITTABLE_DATA, true);
// Verify that the proto has exactly the values we expect.
CachedNetworkParameters expected_network_params;
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 5f0a521..c1e3985 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -2862,7 +2862,7 @@
const bool in_flight = sent_packet_manager_.OnPacketSent(
packet, packet_send_time, packet->transmission_type,
- IsRetransmittable(*packet));
+ IsRetransmittable(*packet), /*measure_rtt=*/true);
QUIC_BUG_IF(default_enable_5rto_blackhole_detection_ &&
blackhole_detector_.IsDetectionInProgress() &&
!sent_packet_manager_.HasInFlightPackets())
@@ -3975,9 +3975,9 @@
}
// Call OnPacketSent regardless of the write result.
- sent_packet_manager_.OnPacketSent(probing_packet.get(), packet_send_time,
- probing_packet->transmission_type,
- NO_RETRANSMITTABLE_DATA);
+ sent_packet_manager_.OnPacketSent(
+ probing_packet.get(), packet_send_time, probing_packet->transmission_type,
+ NO_RETRANSMITTABLE_DATA, /*measure_rtt=*/true);
if (IsWriteBlockedStatus(result.status)) {
if (probing_writer == writer_) {
diff --git a/quic/core/quic_sent_packet_manager.cc b/quic/core/quic_sent_packet_manager.cc
index 4746eae..bf17acd 100644
--- a/quic/core/quic_sent_packet_manager.cc
+++ b/quic/core/quic_sent_packet_manager.cc
@@ -691,7 +691,8 @@
SerializedPacket* serialized_packet,
QuicTime sent_time,
TransmissionType transmission_type,
- HasRetransmittableData has_retransmittable_data) {
+ HasRetransmittableData has_retransmittable_data,
+ bool measure_rtt) {
QuicPacketNumber packet_number = serialized_packet->packet_number;
DCHECK_LE(FirstSendingPacketNumber(), packet_number);
DCHECK(!unacked_packets_.IsUnacked(packet_number));
@@ -717,7 +718,7 @@
}
unacked_packets_.AddSentPacket(serialized_packet, transmission_type,
- sent_time, in_flight);
+ sent_time, in_flight, measure_rtt);
// Reset the retransmission timer anytime a pending packet is sent.
return in_flight;
}
diff --git a/quic/core/quic_sent_packet_manager.h b/quic/core/quic_sent_packet_manager.h
index 9e5bd96..1279c87 100644
--- a/quic/core/quic_sent_packet_manager.h
+++ b/quic/core/quic_sent_packet_manager.h
@@ -186,12 +186,14 @@
}
// Called when we have sent bytes to the peer. This informs the manager both
- // the number of bytes sent and if they were retransmitted. Returns true if
- // the sender should reset the retransmission timer.
+ // the number of bytes sent and if they were retransmitted and if this packet
+ // is used for rtt measuring. Returns true if the sender should reset the
+ // retransmission timer.
bool OnPacketSent(SerializedPacket* serialized_packet,
QuicTime sent_time,
TransmissionType transmission_type,
- HasRetransmittableData has_retransmittable_data);
+ HasRetransmittableData has_retransmittable_data,
+ bool measure_rtt);
// Called when the retransmission timer expires and returns the retransmission
// mode.
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index 57abfab..3187d7c 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -69,7 +69,7 @@
QuicFrame(QuicStreamFrame(1, false, 0, quiche::QuicheStringPiece())));
packet.has_crypto_handshake = IS_HANDSHAKE;
manager_.OnPacketSent(&packet, clock_.Now(), HANDSHAKE_RETRANSMISSION,
- HAS_RETRANSMITTABLE_DATA);
+ HAS_RETRANSMITTABLE_DATA, true);
}
void RetransmitDataPacket(uint64_t packet_number,
@@ -81,8 +81,8 @@
kDefaultLength, HAS_RETRANSMITTABLE_DATA));
SerializedPacket packet(CreatePacket(packet_number, true));
packet.encryption_level = level;
- manager_.OnPacketSent(&packet, clock_.Now(), type,
- HAS_RETRANSMITTABLE_DATA);
+ manager_.OnPacketSent(&packet, clock_.Now(), type, HAS_RETRANSMITTABLE_DATA,
+ true);
}
void RetransmitDataPacket(uint64_t packet_number, TransmissionType type) {
@@ -238,7 +238,7 @@
kDefaultLength, HAS_RETRANSMITTABLE_DATA));
SerializedPacket packet(CreatePacket(new_packet_number, true));
manager_.OnPacketSent(&packet, clock_.Now(), transmission_type,
- HAS_RETRANSMITTABLE_DATA);
+ HAS_RETRANSMITTABLE_DATA, true);
}
SerializedPacket CreateDataPacket(uint64_t packet_number) {
@@ -276,7 +276,7 @@
SerializedPacket packet(CreateDataPacket(packet_number));
packet.encryption_level = encryption_level;
manager_.OnPacketSent(&packet, clock_.Now(), NOT_RETRANSMISSION,
- HAS_RETRANSMITTABLE_DATA);
+ HAS_RETRANSMITTABLE_DATA, true);
}
void SendPingPacket(uint64_t packet_number,
@@ -287,7 +287,7 @@
SerializedPacket packet(CreatePingPacket(packet_number));
packet.encryption_level = encryption_level;
manager_.OnPacketSent(&packet, clock_.Now(), NOT_RETRANSMISSION,
- HAS_RETRANSMITTABLE_DATA);
+ HAS_RETRANSMITTABLE_DATA, true);
}
void SendCryptoPacket(uint64_t packet_number) {
@@ -300,7 +300,7 @@
QuicFrame(QuicStreamFrame(1, false, 0, quiche::QuicheStringPiece())));
packet.has_crypto_handshake = IS_HANDSHAKE;
manager_.OnPacketSent(&packet, clock_.Now(), NOT_RETRANSMISSION,
- HAS_RETRANSMITTABLE_DATA);
+ HAS_RETRANSMITTABLE_DATA, true);
EXPECT_CALL(notifier_, HasUnackedCryptoData()).WillRepeatedly(Return(true));
}
@@ -319,7 +319,7 @@
packet.largest_acked = QuicPacketNumber(largest_acked);
packet.encryption_level = level;
manager_.OnPacketSent(&packet, clock_.Now(), NOT_RETRANSMISSION,
- NO_RETRANSMITTABLE_DATA);
+ NO_RETRANSMITTABLE_DATA, true);
}
void EnablePto(QuicTag tag) {
@@ -2272,7 +2272,7 @@
SerializedPacket packet(QuicPacketNumber(1), PACKET_4BYTE_PACKET_NUMBER,
nullptr, kDefaultLength + 100, false, false);
manager_.OnPacketSent(&packet, clock_.Now(), NOT_RETRANSMISSION,
- HAS_RETRANSMITTABLE_DATA);
+ HAS_RETRANSMITTABLE_DATA, true);
// Ack the large packet and expect the path MTU to increase.
ExpectAck(1);
@@ -4190,6 +4190,33 @@
manager_.GetRetransmissionTime());
}
+TEST_F(QuicSentPacketManagerTest, SendPathChallengeAndGetAck) {
+ QuicPacketNumber packet_number(1);
+ EXPECT_CALL(*send_algorithm_,
+ OnPacketSent(_, BytesInFlight(), packet_number, _, _));
+ SerializedPacket packet(packet_number, PACKET_4BYTE_PACKET_NUMBER, nullptr,
+ kDefaultLength, false, false);
+ QuicPathFrameBuffer path_frame_buffer{0, 1, 2, 3, 4, 5, 6, 7};
+ packet.nonretransmittable_frames.push_back(
+ QuicFrame(new QuicPathChallengeFrame(0, path_frame_buffer)));
+ packet.encryption_level = ENCRYPTION_FORWARD_SECURE;
+ manager_.OnPacketSent(&packet, clock_.Now(), NOT_RETRANSMISSION,
+ NO_RETRANSMITTABLE_DATA, false);
+ clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
+ EXPECT_CALL(*send_algorithm_,
+ OnCongestionEvent(/*rtt_updated=*/false, _, _,
+ Pointwise(PacketNumberEq(), {1}), IsEmpty()));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
+
+ // Get ACK for the packet.
+ manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
+ clock_.Now());
+ manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
+ EXPECT_EQ(PACKETS_NEWLY_ACKED,
+ manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
+ ENCRYPTION_FORWARD_SECURE));
+}
+
} // namespace
} // namespace test
} // namespace quic
diff --git a/quic/core/quic_types.h b/quic/core/quic_types.h
index c52293f..4b94152 100644
--- a/quic/core/quic_types.h
+++ b/quic/core/quic_types.h
@@ -533,6 +533,9 @@
PTO_RETRANSMITTED,
// This packet has been retransmitted for probing purpose.
PROBE_RETRANSMITTED,
+ // Do not collect RTT sample if this packet is the largest_acked of an
+ // incoming ACK.
+ NOT_CONTRIBUTING_RTT,
LAST_PACKET_STATE = PROBE_RETRANSMITTED,
};
diff --git a/quic/core/quic_unacked_packet_map.cc b/quic/core/quic_unacked_packet_map.cc
index dd70f82..1632fe3 100644
--- a/quic/core/quic_unacked_packet_map.cc
+++ b/quic/core/quic_unacked_packet_map.cc
@@ -131,7 +131,8 @@
void QuicUnackedPacketMap::AddSentPacket(SerializedPacket* packet,
TransmissionType transmission_type,
QuicTime sent_time,
- bool set_in_flight) {
+ bool set_in_flight,
+ bool measure_rtt) {
QuicPacketNumber packet_number = packet->packet_number;
QuicPacketLength bytes_sent = packet->encrypted_length;
QUIC_BUG_IF(largest_sent_packet_.IsInitialized() &&
@@ -151,6 +152,11 @@
info.largest_acked = packet->largest_acked;
largest_sent_largest_acked_.UpdateMax(packet->largest_acked);
+ if (!measure_rtt) {
+ QUIC_BUG_IF(set_in_flight);
+ info.state = NOT_CONTRIBUTING_RTT;
+ }
+
largest_sent_packet_ = packet_number;
if (set_in_flight) {
const PacketNumberSpace packet_number_space =
@@ -240,7 +246,8 @@
// Packet can be used for RTT measurement if it may yet be acked as the
// largest observed packet by the receiver.
return QuicUtils::IsAckable(info.state) &&
- (!largest_acked_.IsInitialized() || packet_number > largest_acked_);
+ (!largest_acked_.IsInitialized() || packet_number > largest_acked_) &&
+ info.state != NOT_CONTRIBUTING_RTT;
}
bool QuicUnackedPacketMap::IsPacketUsefulForCongestionControl(
diff --git a/quic/core/quic_unacked_packet_map.h b/quic/core/quic_unacked_packet_map.h
index 9f67e2b..8365009 100644
--- a/quic/core/quic_unacked_packet_map.h
+++ b/quic/core/quic_unacked_packet_map.h
@@ -39,7 +39,8 @@
void AddSentPacket(SerializedPacket* serialized_packet,
TransmissionType transmission_type,
QuicTime sent_time,
- bool set_in_flight);
+ bool set_in_flight,
+ bool measure_rtt);
// Returns true if the packet |packet_number| is unacked.
bool IsUnacked(QuicPacketNumber packet_number) const;
diff --git a/quic/core/quic_unacked_packet_map_test.cc b/quic/core/quic_unacked_packet_map_test.cc
index 330cc11..96ba08a 100644
--- a/quic/core/quic_unacked_packet_map_test.cc
+++ b/quic/core/quic_unacked_packet_map_test.cc
@@ -153,7 +153,8 @@
info->first_sent_after_loss = QuicPacketNumber(new_packet_number);
SerializedPacket packet(
CreateRetransmittablePacketForStream(new_packet_number, stream_id));
- unacked_packets_.AddSentPacket(&packet, transmission_type, now_, true);
+ unacked_packets_.AddSentPacket(&packet, transmission_type, now_, true,
+ true);
}
QuicUnackedPacketMap unacked_packets_;
QuicTime now_;
@@ -169,7 +170,8 @@
TEST_P(QuicUnackedPacketMapTest, RttOnly) {
// Acks are only tracked for RTT measurement purposes.
SerializedPacket packet(CreateNonRetransmittablePacket(1));
- unacked_packets_.AddSentPacket(&packet, NOT_RETRANSMISSION, now_, false);
+ unacked_packets_.AddSentPacket(&packet, NOT_RETRANSMISSION, now_, false,
+ true);
uint64_t unacked[] = {1};
VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
@@ -185,7 +187,7 @@
TEST_P(QuicUnackedPacketMapTest, RetransmittableInflightAndRtt) {
// Simulate a retransmittable packet being sent and acked.
SerializedPacket packet(CreateRetransmittablePacket(1));
- unacked_packets_.AddSentPacket(&packet, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet, NOT_RETRANSMISSION, now_, true, true);
uint64_t unacked[] = {1};
VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
@@ -211,7 +213,7 @@
TEST_P(QuicUnackedPacketMapTest, StopRetransmission) {
const QuicStreamId stream_id = 2;
SerializedPacket packet(CreateRetransmittablePacketForStream(1, stream_id));
- unacked_packets_.AddSentPacket(&packet, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet, NOT_RETRANSMISSION, now_, true, true);
uint64_t unacked[] = {1};
VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
@@ -229,7 +231,7 @@
TEST_P(QuicUnackedPacketMapTest, StopRetransmissionOnOtherStream) {
const QuicStreamId stream_id = 2;
SerializedPacket packet(CreateRetransmittablePacketForStream(1, stream_id));
- unacked_packets_.AddSentPacket(&packet, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet, NOT_RETRANSMISSION, now_, true, true);
uint64_t unacked[] = {1};
VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
@@ -247,7 +249,8 @@
TEST_P(QuicUnackedPacketMapTest, StopRetransmissionAfterRetransmission) {
const QuicStreamId stream_id = 2;
SerializedPacket packet1(CreateRetransmittablePacketForStream(1, stream_id));
- unacked_packets_.AddSentPacket(&packet1, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet1, NOT_RETRANSMISSION, now_, true,
+ true);
RetransmitAndSendPacket(1, 2, LOSS_RETRANSMISSION);
uint64_t unacked[] = {1, 2};
@@ -266,7 +269,8 @@
// Simulate a retransmittable packet being sent, retransmitted, and the first
// transmission being acked.
SerializedPacket packet1(CreateRetransmittablePacket(1));
- unacked_packets_.AddSentPacket(&packet1, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet1, NOT_RETRANSMISSION, now_, true,
+ true);
RetransmitAndSendPacket(1, 2, LOSS_RETRANSMISSION);
uint64_t unacked[] = {1, 2};
@@ -301,9 +305,11 @@
TEST_P(QuicUnackedPacketMapTest, RetransmitThreeTimes) {
// Simulate a retransmittable packet being sent and retransmitted twice.
SerializedPacket packet1(CreateRetransmittablePacket(1));
- unacked_packets_.AddSentPacket(&packet1, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet1, NOT_RETRANSMISSION, now_, true,
+ true);
SerializedPacket packet2(CreateRetransmittablePacket(2));
- unacked_packets_.AddSentPacket(&packet2, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet2, NOT_RETRANSMISSION, now_, true,
+ true);
uint64_t unacked[] = {1, 2};
VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
@@ -319,7 +325,8 @@
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(1));
RetransmitAndSendPacket(1, 3, LOSS_RETRANSMISSION);
SerializedPacket packet4(CreateRetransmittablePacket(4));
- unacked_packets_.AddSentPacket(&packet4, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet4, NOT_RETRANSMISSION, now_, true,
+ true);
uint64_t unacked2[] = {1, 3, 4};
VerifyUnackedPackets(unacked2, QUICHE_ARRAYSIZE(unacked2));
@@ -334,7 +341,8 @@
unacked_packets_.RemoveRetransmittability(QuicPacketNumber(4));
RetransmitAndSendPacket(3, 5, LOSS_RETRANSMISSION);
SerializedPacket packet6(CreateRetransmittablePacket(6));
- unacked_packets_.AddSentPacket(&packet6, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet6, NOT_RETRANSMISSION, now_, true,
+ true);
std::vector<uint64_t> unacked3 = {3, 5, 6};
std::vector<uint64_t> retransmittable3 = {3, 5, 6};
@@ -366,9 +374,11 @@
TEST_P(QuicUnackedPacketMapTest, RetransmitFourTimes) {
// Simulate a retransmittable packet being sent and retransmitted twice.
SerializedPacket packet1(CreateRetransmittablePacket(1));
- unacked_packets_.AddSentPacket(&packet1, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet1, NOT_RETRANSMISSION, now_, true,
+ true);
SerializedPacket packet2(CreateRetransmittablePacket(2));
- unacked_packets_.AddSentPacket(&packet2, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet2, NOT_RETRANSMISSION, now_, true,
+ true);
uint64_t unacked[] = {1, 2};
VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
@@ -394,7 +404,8 @@
// TLP 3 (formerly 1) as 4, and don't remove 1 from unacked.
RetransmitAndSendPacket(3, 4, TLP_RETRANSMISSION);
SerializedPacket packet5(CreateRetransmittablePacket(5));
- unacked_packets_.AddSentPacket(&packet5, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet5, NOT_RETRANSMISSION, now_, true,
+ true);
uint64_t unacked3[] = {1, 3, 4, 5};
VerifyUnackedPackets(unacked3, QUICHE_ARRAYSIZE(unacked3));
@@ -423,9 +434,11 @@
// Simulate a retransmittable packet being sent, retransmitted, and the first
// transmission being acked.
SerializedPacket packet1(CreateRetransmittablePacket(1));
- unacked_packets_.AddSentPacket(&packet1, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet1, NOT_RETRANSMISSION, now_, true,
+ true);
SerializedPacket packet3(CreateRetransmittablePacket(3));
- unacked_packets_.AddSentPacket(&packet3, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet3, NOT_RETRANSMISSION, now_, true,
+ true);
RetransmitAndSendPacket(3, 5, LOSS_RETRANSMISSION);
EXPECT_EQ(QuicPacketNumber(1u), unacked_packets_.GetLeastUnacked());
@@ -571,7 +584,8 @@
// Send packet 1.
SerializedPacket packet1(CreateRetransmittablePacket(1));
packet1.encryption_level = ENCRYPTION_INITIAL;
- unacked_packets_.AddSentPacket(&packet1, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet1, NOT_RETRANSMISSION, now_, true,
+ true);
EXPECT_EQ(QuicPacketNumber(1u), unacked_packets_.largest_sent_packet());
EXPECT_EQ(QuicPacketNumber(1),
unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
@@ -583,7 +597,8 @@
// Send packet 2.
SerializedPacket packet2(CreateRetransmittablePacket(2));
packet2.encryption_level = ENCRYPTION_HANDSHAKE;
- unacked_packets_.AddSentPacket(&packet2, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet2, NOT_RETRANSMISSION, now_, true,
+ true);
EXPECT_EQ(QuicPacketNumber(2u), unacked_packets_.largest_sent_packet());
EXPECT_EQ(QuicPacketNumber(1),
unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
@@ -598,7 +613,8 @@
// Send packet 3.
SerializedPacket packet3(CreateRetransmittablePacket(3));
packet3.encryption_level = ENCRYPTION_ZERO_RTT;
- unacked_packets_.AddSentPacket(&packet3, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet3, NOT_RETRANSMISSION, now_, true,
+ true);
EXPECT_EQ(QuicPacketNumber(3u), unacked_packets_.largest_sent_packet());
EXPECT_EQ(QuicPacketNumber(1),
unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
@@ -618,7 +634,8 @@
// Send packet 4.
SerializedPacket packet4(CreateRetransmittablePacket(4));
packet4.encryption_level = ENCRYPTION_FORWARD_SECURE;
- unacked_packets_.AddSentPacket(&packet4, NOT_RETRANSMISSION, now_, true);
+ unacked_packets_.AddSentPacket(&packet4, NOT_RETRANSMISSION, now_, true,
+ true);
EXPECT_EQ(QuicPacketNumber(4u), unacked_packets_.largest_sent_packet());
EXPECT_EQ(QuicPacketNumber(1),
unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index aaadac1..367db32 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -173,6 +173,7 @@
RETURN_STRING_LITERAL(RTO_RETRANSMITTED);
RETURN_STRING_LITERAL(PTO_RETRANSMITTED);
RETURN_STRING_LITERAL(PROBE_RETRANSMITTED);
+ RETURN_STRING_LITERAL(NOT_CONTRIBUTING_RTT)
}
return "INVALID_SENT_PACKET_STATE";
}
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index 7ee037a..e6bd7e4 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -583,7 +583,7 @@
OnPacketSent(packet.encryption_level, packet.transmission_type);
QuicConnectionPeer::GetSentPacketManager(this)->OnPacketSent(
&packet, clock_.ApproximateNow(), NOT_RETRANSMISSION,
- HAS_RETRANSMITTABLE_DATA);
+ HAS_RETRANSMITTABLE_DATA, true);
}
MockQuicSession::MockQuicSession(QuicConnection* connection)
