using std::vector;
using testing::AnyNumber;
using testing::ElementsAre;
+using testing::IsEmpty;
using testing::Pair;
using testing::Pointwise;
using testing::Return;
EXPECT_CALL(*send_algorithm_, InRecovery()).Times(AnyNumber());
}
- virtual ~QuicSentPacketManagerTest() OVERRIDE {
+ virtual ~QuicSentPacketManagerTest() override {
STLDeleteElements(&packets_);
}
void ExpectAck(QuicPacketSequenceNumber largest_observed) {
EXPECT_CALL(*send_algorithm_, OnCongestionEvent(
- true, _, ElementsAre(Pair(largest_observed, _)), _));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillOnce(Return(100 * kDefaultTCPMSS));
- EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
+ true, _, ElementsAre(Pair(largest_observed, _)), IsEmpty()));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
}
void ExpectUpdatedRtt(QuicPacketSequenceNumber largest_observed) {
EXPECT_CALL(*send_algorithm_,
- OnCongestionEvent(true, _, _, _));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillOnce(Return(100 * kDefaultTCPMSS));
- EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
+ OnCongestionEvent(true, _, IsEmpty(), IsEmpty()));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
}
void ExpectAckAndLoss(bool rtt_updated,
EXPECT_CALL(*send_algorithm_, OnCongestionEvent(
rtt_updated, _, ElementsAre(Pair(largest_observed, _)),
ElementsAre(Pair(lost_packet, _))));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillOnce(Return(100 * kDefaultTCPMSS));
- EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
}
// |packets_acked| and |packets_lost| should be in sequence number order.
OnCongestionEvent(rtt_updated, _,
Pointwise(KeyEq(), ack_vector),
Pointwise(KeyEq(), lost_vector)));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillRepeatedly(Return(100 * kDefaultTCPMSS));
- EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_)).
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange()).
Times(AnyNumber());
}
- // Retransmits a packet as though it was a TLP retransmission, because TLP
- // leaves the |old_sequence_number| pending.
- // TODO(ianswett): Test with transmission types besides TLP.
- void RetransmitPacket(QuicPacketSequenceNumber old_sequence_number,
- QuicPacketSequenceNumber new_sequence_number) {
+ void RetransmitAndSendPacket(QuicPacketSequenceNumber old_sequence_number,
+ QuicPacketSequenceNumber new_sequence_number) {
QuicSentPacketManagerPeer::MarkForRetransmission(
&manager_, old_sequence_number, TLP_RETRANSMISSION);
EXPECT_TRUE(manager_.HasPendingRetransmissions());
EXPECT_EQ(old_sequence_number, next_retransmission.sequence_number);
EXPECT_EQ(TLP_RETRANSMISSION,
next_retransmission.transmission_type);
- manager_.OnRetransmittedPacket(old_sequence_number,
- new_sequence_number);
- EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(
- &manager_, new_sequence_number));
- }
-
- void RetransmitAndSendPacket(QuicPacketSequenceNumber old_sequence_number,
- QuicPacketSequenceNumber new_sequence_number) {
- RetransmitPacket(old_sequence_number, new_sequence_number);
EXPECT_CALL(*send_algorithm_,
OnPacketSent(_, BytesInFlight(), new_sequence_number,
kDefaultLength, HAS_RETRANSMITTABLE_DATA))
.WillOnce(Return(true));
- manager_.OnPacketSent(new_sequence_number,
+ SerializedPacket packet(CreatePacket(new_sequence_number, false));
+ manager_.OnPacketSent(&packet,
+ old_sequence_number,
clock_.Now(),
kDefaultLength,
- LOSS_RETRANSMISSION,
+ TLP_RETRANSMISSION,
HAS_RETRANSMITTABLE_DATA);
+ EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(
+ &manager_, new_sequence_number));
}
SerializedPacket CreateDataPacket(QuicPacketSequenceNumber sequence_number) {
SerializedPacket CreatePacket(QuicPacketSequenceNumber sequence_number,
bool retransmittable) {
packets_.push_back(QuicPacket::NewDataPacket(
- NULL, kDefaultLength, false, PACKET_8BYTE_CONNECTION_ID, false,
+ nullptr, kDefaultLength, false, PACKET_8BYTE_CONNECTION_ID, false,
PACKET_6BYTE_SEQUENCE_NUMBER));
return SerializedPacket(
- sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER,
- packets_.back(), 0u,
- retransmittable ? new RetransmittableFrames() : NULL);
+ sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER, packets_.back(), 0u,
+ retransmittable ? new RetransmittableFrames() : nullptr);
}
SerializedPacket CreateFecPacket(QuicPacketSequenceNumber sequence_number) {
packets_.push_back(QuicPacket::NewFecPacket(
- NULL, kDefaultLength, false, PACKET_8BYTE_CONNECTION_ID, false,
+ nullptr, kDefaultLength, false, PACKET_8BYTE_CONNECTION_ID, false,
PACKET_6BYTE_SEQUENCE_NUMBER));
return SerializedPacket(sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER,
- packets_.back(), 0u, NULL);
+ packets_.back(), 0u, nullptr);
}
void SendDataPacket(QuicPacketSequenceNumber sequence_number) {
OnPacketSent(_, BytesInFlight(), sequence_number, _, _))
.Times(1).WillOnce(Return(true));
SerializedPacket packet(CreateDataPacket(sequence_number));
- manager_.OnSerializedPacket(packet);
- manager_.OnPacketSent(sequence_number, clock_.Now(),
+ manager_.OnPacketSent(&packet, 0, clock_.Now(),
packet.packet->length(), NOT_RETRANSMISSION,
HAS_RETRANSMITTABLE_DATA);
}
packet.retransmittable_frames->AddStreamFrame(
new QuicStreamFrame(1, false, 0, IOVector()));
packet.retransmittable_frames->set_encryption_level(ENCRYPTION_NONE);
- manager_.OnSerializedPacket(packet);
- manager_.OnPacketSent(sequence_number, clock_.ApproximateNow(),
+ manager_.OnPacketSent(&packet, 0, clock_.Now(),
packet.packet->length(), NOT_RETRANSMISSION,
HAS_RETRANSMITTABLE_DATA);
}
kDefaultLength, NO_RETRANSMITTABLE_DATA))
.Times(1).WillOnce(Return(true));
SerializedPacket packet(CreateFecPacket(sequence_number));
- manager_.OnSerializedPacket(packet);
- manager_.OnPacketSent(sequence_number, clock_.ApproximateNow(),
+ manager_.OnPacketSent(&packet, 0, clock_.Now(),
packet.packet->length(), NOT_RETRANSMISSION,
NO_RETRANSMITTABLE_DATA);
}
kDefaultLength, NO_RETRANSMITTABLE_DATA))
.Times(1).WillOnce(Return(false));
SerializedPacket packet(CreatePacket(sequence_number, false));
- manager_.OnSerializedPacket(packet);
- manager_.OnPacketSent(sequence_number, clock_.Now(),
+ manager_.OnPacketSent(&packet, 0, clock_.Now(),
packet.packet->length(), NOT_RETRANSMISSION,
NO_RETRANSMITTABLE_DATA);
}
.Times(1).WillOnce(Return(true));
const QuicSentPacketManager::PendingRetransmission pending =
manager_.NextPendingRetransmission();
- manager_.OnRetransmittedPacket(pending.sequence_number,
- retransmission_sequence_number);
- manager_.OnPacketSent(retransmission_sequence_number, clock_.Now(),
+ SerializedPacket packet(
+ CreatePacket(retransmission_sequence_number, false));
+ manager_.OnPacketSent(&packet, pending.sequence_number, clock_.Now(),
kDefaultLength, pending.transmission_type,
HAS_RETRANSMITTABLE_DATA);
}
};
TEST_F(QuicSentPacketManagerTest, IsUnacked) {
- VerifyUnackedPackets(NULL, 0);
-
- SerializedPacket serialized_packet(CreateDataPacket(1));
-
- manager_.OnSerializedPacket(serialized_packet);
+ VerifyUnackedPackets(nullptr, 0);
+ SendDataPacket(1);
QuicPacketSequenceNumber unacked[] = { 1 };
VerifyUnackedPackets(unacked, arraysize(unacked));
TEST_F(QuicSentPacketManagerTest, IsUnAckedRetransmit) {
SendDataPacket(1);
- RetransmitPacket(1, 2);
+ RetransmitAndSendPacket(1, 2);
EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(&manager_, 2));
QuicPacketSequenceNumber unacked[] = { 1, 2 };
QuicPacketSequenceNumber unacked[] = { 1 };
VerifyUnackedPackets(unacked, arraysize(unacked));
EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
- VerifyRetransmittablePackets(NULL, 0);
+ VerifyRetransmittablePackets(nullptr, 0);
}
TEST_F(QuicSentPacketManagerTest, RetransmitThenAckBeforeSend) {
EXPECT_FALSE(manager_.HasPendingRetransmissions());
// No unacked packets remain.
- VerifyUnackedPackets(NULL, 0);
- VerifyRetransmittablePackets(NULL, 0);
+ VerifyUnackedPackets(nullptr, 0);
+ VerifyRetransmittablePackets(nullptr, 0);
EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted);
}
TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPrevious) {
SendDataPacket(1);
- RetransmitPacket(1, 2);
- QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
- clock_.AdvanceTime(rtt);
-
- // Ack 1 but not 2.
- ExpectAck(1);
- QuicAckFrame ack_frame;
- ack_frame.largest_observed = 1;
- manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
-
- // 2 should be unacked, since it may provide an RTT measurement.
- QuicPacketSequenceNumber unacked[] = { 2 };
- VerifyUnackedPackets(unacked, arraysize(unacked));
- EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
- VerifyRetransmittablePackets(NULL, 0);
-
- // Verify that the retransmission alarm would not fire,
- // since there is no retransmittable data outstanding.
- EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
- EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted);
-}
-
-TEST_F(QuicSentPacketManagerTest, RetransmitAndSendThenAckPrevious) {
- SendDataPacket(1);
RetransmitAndSendPacket(1, 2);
QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
clock_.AdvanceTime(rtt);
QuicPacketSequenceNumber unacked[] = { 2 };
VerifyUnackedPackets(unacked, arraysize(unacked));
EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
- VerifyRetransmittablePackets(NULL, 0);
+ VerifyRetransmittablePackets(nullptr, 0);
EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted);
}
TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPreviousThenNackRetransmit) {
SendDataPacket(1);
- RetransmitPacket(1, 2);
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 2, _, _))
- .WillOnce(Return(true));
- manager_.OnPacketSent(2, clock_.ApproximateNow(), kDefaultLength,
- LOSS_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+ RetransmitAndSendPacket(1, 2);
QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
clock_.AdvanceTime(rtt);
manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
// No packets remain unacked.
- VerifyUnackedPackets(NULL, 0);
+ VerifyUnackedPackets(nullptr, 0);
EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
- VerifyRetransmittablePackets(NULL, 0);
+ VerifyRetransmittablePackets(nullptr, 0);
// Verify that the retransmission alarm would not fire,
// since there is no retransmittable data outstanding.
// Fire the RTO, which will mark 2 for retransmission (but will not send it).
EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
- EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillOnce(Return(2 * kDefaultTCPMSS));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
manager_.OnRetransmissionTimeout();
EXPECT_TRUE(manager_.HasPendingRetransmissions());
QuicPacketSequenceNumber unacked[] = { 2 };
VerifyUnackedPackets(unacked, arraysize(unacked));
EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
- VerifyRetransmittablePackets(NULL, 0);
+ VerifyRetransmittablePackets(nullptr, 0);
// Verify that the retransmission alarm would not fire,
// since there is no retransmittable data outstanding.
QuicPacketSequenceNumber unacked[] = { 2, 3 };
VerifyUnackedPackets(unacked, arraysize(unacked));
EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
- VerifyRetransmittablePackets(NULL, 0);
+ VerifyRetransmittablePackets(nullptr, 0);
// Ensure packet 2 is lost when 4 is sent and 3 and 4 are acked.
SendDataPacket(4);
ack_frame.largest_observed = 4;
ack_frame.missing_packets.insert(2);
QuicPacketSequenceNumber acked[] = { 3, 4 };
- ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0);
+ ExpectAcksAndLosses(true, acked, arraysize(acked), nullptr, 0);
manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
QuicPacketSequenceNumber unacked2[] = { 2 };
ExpectAckAndLoss(true, 5, 2);
manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
- VerifyUnackedPackets(NULL, 0);
+ VerifyUnackedPackets(nullptr, 0);
EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
EXPECT_EQ(2u, stats_.packets_spuriously_retransmitted);
}
ack_frame.missing_packets.insert(1);
ack_frame.revived_packets.insert(1);
QuicPacketSequenceNumber acked[] = { 2, 3 };
- ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0);
+ ExpectAcksAndLosses(true, acked, arraysize(acked), nullptr, 0);
manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
EXPECT_FALSE(manager_.HasPendingRetransmissions());
manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
EXPECT_FALSE(manager_.HasPendingRetransmissions());
- VerifyRetransmittablePackets(NULL, 0);
+ VerifyRetransmittablePackets(nullptr, 0);
}
TEST_F(QuicSentPacketManagerTest, MarkLostThenReviveAndDontRetransmitPacket) {
manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
EXPECT_FALSE(manager_.HasPendingRetransmissions());
- VerifyRetransmittablePackets(NULL, 0);
+ VerifyRetransmittablePackets(nullptr, 0);
}
TEST_F(QuicSentPacketManagerTest, TruncatedAck) {
ack_frame.is_truncated = true;
QuicPacketSequenceNumber lost[] = { 1 };
- ExpectAcksAndLosses(true, NULL, 0, lost, arraysize(lost));
+ ExpectAcksAndLosses(true, nullptr, 0, lost, arraysize(lost));
manager_.OnIncomingAck(ack_frame, clock_.Now());
// High water mark will be raised.
}
TEST_F(QuicSentPacketManagerTest, GetLeastUnackedUnacked) {
- SerializedPacket serialized_packet(CreateDataPacket(1));
-
- manager_.OnSerializedPacket(serialized_packet);
+ SendDataPacket(1);
EXPECT_EQ(1u, manager_.GetLeastUnacked());
}
TEST_F(QuicSentPacketManagerTest, GetLeastUnackedUnackedFec) {
- SerializedPacket serialized_packet(CreateFecPacket(1));
-
- manager_.OnSerializedPacket(serialized_packet);
+ SendFecPacket(1);
EXPECT_EQ(1u, manager_.GetLeastUnacked());
}
TEST_F(QuicSentPacketManagerTest, GetLeastUnackedAndDiscard) {
- VerifyUnackedPackets(NULL, 0);
+ VerifyUnackedPackets(nullptr, 0);
SendFecPacket(1);
EXPECT_EQ(1u, manager_.GetLeastUnacked());
QuicPacketSequenceNumber unacked[] = { 1, 2, 3 };
VerifyUnackedPackets(unacked, arraysize(unacked));
- VerifyRetransmittablePackets(NULL, 0);
+ VerifyRetransmittablePackets(nullptr, 0);
// Ack 2, so there's an rtt update.
ExpectAck(2);
}
TEST_F(QuicSentPacketManagerTest, GetSentTime) {
- VerifyUnackedPackets(NULL, 0);
-
- SerializedPacket serialized_packet(CreateFecPacket(1));
- manager_.OnSerializedPacket(serialized_packet);
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 1, _, _))
- .Times(1).WillOnce(Return(true));
- manager_.OnPacketSent(1, QuicTime::Zero(), kDefaultLength, NOT_RETRANSMISSION,
- NO_RETRANSMITTABLE_DATA);
-
- SerializedPacket serialized_packet2(CreateFecPacket(2));
- QuicTime sent_time = QuicTime::Zero().Add(QuicTime::Delta::FromSeconds(1));
- manager_.OnSerializedPacket(serialized_packet2);
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 2, _, _))
- .Times(1).WillOnce(Return(true));
- manager_.OnPacketSent(2, sent_time, kDefaultLength, NOT_RETRANSMISSION,
- NO_RETRANSMITTABLE_DATA);
+ VerifyUnackedPackets(nullptr, 0);
+ QuicTime sent_time = clock_.Now();
+ SendFecPacket(1);
+ QuicTime sent_time2 = clock_.Now();
+ SendFecPacket(2);
QuicPacketSequenceNumber unacked[] = { 1, 2 };
VerifyUnackedPackets(unacked, arraysize(unacked));
- VerifyRetransmittablePackets(NULL, 0);
+ VerifyRetransmittablePackets(nullptr, 0);
EXPECT_TRUE(manager_.HasUnackedPackets());
- EXPECT_EQ(QuicTime::Zero(),
- QuicSentPacketManagerPeer::GetSentTime(&manager_, 1));
- EXPECT_EQ(sent_time, QuicSentPacketManagerPeer::GetSentTime(&manager_, 2));
+ EXPECT_EQ(sent_time, QuicSentPacketManagerPeer::GetSentTime(&manager_, 1));
+ EXPECT_EQ(sent_time2, QuicSentPacketManagerPeer::GetSentTime(&manager_, 2));
}
TEST_F(QuicSentPacketManagerTest, AckAckAndUpdateRtt) {
// Acking two more packets will lose both of them due to nacks.
ack_frame.largest_observed = 5;
QuicPacketSequenceNumber lost[] = { 1, 2 };
- ExpectAcksAndLosses(false, NULL, 0, lost, arraysize(lost));
+ ExpectAcksAndLosses(false, nullptr, 0, lost, arraysize(lost));
manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
EXPECT_FALSE(manager_.HasPendingRetransmissions());
// The final RTO abandons all of them.
EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
- EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillOnce(Return(2 * kDefaultTCPMSS));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
manager_.OnRetransmissionTimeout();
EXPECT_TRUE(manager_.HasPendingRetransmissions());
EXPECT_EQ(2u, stats_.tlp_count);
// Now ack the two crypto packets and the speculatively encrypted request,
// and ensure the first four crypto packets get abandoned, but not lost.
QuicPacketSequenceNumber acked[] = { 3, 4, 5, 8, 9 };
- ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0);
+ ExpectAcksAndLosses(true, acked, arraysize(acked), nullptr, 0);
QuicAckFrame ack_frame;
ack_frame.largest_observed = 9;
ack_frame.missing_packets.insert(1);
}
TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeoutUnsentDataPacket) {
- // Send 2 crypto packets and serialize 1 data packet.
+ // Send 2 crypto packets and 1 data packet.
const size_t kNumSentCryptoPackets = 2;
for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) {
SendCryptoPacket(i);
}
- SerializedPacket packet(CreateDataPacket(3));
- manager_.OnSerializedPacket(packet);
+ SendDataPacket(3);
EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
// Retransmit 2 crypto packets, but not the serialized packet.
manager_.NeuterUnencryptedPackets();
QuicPacketSequenceNumber unacked[] = { 1, 2, 3};
VerifyUnackedPackets(unacked, arraysize(unacked));
- VerifyRetransmittablePackets(NULL, 0);
+ VerifyRetransmittablePackets(nullptr, 0);
EXPECT_FALSE(manager_.HasPendingRetransmissions());
EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
ack_frame.missing_packets.insert(2);
ExpectUpdatedRtt(3);
manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
- VerifyUnackedPackets(NULL, 0);
- VerifyRetransmittablePackets(NULL, 0);
-}
-
-TEST_F(QuicSentPacketManagerTest, TailLossProbeTimeoutUnsentDataPacket) {
- QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
- // Serialize two data packets and send the latter.
- SerializedPacket packet(CreateDataPacket(1));
- manager_.OnSerializedPacket(packet);
- SendDataPacket(2);
- EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
- EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
-
- // Retransmit 1 unacked packets, but not the first serialized packet.
- manager_.OnRetransmissionTimeout();
- EXPECT_EQ(QuicTime::Delta::Zero(),
- manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
- EXPECT_FALSE(manager_.HasPendingRetransmissions());
- manager_.MaybeRetransmitTailLossProbe();
- EXPECT_TRUE(manager_.HasPendingRetransmissions());
- RetransmitNextPacket(3);
- EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).WillOnce(Return(
- QuicTime::Delta::Infinite()));
- EXPECT_EQ(QuicTime::Delta::Infinite(),
- manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
- EXPECT_FALSE(manager_.HasPendingRetransmissions());
- EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
- EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
+ VerifyUnackedPackets(nullptr, 0);
+ VerifyRetransmittablePackets(nullptr, 0);
}
TEST_F(QuicSentPacketManagerTest, ResetRecentMinRTTWithEmptyWindow) {
}
EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
- EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillOnce(Return(2 * kDefaultTCPMSS));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
EXPECT_FALSE(manager_.MaybeRetransmitTailLossProbe());
manager_.OnRetransmissionTimeout();
}
SendCryptoPacket(1);
// Check the min.
- QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt_us(
- 1 * base::Time::kMicrosecondsPerMillisecond);
+ RttStats* rtt_stats = QuicSentPacketManagerPeer::GetRttStats(&manager_);
+ rtt_stats->set_initial_rtt_us(1 * base::Time::kMicrosecondsPerMillisecond);
EXPECT_EQ(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(10)),
manager_.GetRetransmissionTime());
// Test with a standard smoothed RTT.
- QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt_us(
- 100 * base::Time::kMicrosecondsPerMillisecond);
+ rtt_stats->set_initial_rtt_us(100 * base::Time::kMicrosecondsPerMillisecond);
- QuicTime::Delta srtt = manager_.GetRttStats()->SmoothedRtt();
+ QuicTime::Delta srtt =
+ QuicTime::Delta::FromMicroseconds(rtt_stats->initial_rtt_us());
QuicTime expected_time = clock_.Now().Add(srtt.Multiply(1.5));
EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
SendDataPacket(2);
// Check the min.
- QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt_us(
- 1 * base::Time::kMicrosecondsPerMillisecond);
+ RttStats* rtt_stats = QuicSentPacketManagerPeer::GetRttStats(&manager_);
+ rtt_stats->set_initial_rtt_us(1 * base::Time::kMicrosecondsPerMillisecond);
EXPECT_EQ(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(10)),
manager_.GetRetransmissionTime());
// Test with a standard smoothed RTT.
- QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt_us(
- 100 * base::Time::kMicrosecondsPerMillisecond);
- QuicTime::Delta srtt = manager_.GetRttStats()->SmoothedRtt();
+ rtt_stats->set_initial_rtt_us(100 * base::Time::kMicrosecondsPerMillisecond);
+ QuicTime::Delta srtt =
+ QuicTime::Delta::FromMicroseconds(rtt_stats->initial_rtt_us());
QuicTime::Delta expected_tlp_delay = srtt.Multiply(2);
QuicTime expected_time = clock_.Now().Add(expected_tlp_delay);
EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
// Retransmit the packet by invoking the retransmission timeout.
- EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillOnce(Return(2 * kDefaultTCPMSS));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
clock_.AdvanceTime(expected_rto_delay);
manager_.OnRetransmissionTimeout();
// Wait 2RTTs from now for the RTO, since it's the max of the RTO time
// and the TLP time. In production, there would always be two TLP's first.
- expected_time = clock_.Now().Add(QuicTime::Delta::FromMilliseconds(200));
+ // Since retransmission was spurious, smoothed_rtt_ is expired, and replaced
+ // by the latest RTT sample of 500ms.
+ expected_time = clock_.Now().Add(QuicTime::Delta::FromMilliseconds(1000));
EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
}
EXPECT_EQ(delay,
QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
delay = delay.Add(delay);
- EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillOnce(Return(2 * kDefaultTCPMSS));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
manager_.OnRetransmissionTimeout();
RetransmitNextPacket(i + 2);
EXPECT_EQ(delay,
QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
delay = delay.Add(delay);
- EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillOnce(Return(2 * kDefaultTCPMSS));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
manager_.OnRetransmissionTimeout();
RetransmitNextPacket(i + 2);
manager_.OnRetransmissionTimeout();
}
-TEST_F(QuicSentPacketManagerTest, NegotiateTimeLossDetection) {
- EXPECT_EQ(kNack,
- QuicSentPacketManagerPeer::GetLossAlgorithm(
- &manager_)->GetLossDetectionType());
-
- QuicConfig config;
- QuicConfigPeer::SetReceivedLossDetection(&config, kTIME);
- EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
- EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillOnce(Return(100 * kDefaultTCPMSS));
- manager_.SetFromConfig(config);
-
- EXPECT_EQ(kTime,
- QuicSentPacketManagerPeer::GetLossAlgorithm(
- &manager_)->GetLossDetectionType());
-}
-
TEST_F(QuicSentPacketManagerTest, NegotiateTimeLossDetectionFromOptions) {
EXPECT_EQ(kNack,
QuicSentPacketManagerPeer::GetLossAlgorithm(
options.push_back(kTIME);
QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
- EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillOnce(Return(100 * kDefaultTCPMSS));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
manager_.SetFromConfig(config);
EXPECT_EQ(kTime,
}
TEST_F(QuicSentPacketManagerTest, NegotiateCongestionControlFromOptions) {
+ ValueRestore<bool> old_flag(&FLAGS_quic_allow_bbr, true);
QuicConfig config;
QuicTagVector options;
options.push_back(kRENO);
QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
- EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
manager_.SetFromConfig(config);
- EXPECT_EQ(kReno, QuicSentPacketManagerPeer::GetCongestionControlAlgorithm(
+ EXPECT_EQ(kReno, QuicSentPacketManagerPeer::GetSendAlgorithm(
manager_)->GetCongestionControlType());
// TODO(rtenneti): Enable the following code after BBR code is checked in.
options.clear();
options.push_back(kTBBR);
QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
- EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
manager_.SetFromConfig(config);
- EXPECT_EQ(kBBR, QuicSentPacketManagerPeer::GetCongestionControlAlgorithm(
+ EXPECT_EQ(kBBR, QuicSentPacketManagerPeer::GetSendAlgorithm(
manager_)->GetCongestionControlType());
#endif
}
+TEST_F(QuicSentPacketManagerTest, NegotiateNumConnectionsFromOptions) {
+ QuicConfig config;
+ QuicTagVector options;
+
+ options.push_back(k1CON);
+ QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
+ EXPECT_CALL(*send_algorithm_, SetNumEmulatedConnections(1));
+ EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
+ manager_.SetFromConfig(config);
+
+ QuicSentPacketManagerPeer::SetIsServer(&manager_, false);
+ QuicConfig client_config;
+ client_config.SetConnectionOptionsToSend(options);
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
+ EXPECT_CALL(*send_algorithm_, SetNumEmulatedConnections(1));
+ EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
+ manager_.SetFromConfig(client_config);
+}
+
+TEST_F(QuicSentPacketManagerTest, NegotiateNConnectionFromOptions) {
+ // By default, changing the number of open streams does nothing.
+ manager_.SetNumOpenStreams(5);
+
+ QuicConfig config;
+ QuicTagVector options;
+
+ options.push_back(kNCON);
+ QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
+ EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
+ manager_.SetFromConfig(config);
+
+ EXPECT_CALL(*send_algorithm_, SetNumEmulatedConnections(5));
+ manager_.SetNumOpenStreams(5);
+}
+
+TEST_F(QuicSentPacketManagerTest, NegotiateNoTLPFromOptionsAtServer) {
+ QuicConfig config;
+ QuicTagVector options;
+
+ options.push_back(kNTLP);
+ QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
+ EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
+ manager_.SetFromConfig(config);
+ EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetMaxTailLossProbes(&manager_));
+}
+
+TEST_F(QuicSentPacketManagerTest, NegotiateNoTLPFromOptionsAtClient) {
+ QuicConfig client_config;
+ QuicTagVector options;
+
+ options.push_back(kNTLP);
+ QuicSentPacketManagerPeer::SetIsServer(&manager_, false);
+ client_config.SetConnectionOptionsToSend(options);
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
+ EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
+ manager_.SetFromConfig(client_config);
+ EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetMaxTailLossProbes(&manager_));
+}
+
TEST_F(QuicSentPacketManagerTest, NegotiatePacingFromOptions) {
EXPECT_FALSE(manager_.using_pacing());
QuicTagVector options;
options.push_back(kPACE);
QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
- EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillOnce(Return(100 * kDefaultTCPMSS));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
manager_.SetFromConfig(config);
EXPECT_TRUE(manager_.using_pacing());
}
+TEST_F(QuicSentPacketManagerTest, NegotiateReceiveWindowFromOptions) {
+ EXPECT_EQ(kDefaultSocketReceiveBuffer,
+ QuicSentPacketManagerPeer::GetReceiveWindow(&manager_));
+
+ // Try to set a size below the minimum and ensure it gets set to the min.
+ QuicConfig client_config;
+ QuicConfigPeer::SetReceivedSocketReceiveBuffer(&client_config, 1024);
+ EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
+ manager_.SetFromConfig(client_config);
+
+ EXPECT_EQ(kMinSocketReceiveBuffer,
+ QuicSentPacketManagerPeer::GetReceiveWindow(&manager_));
+
+ // Ensure the smaller send window only allows 16 packets to be sent.
+ for (QuicPacketSequenceNumber i = 1; i <= 16; ++i) {
+ EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).WillOnce(Return(
+ QuicTime::Delta::Zero()));
+ EXPECT_EQ(QuicTime::Delta::Zero(),
+ manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
+ EXPECT_CALL(*send_algorithm_, OnPacketSent(_, BytesInFlight(), i,
+ 1024, HAS_RETRANSMITTABLE_DATA))
+ .WillOnce(Return(true));
+ SerializedPacket packet(CreatePacket(i, true));
+ manager_.OnPacketSent(&packet, 0, clock_.Now(), 1024,
+ NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+ }
+ EXPECT_EQ(QuicTime::Delta::Infinite(),
+ manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
+}
+
TEST_F(QuicSentPacketManagerTest, UseInitialRoundTripTimeToSend) {
uint32 initial_rtt_us = 325000;
EXPECT_NE(initial_rtt_us,
- manager_.GetRttStats()->SmoothedRtt().ToMicroseconds());
+ manager_.GetRttStats()->smoothed_rtt().ToMicroseconds());
QuicConfig config;
config.SetInitialRoundTripTimeUsToSend(initial_rtt_us);
EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
- EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillOnce(Return(100 * kDefaultTCPMSS));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
manager_.SetFromConfig(config);
- EXPECT_EQ(initial_rtt_us,
- manager_.GetRttStats()->SmoothedRtt().ToMicroseconds());
+ EXPECT_EQ(0, manager_.GetRttStats()->smoothed_rtt().ToMicroseconds());
+ EXPECT_EQ(initial_rtt_us, manager_.GetRttStats()->initial_rtt_us());
}
} // namespace
projects / platform / framework / web / crosswalk.git / blobdiff