#include "net/quic/quic_sent_packet_manager.h"
#include "base/stl_util.h"
+#include "net/quic/quic_flags.h"
+#include "net/quic/test_tools/quic_config_peer.h"
#include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
#include "net/quic/test_tools/quic_test_utils.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using std::vector;
-using testing::_;
+using testing::AnyNumber;
+using testing::ElementsAre;
+using testing::IsEmpty;
+using testing::Pair;
+using testing::Pointwise;
using testing::Return;
using testing::StrictMock;
+using testing::_;
namespace net {
namespace test {
namespace {
+// Default packet length.
+const uint32 kDefaultLength = 1000;
+
+// Matcher to check the key of the key-value pair it receives as first argument
+// equals its second argument.
+MATCHER(KeyEq, "") {
+ return std::tr1::get<0>(arg).first == std::tr1::get<1>(arg);
+}
+
+class MockDebugDelegate : public QuicSentPacketManager::DebugDelegate {
+ public:
+ MOCK_METHOD2(OnSpuriousPacketRetransmition,
+ void(TransmissionType transmission_type,
+ QuicByteCount byte_size));
+};
+
class QuicSentPacketManagerTest : public ::testing::TestWithParam<bool> {
protected:
QuicSentPacketManagerTest()
- : manager_(true, &clock_, &stats_, kFixRate),
- send_algorithm_(new StrictMock<MockSendAlgorithm>) {
+ : manager_(true, &clock_, &stats_, kCubic, kNack),
+ send_algorithm_(new StrictMock<MockSendAlgorithm>),
+ network_change_visitor_(new StrictMock<MockNetworkChangeVisitor>) {
QuicSentPacketManagerPeer::SetSendAlgorithm(&manager_, send_algorithm_);
// Disable tail loss probes for most tests.
QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 0);
// Advance the time 1s so the send times are never QuicTime::Zero.
clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000));
+ manager_.set_network_change_visitor(network_change_visitor_.get());
+
+ EXPECT_CALL(*send_algorithm_, HasReliableBandwidthEstimate())
+ .Times(AnyNumber());
+ EXPECT_CALL(*send_algorithm_, BandwidthEstimate())
+ .Times(AnyNumber())
+ .WillRepeatedly(Return(QuicBandwidth::Zero()));
+ EXPECT_CALL(*send_algorithm_, InSlowStart()).Times(AnyNumber());
+ EXPECT_CALL(*send_algorithm_, InRecovery()).Times(AnyNumber());
}
- virtual ~QuicSentPacketManagerTest() {
+ virtual ~QuicSentPacketManagerTest() override {
STLDeleteElements(&packets_);
}
+ QuicByteCount BytesInFlight() {
+ return QuicSentPacketManagerPeer::GetBytesInFlight(&manager_);
+ }
void VerifyUnackedPackets(QuicPacketSequenceNumber* packets,
size_t num_packets) {
if (num_packets == 0) {
EXPECT_FALSE(manager_.HasUnackedPackets());
- EXPECT_EQ(0u, manager_.GetNumRetransmittablePackets());
+ EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetNumRetransmittablePackets(
+ &manager_));
return;
}
EXPECT_TRUE(manager_.HasUnackedPackets());
- EXPECT_EQ(packets[0], manager_.GetLeastUnackedSentPacket());
+ EXPECT_EQ(packets[0], manager_.GetLeastUnacked());
for (size_t i = 0; i < num_packets; ++i) {
EXPECT_TRUE(manager_.IsUnacked(packets[i])) << packets[i];
}
void VerifyRetransmittablePackets(QuicPacketSequenceNumber* packets,
size_t num_packets) {
- SequenceNumberSet unacked = manager_.GetUnackedPackets();
+ EXPECT_EQ(num_packets,
+ QuicSentPacketManagerPeer::GetNumRetransmittablePackets(
+ &manager_));
for (size_t i = 0; i < num_packets; ++i) {
- EXPECT_TRUE(ContainsKey(unacked, packets[i])) << packets[i];
+ EXPECT_TRUE(manager_.HasRetransmittableFrames(packets[i]))
+ << " packets[" << i << "]:" << packets[i];
}
- size_t num_retransmittable = 0;
- for (SequenceNumberSet::const_iterator it = unacked.begin();
- it != unacked.end(); ++it) {
- if (manager_.HasRetransmittableFrames(*it)) {
- ++num_retransmittable;
- }
- }
- EXPECT_EQ(num_packets, manager_.GetNumRetransmittablePackets());
- EXPECT_EQ(num_packets, num_retransmittable);
}
- void VerifyAckedPackets(QuicPacketSequenceNumber* expected,
- size_t num_expected,
- const SequenceNumberSet& actual) {
- if (num_expected == 0) {
- EXPECT_TRUE(actual.empty());
- return;
- }
+ void ExpectAck(QuicPacketSequenceNumber largest_observed) {
+ EXPECT_CALL(*send_algorithm_, OnCongestionEvent(
+ true, _, ElementsAre(Pair(largest_observed, _)), IsEmpty()));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
+ }
+
+ void ExpectUpdatedRtt(QuicPacketSequenceNumber largest_observed) {
+ EXPECT_CALL(*send_algorithm_,
+ OnCongestionEvent(true, _, IsEmpty(), IsEmpty()));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
+ }
+
+ void ExpectAckAndLoss(bool rtt_updated,
+ QuicPacketSequenceNumber largest_observed,
+ QuicPacketSequenceNumber lost_packet) {
+ EXPECT_CALL(*send_algorithm_, OnCongestionEvent(
+ rtt_updated, _, ElementsAre(Pair(largest_observed, _)),
+ ElementsAre(Pair(lost_packet, _))));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
+ }
- EXPECT_EQ(num_expected, actual.size());
- for (size_t i = 0; i < num_expected; ++i) {
- EXPECT_TRUE(ContainsKey(actual, expected[i])) << expected[i];
+ // |packets_acked| and |packets_lost| should be in sequence number order.
+ void ExpectAcksAndLosses(bool rtt_updated,
+ QuicPacketSequenceNumber* packets_acked,
+ size_t num_packets_acked,
+ QuicPacketSequenceNumber* packets_lost,
+ size_t num_packets_lost) {
+ vector<QuicPacketSequenceNumber> ack_vector;
+ for (size_t i = 0; i < num_packets_acked; ++i) {
+ ack_vector.push_back(packets_acked[i]);
+ }
+ vector<QuicPacketSequenceNumber> lost_vector;
+ for (size_t i = 0; i < num_packets_lost; ++i) {
+ lost_vector.push_back(packets_lost[i]);
}
+ EXPECT_CALL(*send_algorithm_,
+ OnCongestionEvent(rtt_updated, _,
+ Pointwise(KeyEq(), ack_vector),
+ Pointwise(KeyEq(), lost_vector)));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange()).
+ Times(AnyNumber());
}
- 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, NACK_RETRANSMISSION);
+ &manager_, old_sequence_number, TLP_RETRANSMISSION);
EXPECT_TRUE(manager_.HasPendingRetransmissions());
QuicSentPacketManager::PendingRetransmission next_retransmission =
manager_.NextPendingRetransmission();
EXPECT_EQ(old_sequence_number, next_retransmission.sequence_number);
- EXPECT_EQ(NACK_RETRANSMISSION, next_retransmission.transmission_type);
- manager_.OnRetransmittedPacket(old_sequence_number, new_sequence_number);
- EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(
- &manager_, new_sequence_number));
- }
+ EXPECT_EQ(TLP_RETRANSMISSION,
+ next_retransmission.transmission_type);
- void RetransmitAndSendPacket(QuicPacketSequenceNumber old_sequence_number,
- QuicPacketSequenceNumber new_sequence_number) {
- RetransmitPacket(old_sequence_number, new_sequence_number);
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, new_sequence_number, _, _, _))
+ EXPECT_CALL(*send_algorithm_,
+ OnPacketSent(_, BytesInFlight(), new_sequence_number,
+ kDefaultLength, HAS_RETRANSMITTABLE_DATA))
.WillOnce(Return(true));
- manager_.OnPacketSent(new_sequence_number, clock_.Now(),
- 1000, NACK_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+ SerializedPacket packet(CreatePacket(new_sequence_number, false));
+ manager_.OnPacketSent(&packet,
+ old_sequence_number,
+ clock_.Now(),
+ kDefaultLength,
+ 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, 1000, false, PACKET_8BYTE_GUID, 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, 1000, false, PACKET_8BYTE_GUID, 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) {
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, sequence_number, _, _, _))
+ EXPECT_CALL(*send_algorithm_,
+ 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);
}
void SendCryptoPacket(QuicPacketSequenceNumber sequence_number) {
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, sequence_number, _, _, _))
+ EXPECT_CALL(*send_algorithm_,
+ OnPacketSent(_, BytesInFlight(), sequence_number,
+ kDefaultLength, HAS_RETRANSMITTABLE_DATA))
.Times(1).WillOnce(Return(true));
SerializedPacket packet(CreateDataPacket(sequence_number));
packet.retransmittable_frames->AddStreamFrame(
new QuicStreamFrame(1, false, 0, IOVector()));
- manager_.OnSerializedPacket(packet);
- manager_.OnPacketSent(sequence_number, clock_.ApproximateNow(),
+ packet.retransmittable_frames->set_encryption_level(ENCRYPTION_NONE);
+ manager_.OnPacketSent(&packet, 0, clock_.Now(),
packet.packet->length(), NOT_RETRANSMISSION,
HAS_RETRANSMITTABLE_DATA);
}
void SendFecPacket(QuicPacketSequenceNumber sequence_number) {
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, sequence_number, _, _, _))
+ EXPECT_CALL(*send_algorithm_,
+ OnPacketSent(_, BytesInFlight(), sequence_number,
+ 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);
+ }
+
+ void SendAckPacket(QuicPacketSequenceNumber sequence_number) {
+ EXPECT_CALL(*send_algorithm_,
+ OnPacketSent(_, BytesInFlight(), sequence_number,
+ kDefaultLength, NO_RETRANSMITTABLE_DATA))
+ .Times(1).WillOnce(Return(false));
+ SerializedPacket packet(CreatePacket(sequence_number, false));
+ manager_.OnPacketSent(&packet, 0, clock_.Now(),
packet.packet->length(), NOT_RETRANSMISSION,
NO_RETRANSMITTABLE_DATA);
}
QuicPacketSequenceNumber retransmission_sequence_number) {
EXPECT_TRUE(manager_.HasPendingRetransmissions());
EXPECT_CALL(*send_algorithm_,
- OnPacketSent(_, retransmission_sequence_number, _, _, _))
+ OnPacketSent(_, _, retransmission_sequence_number,
+ kDefaultLength, HAS_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_.ApproximateNow(), 1000,
- pending.transmission_type, HAS_RETRANSMITTABLE_DATA);
+ SerializedPacket packet(
+ CreatePacket(retransmission_sequence_number, false));
+ manager_.OnPacketSent(&packet, pending.sequence_number, clock_.Now(),
+ kDefaultLength, pending.transmission_type,
+ HAS_RETRANSMITTABLE_DATA);
}
QuicSentPacketManager manager_;
MockClock clock_;
QuicConnectionStats stats_;
MockSendAlgorithm* send_algorithm_;
+ scoped_ptr<MockNetworkChangeVisitor> network_change_visitor_;
};
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 };
RetransmitAndSendPacket(1, 2);
// Ack 2 but not 1.
- ReceivedPacketInfo received_info;
- received_info.largest_observed = 2;
- received_info.missing_packets.insert(1);
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(2, _)).Times(1);
- manager_.OnIncomingAck(received_info, QuicTime::Zero());
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 2;
+ ack_frame.missing_packets.insert(1);
+ ExpectAck(2);
+ manager_.OnIncomingAck(ack_frame, clock_.Now());
// Packet 1 is unacked, pending, but not retransmittable.
QuicPacketSequenceNumber unacked[] = { 1 };
VerifyUnackedPackets(unacked, arraysize(unacked));
EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
- VerifyRetransmittablePackets(NULL, 0);
+ VerifyRetransmittablePackets(nullptr, 0);
}
TEST_F(QuicSentPacketManagerTest, RetransmitThenAckBeforeSend) {
SendDataPacket(1);
QuicSentPacketManagerPeer::MarkForRetransmission(
- &manager_, 1, NACK_RETRANSMISSION);
+ &manager_, 1, TLP_RETRANSMISSION);
EXPECT_TRUE(manager_.HasPendingRetransmissions());
// Ack 1.
- ReceivedPacketInfo received_info;
- received_info.largest_observed = 1;
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(1, _)).Times(1);
- manager_.OnIncomingAck(received_info, QuicTime::Zero());
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 1;
+ ExpectAck(1);
+ manager_.OnIncomingAck(ack_frame, clock_.Now());
// There should no longer be a pending retransmission.
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.
- EXPECT_CALL(*send_algorithm_, UpdateRtt(rtt));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(1, _));
- ReceivedPacketInfo received_info;
- received_info.largest_observed = 1;
- EXPECT_TRUE(manager_.OnIncomingAck(received_info, clock_.ApproximateNow()));
-
- // No packets should be unacked.
- VerifyUnackedPackets(NULL, 0);
- 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);
// Ack 1 but not 2.
- EXPECT_CALL(*send_algorithm_, UpdateRtt(rtt));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(1, _));
- ReceivedPacketInfo received_info;
- received_info.largest_observed = 1;
- EXPECT_TRUE(manager_.OnIncomingAck(received_info, clock_.ApproximateNow()));
+ ExpectAck(1);
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 1;
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
// 2 remains unacked, but no packets have retransmittable data.
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(), 1000,
- NACK_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+ RetransmitAndSendPacket(1, 2);
QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
clock_.AdvanceTime(rtt);
// First, ACK packet 1 which makes packet 2 non-retransmittable.
- EXPECT_CALL(*send_algorithm_, UpdateRtt(rtt));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(1, _));
- ReceivedPacketInfo received_info;
- received_info.largest_observed = 1;
- EXPECT_TRUE(manager_.OnIncomingAck(received_info, clock_.ApproximateNow()));
+ ExpectAck(1);
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 1;
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
SendDataPacket(3);
SendDataPacket(4);
clock_.AdvanceTime(rtt);
// Next, NACK packet 2 three times.
- received_info.largest_observed = 3;
- received_info.missing_packets.insert(2);
- EXPECT_CALL(*send_algorithm_, UpdateRtt(rtt));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(3, _));
- EXPECT_TRUE(manager_.OnIncomingAck(received_info, clock_.ApproximateNow()));
-
- received_info.largest_observed = 4;
- EXPECT_CALL(*send_algorithm_, UpdateRtt(rtt));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(4, _));
- EXPECT_TRUE(manager_.OnIncomingAck(received_info, clock_.ApproximateNow()));
-
- received_info.largest_observed = 5;
- EXPECT_CALL(*send_algorithm_, UpdateRtt(rtt));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(5, _));
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(2, _));
- EXPECT_CALL(*send_algorithm_, OnPacketLost(2, _));
- EXPECT_TRUE(manager_.OnIncomingAck(received_info, clock_.ApproximateNow()));
+ ack_frame.largest_observed = 3;
+ ack_frame.missing_packets.insert(2);
+ ExpectAck(3);
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
+
+ ack_frame.largest_observed = 4;
+ ExpectAck(4);
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
+
+ ack_frame.largest_observed = 5;
+ ExpectAckAndLoss(true, 5, 2);
+ 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());
manager_.OnRetransmissionTimeout();
EXPECT_TRUE(manager_.HasPendingRetransmissions());
// Ack 1 but not 2, before 2 is able to be sent.
// Since 1 has been retransmitted, it has already been lost, and so the
// send algorithm is not informed that it has been ACK'd.
- ReceivedPacketInfo received_info;
- received_info.largest_observed = 1;
- EXPECT_CALL(*send_algorithm_, UpdateRtt(QuicTime::Delta::Zero()));
- EXPECT_TRUE(manager_.OnIncomingAck(received_info, clock_.ApproximateNow()));
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 1;
+ ExpectUpdatedRtt(1);
+ EXPECT_CALL(*send_algorithm_, RevertRetransmissionTimeout());
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
- // Since 2 was marked for retransmit, when 1 is acked, 2 is discarded.
- VerifyUnackedPackets(NULL, 0);
+ // Since 2 was marked for retransmit, when 1 is acked, 2 is kept for RTT.
+ 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.
}
TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckFirst) {
+ StrictMock<MockDebugDelegate> debug_delegate;
+ EXPECT_CALL(debug_delegate, OnSpuriousPacketRetransmition(
+ TLP_RETRANSMISSION, kDefaultLength)).Times(2);
+ manager_.set_debug_delegate(&debug_delegate);
+
SendDataPacket(1);
RetransmitAndSendPacket(1, 2);
RetransmitAndSendPacket(2, 3);
clock_.AdvanceTime(rtt);
// Ack 1 but not 2 or 3.
- EXPECT_CALL(*send_algorithm_, UpdateRtt(rtt));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(1, _));
- ReceivedPacketInfo received_info;
- received_info.largest_observed = 1;
- manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+ ExpectAck(1);
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 1;
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
// 2 and 3 remain unacked, but no packets have retransmittable data.
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 and 5 are sent and acked.
+ // Ensure packet 2 is lost when 4 is sent and 3 and 4 are acked.
SendDataPacket(4);
- received_info.largest_observed = 4;
- received_info.missing_packets.insert(2);
- EXPECT_CALL(*send_algorithm_, UpdateRtt(rtt));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(3, _));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(4, _));
- manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+ ack_frame.largest_observed = 4;
+ ack_frame.missing_packets.insert(2);
+ QuicPacketSequenceNumber acked[] = { 3, 4 };
+ ExpectAcksAndLosses(true, acked, arraysize(acked), nullptr, 0);
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
QuicPacketSequenceNumber unacked2[] = { 2 };
VerifyUnackedPackets(unacked2, arraysize(unacked2));
EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
SendDataPacket(5);
- received_info.largest_observed = 5;
- EXPECT_CALL(*send_algorithm_, UpdateRtt(rtt));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(5, _));
- EXPECT_CALL(*send_algorithm_, OnPacketLost(2, _));
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(2, _));
- manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
-
- VerifyUnackedPackets(NULL, 0);
+ ack_frame.largest_observed = 5;
+ ExpectAckAndLoss(true, 5, 2);
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
+
+ VerifyUnackedPackets(nullptr, 0);
EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
- EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted);
+ EXPECT_EQ(2u, stats_.packets_spuriously_retransmitted);
}
TEST_F(QuicSentPacketManagerTest, LoseButDontRetransmitRevivedPacket) {
SendDataPacket(4);
// Ack 2 and 3, and mark 1 as revived.
- ReceivedPacketInfo received_info;
- received_info.largest_observed = 3;
- received_info.missing_packets.insert(1);
- received_info.revived_packets.insert(1);
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _)).Times(2);
- manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 3;
+ ack_frame.missing_packets.insert(1);
+ ack_frame.revived_packets.insert(1);
+ QuicPacketSequenceNumber acked[] = { 2, 3 };
+ ExpectAcksAndLosses(true, acked, arraysize(acked), nullptr, 0);
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
EXPECT_FALSE(manager_.HasPendingRetransmissions());
QuicPacketSequenceNumber unacked[] = { 1, 4 };
VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
// Ack the 4th packet and expect the 1st to be considered lost.
- received_info.largest_observed = 4;
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _));
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(4, _));
- manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+ ack_frame.largest_observed = 4;
+ ExpectAckAndLoss(true, 4, 1);
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
EXPECT_FALSE(manager_.HasPendingRetransmissions());
- VerifyRetransmittablePackets(NULL, 0);
+ VerifyRetransmittablePackets(nullptr, 0);
+}
+
+TEST_F(QuicSentPacketManagerTest, MarkLostThenReviveAndDontRetransmitPacket) {
+ SendDataPacket(1);
+ SendDataPacket(2);
+ SendDataPacket(3);
+ SendDataPacket(4);
+ SendFecPacket(5);
+
+ // Ack 2, 3, and 4, and expect the 1st to be considered lost.
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 4;
+ ack_frame.missing_packets.insert(1);
+ QuicPacketSequenceNumber acked[] = { 2, 3, 4 };
+ QuicPacketSequenceNumber lost[] = { 1 };
+ ExpectAcksAndLosses(true, acked, arraysize(acked), lost, arraysize(lost));
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
+
+ EXPECT_TRUE(manager_.HasPendingRetransmissions());
+ QuicPacketSequenceNumber unacked[] = { 1, 5 };
+ VerifyUnackedPackets(unacked, arraysize(unacked));
+ QuicPacketSequenceNumber retransmittable[] = { 1 };
+ VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
+
+ // Ack 5th packet (FEC) and revive 1st packet. 1st packet should now be
+ // removed from pending retransmissions map.
+ ack_frame.largest_observed = 5;
+ ack_frame.revived_packets.insert(1);
+ ExpectAck(5);
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
+
+ EXPECT_FALSE(manager_.HasPendingRetransmissions());
+ VerifyRetransmittablePackets(nullptr, 0);
}
TEST_F(QuicSentPacketManagerTest, TruncatedAck) {
RetransmitAndSendPacket(4, 5);
// Truncated ack with 4 NACKs, so the first packet is lost.
- ReceivedPacketInfo received_info;
- received_info.largest_observed = 4;
- received_info.missing_packets.insert(1);
- received_info.missing_packets.insert(2);
- received_info.missing_packets.insert(3);
- received_info.missing_packets.insert(4);
- received_info.is_truncated = true;
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _));
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _));
- manager_.OnIncomingAck(received_info, QuicTime::Zero());
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 4;
+ ack_frame.missing_packets.insert(1);
+ ack_frame.missing_packets.insert(2);
+ ack_frame.missing_packets.insert(3);
+ ack_frame.missing_packets.insert(4);
+ ack_frame.is_truncated = true;
+
+ QuicPacketSequenceNumber lost[] = { 1 };
+ ExpectAcksAndLosses(true, nullptr, 0, lost, arraysize(lost));
+ manager_.OnIncomingAck(ack_frame, clock_.Now());
// High water mark will be raised.
- QuicPacketSequenceNumber unacked[] = { 2, 3, 4 };
+ QuicPacketSequenceNumber unacked[] = { 2, 3, 4, 5 };
VerifyUnackedPackets(unacked, arraysize(unacked));
- QuicPacketSequenceNumber retransmittable[] = { 4 };
+ QuicPacketSequenceNumber retransmittable[] = { 5 };
VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
}
RetransmitAndSendPacket(1, 2);
RetransmitAndSendPacket(2, 3);
RetransmitAndSendPacket(3, 4);
- manager_.OnSerializedPacket(CreateDataPacket(5));
- manager_.OnSerializedPacket(CreateDataPacket(6));
- manager_.OnSerializedPacket(CreateDataPacket(7));
- manager_.OnSerializedPacket(CreateDataPacket(8));
- manager_.OnSerializedPacket(CreateDataPacket(9));
+ SendDataPacket(5);
+ SendDataPacket(6);
+ SendDataPacket(7);
+ SendDataPacket(8);
+ SendDataPacket(9);
// Ack previous transmission
{
- ReceivedPacketInfo received_info;
- received_info.largest_observed = 2;
- received_info.missing_packets.insert(1);
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(2, _));
- manager_.OnIncomingAck(received_info, QuicTime::Zero());
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 2;
+ ack_frame.missing_packets.insert(1);
+ ExpectAck(2);
+ manager_.OnIncomingAck(ack_frame, clock_.Now());
EXPECT_TRUE(manager_.IsUnacked(4));
}
// Truncated ack with 4 NACKs
{
- ReceivedPacketInfo received_info;
- received_info.largest_observed = 6;
- received_info.missing_packets.insert(3);
- received_info.missing_packets.insert(4);
- received_info.missing_packets.insert(5);
- received_info.missing_packets.insert(6);
- received_info.is_truncated = true;
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(1, _));
- EXPECT_CALL(*send_algorithm_, OnPacketLost(3, _));
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(3, _));
- manager_.OnIncomingAck(received_info, QuicTime::Zero());
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 6;
+ ack_frame.missing_packets.insert(3);
+ ack_frame.missing_packets.insert(4);
+ ack_frame.missing_packets.insert(5);
+ ack_frame.missing_packets.insert(6);
+ ack_frame.is_truncated = true;
+ ExpectAckAndLoss(true, 1, 3);
+ manager_.OnIncomingAck(ack_frame, clock_.Now());
}
// High water mark will be raised.
VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
}
-TEST_F(QuicSentPacketManagerTest, GetLeastUnackedSentPacket) {
- EXPECT_EQ(0u, manager_.GetLeastUnackedSentPacket());
-}
-
-TEST_F(QuicSentPacketManagerTest, GetLeastUnackedSentPacketUnacked) {
- SerializedPacket serialized_packet(CreateDataPacket(1));
-
- manager_.OnSerializedPacket(serialized_packet);
- EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket());
+TEST_F(QuicSentPacketManagerTest, GetLeastUnacked) {
+ EXPECT_EQ(1u, manager_.GetLeastUnacked());
}
-TEST_F(QuicSentPacketManagerTest, GetLeastUnackedSentPacketUnackedFec) {
- SerializedPacket serialized_packet(CreateFecPacket(1));
-
- manager_.OnSerializedPacket(serialized_packet);
- EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket());
+TEST_F(QuicSentPacketManagerTest, GetLeastUnackedUnacked) {
+ SendDataPacket(1);
+ EXPECT_EQ(1u, manager_.GetLeastUnacked());
}
-TEST_F(QuicSentPacketManagerTest, GetLeastUnackedSentPacketDiscardUnacked) {
- SerializedPacket serialized_packet(CreateDataPacket(1));
-
- manager_.OnSerializedPacket(serialized_packet);
- manager_.DiscardUnackedPacket(1u);
- EXPECT_EQ(0u, manager_.GetLeastUnackedSentPacket());
+TEST_F(QuicSentPacketManagerTest, GetLeastUnackedUnackedFec) {
+ SendFecPacket(1);
+ EXPECT_EQ(1u, manager_.GetLeastUnacked());
}
-TEST_F(QuicSentPacketManagerTest, GetLeastUnackedPacketAndDiscard) {
- VerifyUnackedPackets(NULL, 0);
+TEST_F(QuicSentPacketManagerTest, GetLeastUnackedAndDiscard) {
+ VerifyUnackedPackets(nullptr, 0);
- SerializedPacket serialized_packet(CreateFecPacket(1));
- manager_.OnSerializedPacket(serialized_packet);
- EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket());
+ SendFecPacket(1);
+ EXPECT_EQ(1u, manager_.GetLeastUnacked());
- SerializedPacket serialized_packet2(CreateFecPacket(2));
- manager_.OnSerializedPacket(serialized_packet2);
- EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket());
+ SendFecPacket(2);
+ EXPECT_EQ(1u, manager_.GetLeastUnacked());
- SerializedPacket serialized_packet3(CreateFecPacket(3));
- manager_.OnSerializedPacket(serialized_packet3);
- EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket());
+ SendFecPacket(3);
+ EXPECT_EQ(1u, manager_.GetLeastUnacked());
QuicPacketSequenceNumber unacked[] = { 1, 2, 3 };
VerifyUnackedPackets(unacked, arraysize(unacked));
- VerifyRetransmittablePackets(NULL, 0);
+ VerifyRetransmittablePackets(nullptr, 0);
- manager_.DiscardUnackedPacket(1);
- EXPECT_EQ(2u, manager_.GetLeastUnackedSentPacket());
+ // Ack 2, so there's an rtt update.
+ ExpectAck(2);
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 2;
+ ack_frame.missing_packets.insert(1);
+ manager_.OnIncomingAck(ack_frame, clock_.Now());
- // Ack 2.
- ReceivedPacketInfo received_info;
- received_info.largest_observed = 2;
- manager_.OnIncomingAck(received_info, QuicTime::Zero());
-
- EXPECT_EQ(3u, manager_.GetLeastUnackedSentPacket());
-
- // Discard the 3rd packet and ensure there are no FEC packets.
- manager_.DiscardUnackedPacket(3);
- EXPECT_FALSE(manager_.HasUnackedPackets());
+ EXPECT_EQ(1u, manager_.GetLeastUnacked());
}
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(), 0, 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, 0, 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));
-}
-
-TEST_F(QuicSentPacketManagerTest, NackRetransmit1Packet) {
- const size_t kNumSentPackets = 4;
- // Transmit 4 packets.
- for (size_t i = 1; i <= kNumSentPackets; ++i) {
- SendDataPacket(i);
- }
- EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
-
- // Nack the first packet 3 times with increasing largest observed.
- ReceivedPacketInfo received_info;
- received_info.delta_time_largest_observed =
- QuicTime::Delta::FromMilliseconds(5);
- received_info.missing_packets.insert(1);
- for (QuicPacketSequenceNumber i = 1; i <= 3; ++i) {
- received_info.largest_observed = i + 1;
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(i + 1, _)).Times(1);
- if (i == 3) {
- EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _)).Times(1);
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _)).Times(1);
- }
- manager_.OnIncomingAck(received_info, clock_.Now());
- EXPECT_EQ(
- i == 3 ? 1u : 0u,
- QuicSentPacketManagerPeer::GetPendingRetransmissionCount(&manager_));
- EXPECT_EQ(i, QuicSentPacketManagerPeer::GetNackCount(&manager_, 1));
- }
- EXPECT_EQ(1u, stats_.packets_lost);
-}
-
-// A stretch ack is an ack that covers more than 1 packet of previously
-// unacknowledged data.
-TEST_F(QuicSentPacketManagerTest, NackRetransmit1PacketWith1StretchAck) {
- const size_t kNumSentPackets = 4;
- // Transmit 4 packets.
- for (size_t i = 1; i <= kNumSentPackets; ++i) {
- SendDataPacket(i);
- }
-
- // Nack the first packet 3 times in a single StretchAck.
- ReceivedPacketInfo received_info;
- received_info.delta_time_largest_observed =
- QuicTime::Delta::FromMilliseconds(5);
- received_info.missing_packets.insert(1);
- received_info.largest_observed = kNumSentPackets;
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _)).Times(3);
- EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _)).Times(1);
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _)).Times(1);
- manager_.OnIncomingAck(received_info, clock_.Now());
- EXPECT_EQ(
- 1u, QuicSentPacketManagerPeer::GetPendingRetransmissionCount(&manager_));
- EXPECT_EQ(3u, QuicSentPacketManagerPeer::GetNackCount(&manager_, 1));
- EXPECT_EQ(1u, stats_.packets_lost);
-}
-
-// Ack a packet 3 packets ahead, causing a retransmit.
-TEST_F(QuicSentPacketManagerTest, NackRetransmit1PacketSingleAck) {
- const size_t kNumSentPackets = 5;
- // Transmit 5 packets.
- for (size_t i = 1; i <= kNumSentPackets; ++i) {
- SendDataPacket(i);
- }
-
- // Nack the first packet 3 times in an AckFrame with three missing packets.
- ReceivedPacketInfo received_info;
- received_info.delta_time_largest_observed =
- QuicTime::Delta::FromMilliseconds(5);
- received_info.missing_packets.insert(1);
- received_info.missing_packets.insert(2);
- received_info.missing_packets.insert(3);
- received_info.largest_observed = 4;
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(4, _)).Times(1);
- EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _)).Times(1);
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _)).Times(1);
- manager_.OnIncomingAck(received_info, clock_.Now());
- EXPECT_EQ(
- 1u, QuicSentPacketManagerPeer::GetPendingRetransmissionCount(&manager_));
- EXPECT_EQ(3u, QuicSentPacketManagerPeer::GetNackCount(&manager_, 1));
- EXPECT_EQ(1u, stats_.packets_lost);
-}
-
-TEST_F(QuicSentPacketManagerTest, EarlyRetransmit1Packet) {
- const size_t kNumSentPackets = 2;
- // Transmit 2 packets.
- for (size_t i = 1; i <= kNumSentPackets; ++i) {
- SendDataPacket(i);
- }
-
- // Early retransmit when the final packet gets acked and the first is nacked.
- ReceivedPacketInfo received_info;
- received_info.delta_time_largest_observed =
- QuicTime::Delta::FromMilliseconds(5);
- received_info.missing_packets.insert(1);
- received_info.largest_observed = kNumSentPackets;
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(kNumSentPackets, _)).Times(1);
- EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _)).Times(1);
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _)).Times(1);
- manager_.OnIncomingAck(received_info, clock_.Now());
- EXPECT_EQ(
- 1u, QuicSentPacketManagerPeer::GetPendingRetransmissionCount(&manager_));
- EXPECT_EQ(1u, QuicSentPacketManagerPeer::GetNackCount(&manager_, 1));
- EXPECT_EQ(1u, stats_.packets_lost);
-}
-
-TEST_F(QuicSentPacketManagerTest, EarlyRetransmitAllPackets) {
- const size_t kNumSentPackets = 5;
- for (size_t i = 1; i <= kNumSentPackets; ++i) {
- SendDataPacket(i);
- }
-
- // Early retransmit all packets when the final packet arrives, since we do
- // not expect to receive any more acks.
- ReceivedPacketInfo received_info;
- received_info.delta_time_largest_observed =
- QuicTime::Delta::FromMilliseconds(5);
- received_info.missing_packets.insert(1);
- received_info.missing_packets.insert(2);
- received_info.missing_packets.insert(3);
- received_info.missing_packets.insert(4);
- received_info.largest_observed = kNumSentPackets;
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(5, _)).Times(1);
- EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(4);
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(4);
- manager_.OnIncomingAck(received_info, clock_.Now());
- EXPECT_EQ(
- 4u, QuicSentPacketManagerPeer::GetPendingRetransmissionCount(&manager_));
- EXPECT_EQ(4u, QuicSentPacketManagerPeer::GetNackCount(&manager_, 1));
- EXPECT_EQ(4u, stats_.packets_lost);
-}
-
-TEST_F(QuicSentPacketManagerTest, NackRetransmit2Packets) {
- const size_t kNumSentPackets = 25;
- // Transmit 25 packets.
- for (QuicPacketSequenceNumber i = 1; i <= kNumSentPackets; ++i) {
- SendDataPacket(i);
- }
-
- // Nack the first 19 packets 3 times, which does not trigger early retransmit.
- const size_t kLargestObserved = 20;
- ReceivedPacketInfo received_info;
- received_info.largest_observed = kLargestObserved;
- received_info.delta_time_largest_observed =
- QuicTime::Delta::FromMilliseconds(5);
- for (size_t i = 1; i < kLargestObserved; ++i) {
- received_info.missing_packets.insert(i);
- }
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- EXPECT_CALL(*send_algorithm_,
- OnPacketAcked(kLargestObserved, _)).Times(1);
- EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(17);
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(17);
- manager_.OnIncomingAck(received_info, clock_.Now());
- EXPECT_EQ(
- 17u, QuicSentPacketManagerPeer::GetPendingRetransmissionCount(&manager_));
- for (size_t i = 1; i < kLargestObserved; ++i) {
- EXPECT_EQ(kLargestObserved - i,
- QuicSentPacketManagerPeer::GetNackCount(&manager_, i));
- }
+ EXPECT_EQ(sent_time, QuicSentPacketManagerPeer::GetSentTime(&manager_, 1));
+ EXPECT_EQ(sent_time2, QuicSentPacketManagerPeer::GetSentTime(&manager_, 2));
}
-TEST_F(QuicSentPacketManagerTest, NackRetransmit2PacketsAlternateAcks) {
- const size_t kNumSentPackets = 30;
- // Transmit 15 packets of data and 15 ack packets. The send algorithm will
- // inform the congestion manager not to save the acks by returning false.
- for (QuicPacketSequenceNumber i = 1; i <= kNumSentPackets; ++i) {
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .Times(1).WillOnce(Return(i % 2 == 0 ? false : true));
- SerializedPacket packet(CreatePacket(i, i % 2 == 1));
- manager_.OnSerializedPacket(packet);
- manager_.OnPacketSent(
- i, clock_.Now(), 1000, NOT_RETRANSMISSION,
- i % 2 == 0 ? NO_RETRANSMITTABLE_DATA : HAS_RETRANSMITTABLE_DATA);
- }
+TEST_F(QuicSentPacketManagerTest, AckAckAndUpdateRtt) {
+ SendDataPacket(1);
+ SendAckPacket(2);
- // Nack the first 29 packets 3 times.
- ReceivedPacketInfo received_info;
- received_info.largest_observed = kNumSentPackets;
- received_info.delta_time_largest_observed =
+ // Now ack the ack and expect an RTT update.
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 2;
+ ack_frame.delta_time_largest_observed =
QuicTime::Delta::FromMilliseconds(5);
- for (size_t i = 1; i < kNumSentPackets; ++i) {
- received_info.missing_packets.insert(i);
- }
- // We never actually get an ack call, since the kNumSentPackets packet was
- // not saved.
- EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(14);
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(14);
- manager_.OnIncomingAck(received_info, clock_.Now());
- ASSERT_EQ(
- 14u, QuicSentPacketManagerPeer::GetPendingRetransmissionCount(&manager_));
- // Only non-ack packets have a nack count.
- for (size_t i = 1; i < kNumSentPackets; i += 2) {
- EXPECT_EQ(kNumSentPackets - i,
- QuicSentPacketManagerPeer::GetNackCount(&manager_, i));
- }
- // Ensure only the odd packets were retransmitted, since the others were not
- // retransmittable(ie: acks).
- for (size_t i = 0; i < 13; ++i) {
- EXPECT_EQ(1 + 2 * i, manager_.NextPendingRetransmission().sequence_number);
- manager_.OnRetransmittedPacket(1 + 2 * i, kNumSentPackets + 1 + i);
- }
-}
+ ExpectAck(1);
+ manager_.OnIncomingAck(ack_frame, clock_.Now());
-TEST_F(QuicSentPacketManagerTest, NackTwiceThenAck) {
- // Transmit 4 packets.
- for (QuicPacketSequenceNumber i = 1; i <= 4; ++i) {
- SendDataPacket(i);
- }
+ SendAckPacket(3);
- // Nack the first packet 2 times, then ack it.
- ReceivedPacketInfo received_info;
- received_info.missing_packets.insert(1);
- for (size_t i = 1; i <= 3; ++i) {
- if (i == 3) {
- received_info.missing_packets.clear();
- }
- received_info.largest_observed = i + 1;
- received_info.delta_time_largest_observed =
- QuicTime::Delta::FromMilliseconds(5);
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- EXPECT_CALL(*send_algorithm_,
- OnPacketAcked(_, _)).Times(i == 3 ? 2 : 1);
- manager_.OnIncomingAck(received_info, clock_.Now());
- EXPECT_FALSE(manager_.HasPendingRetransmissions());
- // The nack count remains at 2 when the packet is acked.
- EXPECT_EQ(i == 3 ? 2u : i,
- QuicSentPacketManagerPeer::GetNackCount(&manager_, 1));
- }
+ // Now ack the ack and expect only an RTT update.
+ ack_frame.largest_observed = 3;
+ ExpectUpdatedRtt(3);
+ manager_.OnIncomingAck(ack_frame, clock_.Now());
}
TEST_F(QuicSentPacketManagerTest, Rtt) {
SendDataPacket(sequence_number);
clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
- EXPECT_CALL(*send_algorithm_, UpdateRtt(expected_rtt));
- EXPECT_CALL(*send_algorithm_,
- OnPacketAcked(sequence_number, _)).Times(1);
- ReceivedPacketInfo received_info;
- received_info.largest_observed = sequence_number;
- received_info.delta_time_largest_observed =
+ ExpectAck(sequence_number);
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = sequence_number;
+ ack_frame.delta_time_largest_observed =
QuicTime::Delta::FromMilliseconds(5);
- manager_.OnIncomingAck(received_info, clock_.Now());
- EXPECT_EQ(expected_rtt, QuicSentPacketManagerPeer::rtt(&manager_));
+ manager_.OnIncomingAck(ack_frame, clock_.Now());
+ EXPECT_EQ(expected_rtt,
+ QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt());
}
TEST_F(QuicSentPacketManagerTest, RttWithInvalidDelta) {
SendDataPacket(sequence_number);
clock_.AdvanceTime(expected_rtt);
- EXPECT_CALL(*send_algorithm_, UpdateRtt(expected_rtt));
- EXPECT_CALL(*send_algorithm_,
- OnPacketAcked(sequence_number, _)).Times(1);
- ReceivedPacketInfo received_info;
- received_info.largest_observed = sequence_number;
- received_info.delta_time_largest_observed =
+ ExpectAck(sequence_number);
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = sequence_number;
+ ack_frame.delta_time_largest_observed =
QuicTime::Delta::FromMilliseconds(11);
- manager_.OnIncomingAck(received_info, clock_.Now());
- EXPECT_EQ(expected_rtt, QuicSentPacketManagerPeer::rtt(&manager_));
+ manager_.OnIncomingAck(ack_frame, clock_.Now());
+ EXPECT_EQ(expected_rtt,
+ QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt());
}
TEST_F(QuicSentPacketManagerTest, RttWithInfiniteDelta) {
SendDataPacket(sequence_number);
clock_.AdvanceTime(expected_rtt);
- EXPECT_CALL(*send_algorithm_, UpdateRtt(expected_rtt));
- EXPECT_CALL(*send_algorithm_,
- OnPacketAcked(sequence_number, _)).Times(1);
- ReceivedPacketInfo received_info;
- received_info.largest_observed = sequence_number;
- received_info.delta_time_largest_observed = QuicTime::Delta::Infinite();
- manager_.OnIncomingAck(received_info, clock_.Now());
- EXPECT_EQ(expected_rtt, QuicSentPacketManagerPeer::rtt(&manager_));
+ ExpectAck(sequence_number);
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = sequence_number;
+ ack_frame.delta_time_largest_observed = QuicTime::Delta::Infinite();
+ manager_.OnIncomingAck(ack_frame, clock_.Now());
+ EXPECT_EQ(expected_rtt,
+ QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt());
}
TEST_F(QuicSentPacketManagerTest, RttZeroDelta) {
SendDataPacket(sequence_number);
clock_.AdvanceTime(expected_rtt);
- EXPECT_CALL(*send_algorithm_, UpdateRtt(expected_rtt));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(sequence_number, _))
- .Times(1);
- ReceivedPacketInfo received_info;
- received_info.largest_observed = sequence_number;
- received_info.delta_time_largest_observed = QuicTime::Delta::Zero();
- manager_.OnIncomingAck(received_info, clock_.Now());
- EXPECT_EQ(expected_rtt, QuicSentPacketManagerPeer::rtt(&manager_));
+ ExpectAck(sequence_number);
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = sequence_number;
+ ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero();
+ manager_.OnIncomingAck(ack_frame, clock_.Now());
+ EXPECT_EQ(expected_rtt,
+ QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt());
}
TEST_F(QuicSentPacketManagerTest, TailLossProbeTimeout) {
// The first tail loss probe retransmits 1 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(2);
EXPECT_FALSE(manager_.HasPendingRetransmissions());
// The second tail loss probe retransmits 1 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());
// Ack the third and ensure the first two are still pending.
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(3, _));
- ReceivedPacketInfo received_info;
- received_info.largest_observed = 3;
- received_info.missing_packets.insert(1);
- received_info.missing_packets.insert(2);
- manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+ ExpectAck(3);
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 3;
+ ack_frame.missing_packets.insert(1);
+ ack_frame.missing_packets.insert(2);
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
// Acking two more packets will lose both of them due to nacks.
- received_info.largest_observed = 5;
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(2);
- EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(2);
- manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+ ack_frame.largest_observed = 5;
+ QuicPacketSequenceNumber lost[] = { 1, 2 };
+ ExpectAcksAndLosses(false, nullptr, 0, lost, arraysize(lost));
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
EXPECT_FALSE(manager_.HasPendingRetransmissions());
EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
// The first tail loss probe retransmits 1 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(101);
+ 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());
// The second tail loss probe retransmits 1 packet.
manager_.OnRetransmissionTimeout();
- RetransmitNextPacket(102);
+ EXPECT_EQ(QuicTime::Delta::Zero(),
+ manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
EXPECT_FALSE(manager_.HasPendingRetransmissions());
+ EXPECT_TRUE(manager_.MaybeRetransmitTailLossProbe());
+ EXPECT_TRUE(manager_.HasPendingRetransmissions());
+ RetransmitNextPacket(102);
+ EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).WillOnce(Return(
+ QuicTime::Delta::Infinite()));
+ EXPECT_EQ(QuicTime::Delta::Infinite(),
+ manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
// Advance the time enough to ensure all packets are RTO'd.
clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000));
// The final RTO abandons all of them.
EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
manager_.OnRetransmissionTimeout();
EXPECT_TRUE(manager_.HasPendingRetransmissions());
EXPECT_EQ(2u, stats_.tlp_count);
EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
// The first retransmits 2 packets.
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(2);
manager_.OnRetransmissionTimeout();
+ EXPECT_EQ(QuicTime::Delta::Zero(),
+ manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
RetransmitNextPacket(6);
RetransmitNextPacket(7);
EXPECT_FALSE(manager_.HasPendingRetransmissions());
EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
// The second retransmits 2 packets.
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(2);
manager_.OnRetransmissionTimeout();
+ EXPECT_EQ(QuicTime::Delta::Zero(),
+ manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
RetransmitNextPacket(8);
RetransmitNextPacket(9);
EXPECT_FALSE(manager_.HasPendingRetransmissions());
// Now ack the two crypto packets and the speculatively encrypted request,
// and ensure the first four crypto packets get abandoned, but not lost.
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _)).Times(5);
- ReceivedPacketInfo received_info;
- received_info.largest_observed = 9;
- received_info.missing_packets.insert(1);
- received_info.missing_packets.insert(2);
- received_info.missing_packets.insert(6);
- received_info.missing_packets.insert(7);
- manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+ QuicPacketSequenceNumber acked[] = { 3, 4, 5, 8, 9 };
+ ExpectAcksAndLosses(true, acked, arraysize(acked), nullptr, 0);
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 9;
+ ack_frame.missing_packets.insert(1);
+ ack_frame.missing_packets.insert(2);
+ ack_frame.missing_packets.insert(6);
+ ack_frame.missing_packets.insert(7);
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
}
+TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeoutVersionNegotiation) {
+ // Send 2 crypto packets and 3 data packets.
+ const size_t kNumSentCryptoPackets = 2;
+ for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) {
+ SendCryptoPacket(i);
+ }
+ const size_t kNumSentDataPackets = 3;
+ for (size_t i = 1; i <= kNumSentDataPackets; ++i) {
+ SendDataPacket(kNumSentCryptoPackets + i);
+ }
+ EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
+
+ // The first retransmission timeout retransmits 2 crypto packets.
+ manager_.OnRetransmissionTimeout();
+ RetransmitNextPacket(6);
+ RetransmitNextPacket(7);
+ EXPECT_FALSE(manager_.HasPendingRetransmissions());
+ EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
+
+ // Now act like a version negotiation packet arrived, which would cause all
+ // unacked packets to be retransmitted.
+ manager_.RetransmitUnackedPackets(ALL_UNACKED_RETRANSMISSION);
+
+ // Ensure the first two pending packets are the crypto retransmits.
+ ASSERT_TRUE(manager_.HasPendingRetransmissions());
+ EXPECT_EQ(6u, manager_.NextPendingRetransmission().sequence_number);
+ RetransmitNextPacket(8);
+ EXPECT_EQ(7u, manager_.NextPendingRetransmission().sequence_number);
+ RetransmitNextPacket(9);
+
+ EXPECT_TRUE(manager_.HasPendingRetransmissions());
+ // Send 3 more data packets and ensure the least unacked is raised.
+ RetransmitNextPacket(10);
+ RetransmitNextPacket(11);
+ RetransmitNextPacket(12);
+ EXPECT_FALSE(manager_.HasPendingRetransmissions());
+
+ EXPECT_EQ(8u, manager_.GetLeastUnacked());
+}
+
TEST_F(QuicSentPacketManagerTest, CryptoHandshakeSpuriousRetransmission) {
// Send 1 crypto packet.
SendCryptoPacket(1);
EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
// Retransmit the crypto packet as 2.
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(1);
manager_.OnRetransmissionTimeout();
RetransmitNextPacket(2);
// Retransmit the crypto packet as 3.
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(1);
manager_.OnRetransmissionTimeout();
RetransmitNextPacket(3);
- // Now ack the first crypto packet, and ensure the second gets abandoned and
- // removed from unacked_packets.
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(1);
- ReceivedPacketInfo received_info;
- received_info.largest_observed = 2;
- received_info.missing_packets.insert(1);
- manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+ // Now ack the second crypto packet, and ensure the first gets removed, but
+ // the third does not.
+ ExpectUpdatedRtt(2);
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 2;
+ ack_frame.missing_packets.insert(1);
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
- VerifyUnackedPackets(NULL, 0);
+ QuicPacketSequenceNumber unacked[] = { 3 };
+ VerifyUnackedPackets(unacked, arraysize(unacked));
}
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.
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(2);
manager_.OnRetransmissionTimeout();
- RetransmitNextPacket(6);
- RetransmitNextPacket(7);
+ RetransmitNextPacket(4);
+ RetransmitNextPacket(5);
EXPECT_FALSE(manager_.HasPendingRetransmissions());
EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
}
EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
// Retransmit the crypto packet as 2.
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(1);
manager_.OnRetransmissionTimeout();
RetransmitNextPacket(2);
// Now retransmit all the unacked packets, which occurs when there is a
// version negotiation.
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(1);
- manager_.RetransmitUnackedPackets(ALL_PACKETS);
+ manager_.RetransmitUnackedPackets(ALL_UNACKED_RETRANSMISSION);
QuicPacketSequenceNumber unacked[] = { 1, 2 };
VerifyUnackedPackets(unacked, arraysize(unacked));
EXPECT_TRUE(manager_.HasPendingRetransmissions());
EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
}
-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_));
+TEST_F(QuicSentPacketManagerTest,
+ CryptoHandshakeRetransmissionThenNeuterAndAck) {
+ // Send 1 crypto packet.
+ SendCryptoPacket(1);
+ EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
+
+ // Retransmit the crypto packet as 2.
+ manager_.OnRetransmissionTimeout();
+ RetransmitNextPacket(2);
- // Retransmit 1 unacked packets, but not the first serialized packet.
+ // Retransmit the crypto packet as 3.
manager_.OnRetransmissionTimeout();
RetransmitNextPacket(3);
+
+ // Now neuter all unacked unencrypted packets, which occurs when the
+ // connection goes forward secure.
+ manager_.NeuterUnencryptedPackets();
+ QuicPacketSequenceNumber unacked[] = { 1, 2, 3};
+ VerifyUnackedPackets(unacked, arraysize(unacked));
+ VerifyRetransmittablePackets(nullptr, 0);
EXPECT_FALSE(manager_.HasPendingRetransmissions());
EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
- EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
+ EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
+
+ // Ensure both packets get discarded when packet 2 is acked.
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 3;
+ ack_frame.missing_packets.insert(1);
+ ack_frame.missing_packets.insert(2);
+ ExpectUpdatedRtt(3);
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
+ VerifyUnackedPackets(nullptr, 0);
+ VerifyRetransmittablePackets(nullptr, 0);
+}
+
+TEST_F(QuicSentPacketManagerTest, ResetRecentMinRTTWithEmptyWindow) {
+ QuicTime::Delta min_rtt = QuicTime::Delta::FromMilliseconds(50);
+ QuicSentPacketManagerPeer::GetRttStats(&manager_)->UpdateRtt(
+ min_rtt, QuicTime::Delta::Zero(), QuicTime::Zero());
+ EXPECT_EQ(min_rtt,
+ QuicSentPacketManagerPeer::GetRttStats(&manager_)->min_rtt());
+ EXPECT_EQ(min_rtt,
+ QuicSentPacketManagerPeer::GetRttStats(
+ &manager_)->recent_min_rtt());
+
+ // Send two packets with no prior bytes in flight.
+ SendDataPacket(1);
+ SendDataPacket(2);
+
+ clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(100));
+ // Ack two packets with 100ms RTT observations.
+ QuicAckFrame ack_frame;
+ ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero();
+ ack_frame.largest_observed = 1;
+ ExpectAck(1);
+ manager_.OnIncomingAck(ack_frame, clock_.Now());
+
+ // First ack does not change recent min rtt.
+ EXPECT_EQ(min_rtt,
+ QuicSentPacketManagerPeer::GetRttStats(
+ &manager_)->recent_min_rtt());
+
+ ack_frame.largest_observed = 2;
+ ExpectAck(2);
+ manager_.OnIncomingAck(ack_frame, clock_.Now());
+
+ EXPECT_EQ(min_rtt,
+ QuicSentPacketManagerPeer::GetRttStats(&manager_)->min_rtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100),
+ QuicSentPacketManagerPeer::GetRttStats(
+ &manager_)->recent_min_rtt());
}
TEST_F(QuicSentPacketManagerTest, RetransmissionTimeout) {
}
EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
+ EXPECT_FALSE(manager_.MaybeRetransmitTailLossProbe());
manager_.OnRetransmissionTimeout();
}
SendCryptoPacket(1);
// Check the min.
- EXPECT_CALL(*send_algorithm_, SmoothedRtt())
- .WillRepeatedly(Return(QuicTime::Delta::FromMilliseconds(1)));
+ 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.
- EXPECT_CALL(*send_algorithm_, SmoothedRtt())
- .WillRepeatedly(Return(QuicTime::Delta::FromMilliseconds(100)));
+ rtt_stats->set_initial_rtt_us(100 * base::Time::kMicrosecondsPerMillisecond);
- QuicTime::Delta srtt = manager_.SmoothedRtt();
- QuicTime expected_time = clock_.Now().Add(QuicTime::Delta::FromMilliseconds(
- static_cast<int64>(1.5 * srtt.ToMilliseconds())));
+ 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());
// Retransmit the packet by invoking the retransmission timeout.
- clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(
- static_cast<int64>(1.5 * srtt.ToMilliseconds())));
- EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _));
+ clock_.AdvanceTime(srtt.Multiply(1.5));
manager_.OnRetransmissionTimeout();
RetransmitNextPacket(2);
// The retransmission time should now be twice as far in the future.
- expected_time = clock_.Now().Add(QuicTime::Delta::FromMilliseconds(
- static_cast<int64>(2 * 1.5 * srtt.ToMilliseconds())));
+ expected_time = clock_.Now().Add(srtt.Multiply(2).Multiply(1.5));
EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
}
SendDataPacket(2);
// Check the min.
- EXPECT_CALL(*send_algorithm_, SmoothedRtt())
- .WillRepeatedly(Return(QuicTime::Delta::FromMilliseconds(1)));
+ 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.
- EXPECT_CALL(*send_algorithm_, SmoothedRtt())
- .WillRepeatedly(Return(QuicTime::Delta::FromMilliseconds(100)));
- QuicTime::Delta srtt = manager_.SmoothedRtt();
- QuicTime::Delta expected_tlp_delay = QuicTime::Delta::FromMilliseconds(
- static_cast<int64>(2 * srtt.ToMilliseconds()));
+ 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());
// Retransmit the packet by invoking the retransmission timeout.
clock_.AdvanceTime(expected_tlp_delay);
manager_.OnRetransmissionTimeout();
+ EXPECT_EQ(QuicTime::Delta::Zero(),
+ manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
+ EXPECT_FALSE(manager_.HasPendingRetransmissions());
+ EXPECT_TRUE(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());
expected_time = clock_.Now().Add(expected_tlp_delay);
}
TEST_F(QuicSentPacketManagerTest, GetTransmissionTimeRTO) {
- EXPECT_CALL(*send_algorithm_, SmoothedRtt())
- .WillRepeatedly(Return(QuicTime::Delta::FromMilliseconds(100)));
+ QuicSentPacketManagerPeer::GetRttStats(&manager_)->UpdateRtt(
+ QuicTime::Delta::FromMilliseconds(100),
+ QuicTime::Delta::Zero(),
+ QuicTime::Zero());
SendDataPacket(1);
SendDataPacket(2);
+ SendDataPacket(3);
+ SendDataPacket(4);
QuicTime::Delta expected_rto_delay = QuicTime::Delta::FromMilliseconds(500);
EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
// Retransmit the packet by invoking the retransmission timeout.
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
clock_.AdvanceTime(expected_rto_delay);
manager_.OnRetransmissionTimeout();
- RetransmitNextPacket(3);
- RetransmitNextPacket(4);
- EXPECT_FALSE(manager_.HasPendingRetransmissions());
+ EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+ RetransmitNextPacket(5);
+ RetransmitNextPacket(6);
+ EXPECT_EQ(2 * kDefaultLength,
+ QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+ EXPECT_TRUE(manager_.HasPendingRetransmissions());
// The delay should double the second time.
expected_time = clock_.Now().Add(expected_rto_delay).Add(expected_rto_delay);
EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
// Ack a packet and ensure the RTO goes back to the original value.
- ReceivedPacketInfo received_info;
- received_info.largest_observed = 2;
- received_info.missing_packets.insert(1);
- EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
- manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
-
- expected_time = clock_.Now().Add(expected_rto_delay);
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 2;
+ ack_frame.missing_packets.insert(1);
+ ExpectUpdatedRtt(2);
+ EXPECT_CALL(*send_algorithm_, RevertRetransmissionTimeout());
+ manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
+ EXPECT_FALSE(manager_.HasPendingRetransmissions());
+ EXPECT_EQ(4 * kDefaultLength,
+ QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+
+ // 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.
+ // 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_, 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_, OnRetransmissionTimeout(true));
manager_.OnRetransmissionTimeout();
RetransmitNextPacket(i + 2);
}
}
+TEST_F(QuicSentPacketManagerTest, GetLossDelay) {
+ MockLossAlgorithm* loss_algorithm = new MockLossAlgorithm();
+ QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm);
+
+ EXPECT_CALL(*loss_algorithm, GetLossTimeout())
+ .WillRepeatedly(Return(QuicTime::Zero()));
+ SendDataPacket(1);
+ SendDataPacket(2);
+
+ // Handle an ack which causes the loss algorithm to be evaluated and
+ // set the loss timeout.
+ ExpectAck(2);
+ EXPECT_CALL(*loss_algorithm, DetectLostPackets(_, _, _, _))
+ .WillOnce(Return(SequenceNumberSet()));
+ QuicAckFrame ack_frame;
+ ack_frame.largest_observed = 2;
+ ack_frame.missing_packets.insert(1);
+ manager_.OnIncomingAck(ack_frame, clock_.Now());
+
+ QuicTime timeout(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(10)));
+ EXPECT_CALL(*loss_algorithm, GetLossTimeout())
+ .WillRepeatedly(Return(timeout));
+ EXPECT_EQ(timeout, manager_.GetRetransmissionTime());
+
+ // Fire the retransmission timeout and ensure the loss detection algorithm
+ // is invoked.
+ EXPECT_CALL(*loss_algorithm, DetectLostPackets(_, _, _, _))
+ .WillOnce(Return(SequenceNumberSet()));
+ manager_.OnRetransmissionTimeout();
+}
+
+TEST_F(QuicSentPacketManagerTest, NegotiateTimeLossDetectionFromOptions) {
+ EXPECT_EQ(kNack,
+ QuicSentPacketManagerPeer::GetLossAlgorithm(
+ &manager_)->GetLossDetectionType());
+
+ QuicConfig config;
+ QuicTagVector options;
+ options.push_back(kTIME);
+ QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
+ EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
+ manager_.SetFromConfig(config);
+
+ EXPECT_EQ(kTime,
+ QuicSentPacketManagerPeer::GetLossAlgorithm(
+ &manager_)->GetLossDetectionType());
+}
+
+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());
+ manager_.SetFromConfig(config);
+ EXPECT_EQ(kReno, QuicSentPacketManagerPeer::GetSendAlgorithm(
+ manager_)->GetCongestionControlType());
+
+ // TODO(rtenneti): Enable the following code after BBR code is checked in.
+#if 0
+ options.clear();
+ options.push_back(kTBBR);
+ QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
+ manager_.SetFromConfig(config);
+ 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());
+
+ QuicConfig config;
+ QuicTagVector options;
+ options.push_back(kPACE);
+ QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
+ 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()->smoothed_rtt().ToMicroseconds());
+
+ QuicConfig config;
+ config.SetInitialRoundTripTimeUsToSend(initial_rtt_us);
+ EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
+ EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
+ manager_.SetFromConfig(config);
+
+ EXPECT_EQ(0, manager_.GetRttStats()->smoothed_rtt().ToMicroseconds());
+ EXPECT_EQ(initial_rtt_us, manager_.GetRttStats()->initial_rtt_us());
+}
+
} // namespace
} // namespace test
} // namespace net
projects / platform / framework / web / crosswalk.git / blobdiff