Gallery.app: Does not open files not having an image exntension in their file name.
[chromium-blink-merge.git] / net / quic / quic_sent_packet_manager_test.cc
blob8a386bfd0d0c7db6dd41837ae0c2a9cb3e4d6268
1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "net/quic/quic_sent_packet_manager.h"
7 #include "base/stl_util.h"
8 #include "net/quic/quic_flags.h"
9 #include "net/quic/test_tools/quic_config_peer.h"
10 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
11 #include "net/quic/test_tools/quic_test_utils.h"
12 #include "testing/gmock/include/gmock/gmock.h"
13 #include "testing/gtest/include/gtest/gtest.h"
15 using std::vector;
16 using testing::AnyNumber;
17 using testing::ElementsAre;
18 using testing::Pair;
19 using testing::Pointwise;
20 using testing::Return;
21 using testing::StrictMock;
22 using testing::_;
24 namespace net {
25 namespace test {
26 namespace {
28 // Default packet length.
29 const uint32 kDefaultLength = 1000;
31 // Matcher to check the key of the key-value pair it receives as first argument
32 // equals its second argument.
33 MATCHER(KeyEq, "") {
34 return std::tr1::get<0>(arg).first == std::tr1::get<1>(arg);
37 class MockDebugDelegate : public QuicSentPacketManager::DebugDelegate {
38 public:
39 MOCK_METHOD2(OnSpuriousPacketRetransmition,
40 void(TransmissionType transmission_type,
41 QuicByteCount byte_size));
44 class QuicSentPacketManagerTest : public ::testing::TestWithParam<bool> {
45 protected:
46 QuicSentPacketManagerTest()
47 : manager_(true, &clock_, &stats_, kCubic, kNack),
48 send_algorithm_(new StrictMock<MockSendAlgorithm>),
49 network_change_visitor_(new StrictMock<MockNetworkChangeVisitor>) {
50 QuicSentPacketManagerPeer::SetSendAlgorithm(&manager_, send_algorithm_);
51 // Disable tail loss probes for most tests.
52 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 0);
53 // Advance the time 1s so the send times are never QuicTime::Zero.
54 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000));
55 manager_.set_network_change_visitor(network_change_visitor_.get());
57 EXPECT_CALL(*send_algorithm_, HasReliableBandwidthEstimate())
58 .Times(AnyNumber());
59 EXPECT_CALL(*send_algorithm_, BandwidthEstimate())
60 .Times(AnyNumber())
61 .WillRepeatedly(Return(QuicBandwidth::Zero()));
62 EXPECT_CALL(*send_algorithm_, InSlowStart()).Times(AnyNumber());
63 EXPECT_CALL(*send_algorithm_, InRecovery()).Times(AnyNumber());
66 virtual ~QuicSentPacketManagerTest() OVERRIDE {
67 STLDeleteElements(&packets_);
70 QuicByteCount BytesInFlight() {
71 return QuicSentPacketManagerPeer::GetBytesInFlight(&manager_);
73 void VerifyUnackedPackets(QuicPacketSequenceNumber* packets,
74 size_t num_packets) {
75 if (num_packets == 0) {
76 EXPECT_FALSE(manager_.HasUnackedPackets());
77 EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetNumRetransmittablePackets(
78 &manager_));
79 return;
82 EXPECT_TRUE(manager_.HasUnackedPackets());
83 EXPECT_EQ(packets[0], manager_.GetLeastUnacked());
84 for (size_t i = 0; i < num_packets; ++i) {
85 EXPECT_TRUE(manager_.IsUnacked(packets[i])) << packets[i];
89 void VerifyRetransmittablePackets(QuicPacketSequenceNumber* packets,
90 size_t num_packets) {
91 EXPECT_EQ(num_packets,
92 QuicSentPacketManagerPeer::GetNumRetransmittablePackets(
93 &manager_));
94 for (size_t i = 0; i < num_packets; ++i) {
95 EXPECT_TRUE(manager_.HasRetransmittableFrames(packets[i]))
96 << " packets[" << i << "]:" << packets[i];
100 void ExpectAck(QuicPacketSequenceNumber largest_observed) {
101 EXPECT_CALL(*send_algorithm_, OnCongestionEvent(
102 true, _, ElementsAre(Pair(largest_observed, _)), _));
103 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
104 .WillOnce(Return(100 * kDefaultTCPMSS));
105 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
108 void ExpectUpdatedRtt(QuicPacketSequenceNumber largest_observed) {
109 EXPECT_CALL(*send_algorithm_,
110 OnCongestionEvent(true, _, _, _));
111 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
112 .WillOnce(Return(100 * kDefaultTCPMSS));
113 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
116 void ExpectAckAndLoss(bool rtt_updated,
117 QuicPacketSequenceNumber largest_observed,
118 QuicPacketSequenceNumber lost_packet) {
119 EXPECT_CALL(*send_algorithm_, OnCongestionEvent(
120 rtt_updated, _, ElementsAre(Pair(largest_observed, _)),
121 ElementsAre(Pair(lost_packet, _))));
122 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
123 .WillOnce(Return(100 * kDefaultTCPMSS));
124 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
127 // |packets_acked| and |packets_lost| should be in sequence number order.
128 void ExpectAcksAndLosses(bool rtt_updated,
129 QuicPacketSequenceNumber* packets_acked,
130 size_t num_packets_acked,
131 QuicPacketSequenceNumber* packets_lost,
132 size_t num_packets_lost) {
133 vector<QuicPacketSequenceNumber> ack_vector;
134 for (size_t i = 0; i < num_packets_acked; ++i) {
135 ack_vector.push_back(packets_acked[i]);
137 vector<QuicPacketSequenceNumber> lost_vector;
138 for (size_t i = 0; i < num_packets_lost; ++i) {
139 lost_vector.push_back(packets_lost[i]);
141 EXPECT_CALL(*send_algorithm_,
142 OnCongestionEvent(rtt_updated, _,
143 Pointwise(KeyEq(), ack_vector),
144 Pointwise(KeyEq(), lost_vector)));
145 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
146 .WillRepeatedly(Return(100 * kDefaultTCPMSS));
147 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_)).
148 Times(AnyNumber());
151 // Retransmits a packet as though it was a TLP retransmission, because TLP
152 // leaves the |old_sequence_number| pending.
153 // TODO(ianswett): Test with transmission types besides TLP.
154 void RetransmitPacket(QuicPacketSequenceNumber old_sequence_number,
155 QuicPacketSequenceNumber new_sequence_number) {
156 QuicSentPacketManagerPeer::MarkForRetransmission(
157 &manager_, old_sequence_number, TLP_RETRANSMISSION);
158 EXPECT_TRUE(manager_.HasPendingRetransmissions());
159 QuicSentPacketManager::PendingRetransmission next_retransmission =
160 manager_.NextPendingRetransmission();
161 EXPECT_EQ(old_sequence_number, next_retransmission.sequence_number);
162 EXPECT_EQ(TLP_RETRANSMISSION,
163 next_retransmission.transmission_type);
164 manager_.OnRetransmittedPacket(old_sequence_number,
165 new_sequence_number);
166 EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(
167 &manager_, new_sequence_number));
170 void RetransmitAndSendPacket(QuicPacketSequenceNumber old_sequence_number,
171 QuicPacketSequenceNumber new_sequence_number) {
172 RetransmitPacket(old_sequence_number, new_sequence_number);
174 EXPECT_CALL(*send_algorithm_,
175 OnPacketSent(_, BytesInFlight(), new_sequence_number,
176 kDefaultLength, HAS_RETRANSMITTABLE_DATA))
177 .WillOnce(Return(true));
178 manager_.OnPacketSent(new_sequence_number,
179 clock_.Now(),
180 kDefaultLength,
181 LOSS_RETRANSMISSION,
182 HAS_RETRANSMITTABLE_DATA);
185 SerializedPacket CreateDataPacket(QuicPacketSequenceNumber sequence_number) {
186 return CreatePacket(sequence_number, true);
189 SerializedPacket CreatePacket(QuicPacketSequenceNumber sequence_number,
190 bool retransmittable) {
191 packets_.push_back(QuicPacket::NewDataPacket(
192 NULL, kDefaultLength, false, PACKET_8BYTE_CONNECTION_ID, false,
193 PACKET_6BYTE_SEQUENCE_NUMBER));
194 return SerializedPacket(
195 sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER,
196 packets_.back(), 0u,
197 retransmittable ? new RetransmittableFrames() : NULL);
200 SerializedPacket CreateFecPacket(QuicPacketSequenceNumber sequence_number) {
201 packets_.push_back(QuicPacket::NewFecPacket(
202 NULL, kDefaultLength, false, PACKET_8BYTE_CONNECTION_ID, false,
203 PACKET_6BYTE_SEQUENCE_NUMBER));
204 return SerializedPacket(sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER,
205 packets_.back(), 0u, NULL);
208 void SendDataPacket(QuicPacketSequenceNumber sequence_number) {
209 EXPECT_CALL(*send_algorithm_,
210 OnPacketSent(_, BytesInFlight(), sequence_number, _, _))
211 .Times(1).WillOnce(Return(true));
212 SerializedPacket packet(CreateDataPacket(sequence_number));
213 manager_.OnSerializedPacket(packet);
214 manager_.OnPacketSent(sequence_number, clock_.Now(),
215 packet.packet->length(), NOT_RETRANSMISSION,
216 HAS_RETRANSMITTABLE_DATA);
219 void SendCryptoPacket(QuicPacketSequenceNumber sequence_number) {
220 EXPECT_CALL(*send_algorithm_,
221 OnPacketSent(_, BytesInFlight(), sequence_number,
222 kDefaultLength, HAS_RETRANSMITTABLE_DATA))
223 .Times(1).WillOnce(Return(true));
224 SerializedPacket packet(CreateDataPacket(sequence_number));
225 packet.retransmittable_frames->AddStreamFrame(
226 new QuicStreamFrame(1, false, 0, IOVector()));
227 packet.retransmittable_frames->set_encryption_level(ENCRYPTION_NONE);
228 manager_.OnSerializedPacket(packet);
229 manager_.OnPacketSent(sequence_number, clock_.ApproximateNow(),
230 packet.packet->length(), NOT_RETRANSMISSION,
231 HAS_RETRANSMITTABLE_DATA);
234 void SendFecPacket(QuicPacketSequenceNumber sequence_number) {
235 EXPECT_CALL(*send_algorithm_,
236 OnPacketSent(_, BytesInFlight(), sequence_number,
237 kDefaultLength, NO_RETRANSMITTABLE_DATA))
238 .Times(1).WillOnce(Return(true));
239 SerializedPacket packet(CreateFecPacket(sequence_number));
240 manager_.OnSerializedPacket(packet);
241 manager_.OnPacketSent(sequence_number, clock_.ApproximateNow(),
242 packet.packet->length(), NOT_RETRANSMISSION,
243 NO_RETRANSMITTABLE_DATA);
246 void SendAckPacket(QuicPacketSequenceNumber sequence_number) {
247 EXPECT_CALL(*send_algorithm_,
248 OnPacketSent(_, BytesInFlight(), sequence_number,
249 kDefaultLength, NO_RETRANSMITTABLE_DATA))
250 .Times(1).WillOnce(Return(false));
251 SerializedPacket packet(CreatePacket(sequence_number, false));
252 manager_.OnSerializedPacket(packet);
253 manager_.OnPacketSent(sequence_number, clock_.Now(),
254 packet.packet->length(), NOT_RETRANSMISSION,
255 NO_RETRANSMITTABLE_DATA);
258 // Based on QuicConnection's WritePendingRetransmissions.
259 void RetransmitNextPacket(
260 QuicPacketSequenceNumber retransmission_sequence_number) {
261 EXPECT_TRUE(manager_.HasPendingRetransmissions());
262 EXPECT_CALL(*send_algorithm_,
263 OnPacketSent(_, _, retransmission_sequence_number,
264 kDefaultLength, HAS_RETRANSMITTABLE_DATA))
265 .Times(1).WillOnce(Return(true));
266 const QuicSentPacketManager::PendingRetransmission pending =
267 manager_.NextPendingRetransmission();
268 manager_.OnRetransmittedPacket(pending.sequence_number,
269 retransmission_sequence_number);
270 manager_.OnPacketSent(retransmission_sequence_number, clock_.Now(),
271 kDefaultLength, pending.transmission_type,
272 HAS_RETRANSMITTABLE_DATA);
275 QuicSentPacketManager manager_;
276 vector<QuicPacket*> packets_;
277 MockClock clock_;
278 QuicConnectionStats stats_;
279 MockSendAlgorithm* send_algorithm_;
280 scoped_ptr<MockNetworkChangeVisitor> network_change_visitor_;
283 TEST_F(QuicSentPacketManagerTest, IsUnacked) {
284 VerifyUnackedPackets(NULL, 0);
286 SerializedPacket serialized_packet(CreateDataPacket(1));
288 manager_.OnSerializedPacket(serialized_packet);
290 QuicPacketSequenceNumber unacked[] = { 1 };
291 VerifyUnackedPackets(unacked, arraysize(unacked));
292 QuicPacketSequenceNumber retransmittable[] = { 1 };
293 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
296 TEST_F(QuicSentPacketManagerTest, IsUnAckedRetransmit) {
297 SendDataPacket(1);
298 RetransmitPacket(1, 2);
300 EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(&manager_, 2));
301 QuicPacketSequenceNumber unacked[] = { 1, 2 };
302 VerifyUnackedPackets(unacked, arraysize(unacked));
303 QuicPacketSequenceNumber retransmittable[] = { 2 };
304 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
307 TEST_F(QuicSentPacketManagerTest, RetransmitThenAck) {
308 SendDataPacket(1);
309 RetransmitAndSendPacket(1, 2);
311 // Ack 2 but not 1.
312 QuicAckFrame ack_frame;
313 ack_frame.largest_observed = 2;
314 ack_frame.missing_packets.insert(1);
315 ExpectAck(2);
316 manager_.OnIncomingAck(ack_frame, clock_.Now());
318 // Packet 1 is unacked, pending, but not retransmittable.
319 QuicPacketSequenceNumber unacked[] = { 1 };
320 VerifyUnackedPackets(unacked, arraysize(unacked));
321 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
322 VerifyRetransmittablePackets(NULL, 0);
325 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckBeforeSend) {
326 SendDataPacket(1);
327 QuicSentPacketManagerPeer::MarkForRetransmission(
328 &manager_, 1, TLP_RETRANSMISSION);
329 EXPECT_TRUE(manager_.HasPendingRetransmissions());
331 // Ack 1.
332 QuicAckFrame ack_frame;
333 ack_frame.largest_observed = 1;
334 ExpectAck(1);
335 manager_.OnIncomingAck(ack_frame, clock_.Now());
337 // There should no longer be a pending retransmission.
338 EXPECT_FALSE(manager_.HasPendingRetransmissions());
340 // No unacked packets remain.
341 VerifyUnackedPackets(NULL, 0);
342 VerifyRetransmittablePackets(NULL, 0);
343 EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted);
346 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPrevious) {
347 SendDataPacket(1);
348 RetransmitPacket(1, 2);
349 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
350 clock_.AdvanceTime(rtt);
352 // Ack 1 but not 2.
353 ExpectAck(1);
354 QuicAckFrame ack_frame;
355 ack_frame.largest_observed = 1;
356 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
358 // 2 should be unacked, since it may provide an RTT measurement.
359 QuicPacketSequenceNumber unacked[] = { 2 };
360 VerifyUnackedPackets(unacked, arraysize(unacked));
361 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
362 VerifyRetransmittablePackets(NULL, 0);
364 // Verify that the retransmission alarm would not fire,
365 // since there is no retransmittable data outstanding.
366 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
367 EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted);
370 TEST_F(QuicSentPacketManagerTest, RetransmitAndSendThenAckPrevious) {
371 SendDataPacket(1);
372 RetransmitAndSendPacket(1, 2);
373 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
374 clock_.AdvanceTime(rtt);
376 // Ack 1 but not 2.
377 ExpectAck(1);
378 QuicAckFrame ack_frame;
379 ack_frame.largest_observed = 1;
380 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
382 // 2 remains unacked, but no packets have retransmittable data.
383 QuicPacketSequenceNumber unacked[] = { 2 };
384 VerifyUnackedPackets(unacked, arraysize(unacked));
385 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
386 VerifyRetransmittablePackets(NULL, 0);
388 EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted);
391 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPreviousThenNackRetransmit) {
392 SendDataPacket(1);
393 RetransmitPacket(1, 2);
394 EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 2, _, _))
395 .WillOnce(Return(true));
396 manager_.OnPacketSent(2, clock_.ApproximateNow(), kDefaultLength,
397 LOSS_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
398 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
399 clock_.AdvanceTime(rtt);
401 // First, ACK packet 1 which makes packet 2 non-retransmittable.
402 ExpectAck(1);
403 QuicAckFrame ack_frame;
404 ack_frame.largest_observed = 1;
405 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
407 SendDataPacket(3);
408 SendDataPacket(4);
409 SendDataPacket(5);
410 clock_.AdvanceTime(rtt);
412 // Next, NACK packet 2 three times.
413 ack_frame.largest_observed = 3;
414 ack_frame.missing_packets.insert(2);
415 ExpectAck(3);
416 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
418 ack_frame.largest_observed = 4;
419 ExpectAck(4);
420 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
422 ack_frame.largest_observed = 5;
423 ExpectAckAndLoss(true, 5, 2);
424 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
426 // No packets remain unacked.
427 VerifyUnackedPackets(NULL, 0);
428 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
429 VerifyRetransmittablePackets(NULL, 0);
431 // Verify that the retransmission alarm would not fire,
432 // since there is no retransmittable data outstanding.
433 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
436 TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckPreviousBeforeSend) {
437 SendDataPacket(1);
438 RetransmitAndSendPacket(1, 2);
440 // Fire the RTO, which will mark 2 for retransmission (but will not send it).
441 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
442 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
443 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
444 .WillOnce(Return(2 * kDefaultTCPMSS));
445 manager_.OnRetransmissionTimeout();
446 EXPECT_TRUE(manager_.HasPendingRetransmissions());
448 // Ack 1 but not 2, before 2 is able to be sent.
449 // Since 1 has been retransmitted, it has already been lost, and so the
450 // send algorithm is not informed that it has been ACK'd.
451 QuicAckFrame ack_frame;
452 ack_frame.largest_observed = 1;
453 ExpectUpdatedRtt(1);
454 EXPECT_CALL(*send_algorithm_, RevertRetransmissionTimeout());
455 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
457 // Since 2 was marked for retransmit, when 1 is acked, 2 is kept for RTT.
458 QuicPacketSequenceNumber unacked[] = { 2 };
459 VerifyUnackedPackets(unacked, arraysize(unacked));
460 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
461 VerifyRetransmittablePackets(NULL, 0);
463 // Verify that the retransmission alarm would not fire,
464 // since there is no retransmittable data outstanding.
465 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
468 TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckFirst) {
469 StrictMock<MockDebugDelegate> debug_delegate;
470 EXPECT_CALL(debug_delegate, OnSpuriousPacketRetransmition(
471 TLP_RETRANSMISSION, kDefaultLength)).Times(2);
472 manager_.set_debug_delegate(&debug_delegate);
474 SendDataPacket(1);
475 RetransmitAndSendPacket(1, 2);
476 RetransmitAndSendPacket(2, 3);
477 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
478 clock_.AdvanceTime(rtt);
480 // Ack 1 but not 2 or 3.
481 ExpectAck(1);
482 QuicAckFrame ack_frame;
483 ack_frame.largest_observed = 1;
484 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
486 // 2 and 3 remain unacked, but no packets have retransmittable data.
487 QuicPacketSequenceNumber unacked[] = { 2, 3 };
488 VerifyUnackedPackets(unacked, arraysize(unacked));
489 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
490 VerifyRetransmittablePackets(NULL, 0);
492 // Ensure packet 2 is lost when 4 is sent and 3 and 4 are acked.
493 SendDataPacket(4);
494 ack_frame.largest_observed = 4;
495 ack_frame.missing_packets.insert(2);
496 QuicPacketSequenceNumber acked[] = { 3, 4 };
497 ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0);
498 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
500 QuicPacketSequenceNumber unacked2[] = { 2 };
501 VerifyUnackedPackets(unacked2, arraysize(unacked2));
502 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
504 SendDataPacket(5);
505 ack_frame.largest_observed = 5;
506 ExpectAckAndLoss(true, 5, 2);
507 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
509 VerifyUnackedPackets(NULL, 0);
510 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
511 EXPECT_EQ(2u, stats_.packets_spuriously_retransmitted);
514 TEST_F(QuicSentPacketManagerTest, LoseButDontRetransmitRevivedPacket) {
515 SendDataPacket(1);
516 SendDataPacket(2);
517 SendFecPacket(3);
518 SendDataPacket(4);
520 // Ack 2 and 3, and mark 1 as revived.
521 QuicAckFrame ack_frame;
522 ack_frame.largest_observed = 3;
523 ack_frame.missing_packets.insert(1);
524 ack_frame.revived_packets.insert(1);
525 QuicPacketSequenceNumber acked[] = { 2, 3 };
526 ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0);
527 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
529 EXPECT_FALSE(manager_.HasPendingRetransmissions());
530 QuicPacketSequenceNumber unacked[] = { 1, 4 };
531 VerifyUnackedPackets(unacked, arraysize(unacked));
532 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
533 QuicPacketSequenceNumber retransmittable[] = { 4 };
534 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
536 // Ack the 4th packet and expect the 1st to be considered lost.
537 ack_frame.largest_observed = 4;
538 ExpectAckAndLoss(true, 4, 1);
539 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
541 EXPECT_FALSE(manager_.HasPendingRetransmissions());
542 VerifyRetransmittablePackets(NULL, 0);
545 TEST_F(QuicSentPacketManagerTest, MarkLostThenReviveAndDontRetransmitPacket) {
546 SendDataPacket(1);
547 SendDataPacket(2);
548 SendDataPacket(3);
549 SendDataPacket(4);
550 SendFecPacket(5);
552 // Ack 2, 3, and 4, and expect the 1st to be considered lost.
553 QuicAckFrame ack_frame;
554 ack_frame.largest_observed = 4;
555 ack_frame.missing_packets.insert(1);
556 QuicPacketSequenceNumber acked[] = { 2, 3, 4 };
557 QuicPacketSequenceNumber lost[] = { 1 };
558 ExpectAcksAndLosses(true, acked, arraysize(acked), lost, arraysize(lost));
559 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
561 EXPECT_TRUE(manager_.HasPendingRetransmissions());
562 QuicPacketSequenceNumber unacked[] = { 1, 5 };
563 VerifyUnackedPackets(unacked, arraysize(unacked));
564 QuicPacketSequenceNumber retransmittable[] = { 1 };
565 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
567 // Ack 5th packet (FEC) and revive 1st packet. 1st packet should now be
568 // removed from pending retransmissions map.
569 ack_frame.largest_observed = 5;
570 ack_frame.revived_packets.insert(1);
571 ExpectAck(5);
572 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
574 EXPECT_FALSE(manager_.HasPendingRetransmissions());
575 VerifyRetransmittablePackets(NULL, 0);
578 TEST_F(QuicSentPacketManagerTest, TruncatedAck) {
579 SendDataPacket(1);
580 RetransmitAndSendPacket(1, 2);
581 RetransmitAndSendPacket(2, 3);
582 RetransmitAndSendPacket(3, 4);
583 RetransmitAndSendPacket(4, 5);
585 // Truncated ack with 4 NACKs, so the first packet is lost.
586 QuicAckFrame ack_frame;
587 ack_frame.largest_observed = 4;
588 ack_frame.missing_packets.insert(1);
589 ack_frame.missing_packets.insert(2);
590 ack_frame.missing_packets.insert(3);
591 ack_frame.missing_packets.insert(4);
592 ack_frame.is_truncated = true;
594 QuicPacketSequenceNumber lost[] = { 1 };
595 ExpectAcksAndLosses(true, NULL, 0, lost, arraysize(lost));
596 manager_.OnIncomingAck(ack_frame, clock_.Now());
598 // High water mark will be raised.
599 QuicPacketSequenceNumber unacked[] = { 2, 3, 4, 5 };
600 VerifyUnackedPackets(unacked, arraysize(unacked));
601 QuicPacketSequenceNumber retransmittable[] = { 5 };
602 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
605 TEST_F(QuicSentPacketManagerTest, AckPreviousTransmissionThenTruncatedAck) {
606 SendDataPacket(1);
607 RetransmitAndSendPacket(1, 2);
608 RetransmitAndSendPacket(2, 3);
609 RetransmitAndSendPacket(3, 4);
610 SendDataPacket(5);
611 SendDataPacket(6);
612 SendDataPacket(7);
613 SendDataPacket(8);
614 SendDataPacket(9);
616 // Ack previous transmission
618 QuicAckFrame ack_frame;
619 ack_frame.largest_observed = 2;
620 ack_frame.missing_packets.insert(1);
621 ExpectAck(2);
622 manager_.OnIncomingAck(ack_frame, clock_.Now());
623 EXPECT_TRUE(manager_.IsUnacked(4));
626 // Truncated ack with 4 NACKs
628 QuicAckFrame ack_frame;
629 ack_frame.largest_observed = 6;
630 ack_frame.missing_packets.insert(3);
631 ack_frame.missing_packets.insert(4);
632 ack_frame.missing_packets.insert(5);
633 ack_frame.missing_packets.insert(6);
634 ack_frame.is_truncated = true;
635 ExpectAckAndLoss(true, 1, 3);
636 manager_.OnIncomingAck(ack_frame, clock_.Now());
639 // High water mark will be raised.
640 QuicPacketSequenceNumber unacked[] = { 4, 5, 6, 7, 8, 9 };
641 VerifyUnackedPackets(unacked, arraysize(unacked));
642 QuicPacketSequenceNumber retransmittable[] = { 5, 6, 7, 8, 9 };
643 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
646 TEST_F(QuicSentPacketManagerTest, GetLeastUnacked) {
647 EXPECT_EQ(1u, manager_.GetLeastUnacked());
650 TEST_F(QuicSentPacketManagerTest, GetLeastUnackedUnacked) {
651 SerializedPacket serialized_packet(CreateDataPacket(1));
653 manager_.OnSerializedPacket(serialized_packet);
654 EXPECT_EQ(1u, manager_.GetLeastUnacked());
657 TEST_F(QuicSentPacketManagerTest, GetLeastUnackedUnackedFec) {
658 SerializedPacket serialized_packet(CreateFecPacket(1));
660 manager_.OnSerializedPacket(serialized_packet);
661 EXPECT_EQ(1u, manager_.GetLeastUnacked());
664 TEST_F(QuicSentPacketManagerTest, GetLeastUnackedAndDiscard) {
665 VerifyUnackedPackets(NULL, 0);
667 SendFecPacket(1);
668 EXPECT_EQ(1u, manager_.GetLeastUnacked());
670 SendFecPacket(2);
671 EXPECT_EQ(1u, manager_.GetLeastUnacked());
673 SendFecPacket(3);
674 EXPECT_EQ(1u, manager_.GetLeastUnacked());
676 QuicPacketSequenceNumber unacked[] = { 1, 2, 3 };
677 VerifyUnackedPackets(unacked, arraysize(unacked));
678 VerifyRetransmittablePackets(NULL, 0);
680 // Ack 2, so there's an rtt update.
681 ExpectAck(2);
682 QuicAckFrame ack_frame;
683 ack_frame.largest_observed = 2;
684 ack_frame.missing_packets.insert(1);
685 manager_.OnIncomingAck(ack_frame, clock_.Now());
687 EXPECT_EQ(1u, manager_.GetLeastUnacked());
690 TEST_F(QuicSentPacketManagerTest, GetSentTime) {
691 VerifyUnackedPackets(NULL, 0);
693 SerializedPacket serialized_packet(CreateFecPacket(1));
694 manager_.OnSerializedPacket(serialized_packet);
695 EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 1, _, _))
696 .Times(1).WillOnce(Return(true));
697 manager_.OnPacketSent(1, QuicTime::Zero(), kDefaultLength, NOT_RETRANSMISSION,
698 NO_RETRANSMITTABLE_DATA);
700 SerializedPacket serialized_packet2(CreateFecPacket(2));
701 QuicTime sent_time = QuicTime::Zero().Add(QuicTime::Delta::FromSeconds(1));
702 manager_.OnSerializedPacket(serialized_packet2);
703 EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 2, _, _))
704 .Times(1).WillOnce(Return(true));
705 manager_.OnPacketSent(2, sent_time, kDefaultLength, NOT_RETRANSMISSION,
706 NO_RETRANSMITTABLE_DATA);
708 QuicPacketSequenceNumber unacked[] = { 1, 2 };
709 VerifyUnackedPackets(unacked, arraysize(unacked));
710 VerifyRetransmittablePackets(NULL, 0);
712 EXPECT_TRUE(manager_.HasUnackedPackets());
713 EXPECT_EQ(QuicTime::Zero(),
714 QuicSentPacketManagerPeer::GetSentTime(&manager_, 1));
715 EXPECT_EQ(sent_time, QuicSentPacketManagerPeer::GetSentTime(&manager_, 2));
718 TEST_F(QuicSentPacketManagerTest, AckAckAndUpdateRtt) {
719 SendDataPacket(1);
720 SendAckPacket(2);
722 // Now ack the ack and expect an RTT update.
723 QuicAckFrame ack_frame;
724 ack_frame.largest_observed = 2;
725 ack_frame.delta_time_largest_observed =
726 QuicTime::Delta::FromMilliseconds(5);
728 ExpectAck(1);
729 manager_.OnIncomingAck(ack_frame, clock_.Now());
731 SendAckPacket(3);
733 // Now ack the ack and expect only an RTT update.
734 ack_frame.largest_observed = 3;
735 ExpectUpdatedRtt(3);
736 manager_.OnIncomingAck(ack_frame, clock_.Now());
739 TEST_F(QuicSentPacketManagerTest, Rtt) {
740 QuicPacketSequenceNumber sequence_number = 1;
741 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(15);
742 SendDataPacket(sequence_number);
743 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
745 ExpectAck(sequence_number);
746 QuicAckFrame ack_frame;
747 ack_frame.largest_observed = sequence_number;
748 ack_frame.delta_time_largest_observed =
749 QuicTime::Delta::FromMilliseconds(5);
750 manager_.OnIncomingAck(ack_frame, clock_.Now());
751 EXPECT_EQ(expected_rtt,
752 QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt());
755 TEST_F(QuicSentPacketManagerTest, RttWithInvalidDelta) {
756 // Expect that the RTT is equal to the local time elapsed, since the
757 // delta_time_largest_observed is larger than the local time elapsed
758 // and is hence invalid.
759 QuicPacketSequenceNumber sequence_number = 1;
760 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10);
761 SendDataPacket(sequence_number);
762 clock_.AdvanceTime(expected_rtt);
764 ExpectAck(sequence_number);
765 QuicAckFrame ack_frame;
766 ack_frame.largest_observed = sequence_number;
767 ack_frame.delta_time_largest_observed =
768 QuicTime::Delta::FromMilliseconds(11);
769 manager_.OnIncomingAck(ack_frame, clock_.Now());
770 EXPECT_EQ(expected_rtt,
771 QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt());
774 TEST_F(QuicSentPacketManagerTest, RttWithInfiniteDelta) {
775 // Expect that the RTT is equal to the local time elapsed, since the
776 // delta_time_largest_observed is infinite, and is hence invalid.
777 QuicPacketSequenceNumber sequence_number = 1;
778 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10);
779 SendDataPacket(sequence_number);
780 clock_.AdvanceTime(expected_rtt);
782 ExpectAck(sequence_number);
783 QuicAckFrame ack_frame;
784 ack_frame.largest_observed = sequence_number;
785 ack_frame.delta_time_largest_observed = QuicTime::Delta::Infinite();
786 manager_.OnIncomingAck(ack_frame, clock_.Now());
787 EXPECT_EQ(expected_rtt,
788 QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt());
791 TEST_F(QuicSentPacketManagerTest, RttZeroDelta) {
792 // Expect that the RTT is the time between send and receive since the
793 // delta_time_largest_observed is zero.
794 QuicPacketSequenceNumber sequence_number = 1;
795 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10);
796 SendDataPacket(sequence_number);
797 clock_.AdvanceTime(expected_rtt);
799 ExpectAck(sequence_number);
800 QuicAckFrame ack_frame;
801 ack_frame.largest_observed = sequence_number;
802 ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero();
803 manager_.OnIncomingAck(ack_frame, clock_.Now());
804 EXPECT_EQ(expected_rtt,
805 QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt());
808 TEST_F(QuicSentPacketManagerTest, TailLossProbeTimeout) {
809 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
811 // Send 1 packet.
812 QuicPacketSequenceNumber sequence_number = 1;
813 SendDataPacket(sequence_number);
815 // The first tail loss probe retransmits 1 packet.
816 manager_.OnRetransmissionTimeout();
817 EXPECT_EQ(QuicTime::Delta::Zero(),
818 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
819 EXPECT_FALSE(manager_.HasPendingRetransmissions());
820 manager_.MaybeRetransmitTailLossProbe();
821 EXPECT_TRUE(manager_.HasPendingRetransmissions());
822 RetransmitNextPacket(2);
823 EXPECT_FALSE(manager_.HasPendingRetransmissions());
825 // The second tail loss probe retransmits 1 packet.
826 manager_.OnRetransmissionTimeout();
827 EXPECT_EQ(QuicTime::Delta::Zero(),
828 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
829 EXPECT_FALSE(manager_.HasPendingRetransmissions());
830 manager_.MaybeRetransmitTailLossProbe();
831 EXPECT_TRUE(manager_.HasPendingRetransmissions());
832 RetransmitNextPacket(3);
833 EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).WillOnce(Return(
834 QuicTime::Delta::Infinite()));
835 EXPECT_EQ(QuicTime::Delta::Infinite(),
836 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
837 EXPECT_FALSE(manager_.HasPendingRetransmissions());
839 // Ack the third and ensure the first two are still pending.
840 ExpectAck(3);
841 QuicAckFrame ack_frame;
842 ack_frame.largest_observed = 3;
843 ack_frame.missing_packets.insert(1);
844 ack_frame.missing_packets.insert(2);
845 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
847 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
849 // Acking two more packets will lose both of them due to nacks.
850 ack_frame.largest_observed = 5;
851 QuicPacketSequenceNumber lost[] = { 1, 2 };
852 ExpectAcksAndLosses(false, NULL, 0, lost, arraysize(lost));
853 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
855 EXPECT_FALSE(manager_.HasPendingRetransmissions());
856 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
857 EXPECT_EQ(2u, stats_.tlp_count);
858 EXPECT_EQ(0u, stats_.rto_count);
861 TEST_F(QuicSentPacketManagerTest, TailLossProbeThenRTO) {
862 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
864 // Send 100 packets.
865 const size_t kNumSentPackets = 100;
866 for (size_t i = 1; i <= kNumSentPackets; ++i) {
867 SendDataPacket(i);
870 // The first tail loss probe retransmits 1 packet.
871 manager_.OnRetransmissionTimeout();
872 EXPECT_EQ(QuicTime::Delta::Zero(),
873 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
874 EXPECT_FALSE(manager_.HasPendingRetransmissions());
875 manager_.MaybeRetransmitTailLossProbe();
876 EXPECT_TRUE(manager_.HasPendingRetransmissions());
877 RetransmitNextPacket(101);
878 EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).WillOnce(Return(
879 QuicTime::Delta::Infinite()));
880 EXPECT_EQ(QuicTime::Delta::Infinite(),
881 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
882 EXPECT_FALSE(manager_.HasPendingRetransmissions());
884 // The second tail loss probe retransmits 1 packet.
885 manager_.OnRetransmissionTimeout();
886 EXPECT_EQ(QuicTime::Delta::Zero(),
887 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
888 EXPECT_FALSE(manager_.HasPendingRetransmissions());
889 EXPECT_TRUE(manager_.MaybeRetransmitTailLossProbe());
890 EXPECT_TRUE(manager_.HasPendingRetransmissions());
891 RetransmitNextPacket(102);
892 EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).WillOnce(Return(
893 QuicTime::Delta::Infinite()));
894 EXPECT_EQ(QuicTime::Delta::Infinite(),
895 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
897 // Advance the time enough to ensure all packets are RTO'd.
898 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000));
900 // The final RTO abandons all of them.
901 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
902 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
903 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
904 .WillOnce(Return(2 * kDefaultTCPMSS));
905 manager_.OnRetransmissionTimeout();
906 EXPECT_TRUE(manager_.HasPendingRetransmissions());
907 EXPECT_EQ(2u, stats_.tlp_count);
908 EXPECT_EQ(1u, stats_.rto_count);
911 TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeout) {
912 // Send 2 crypto packets and 3 data packets.
913 const size_t kNumSentCryptoPackets = 2;
914 for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) {
915 SendCryptoPacket(i);
917 const size_t kNumSentDataPackets = 3;
918 for (size_t i = 1; i <= kNumSentDataPackets; ++i) {
919 SendDataPacket(kNumSentCryptoPackets + i);
921 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
923 // The first retransmits 2 packets.
924 manager_.OnRetransmissionTimeout();
925 EXPECT_EQ(QuicTime::Delta::Zero(),
926 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
927 RetransmitNextPacket(6);
928 RetransmitNextPacket(7);
929 EXPECT_FALSE(manager_.HasPendingRetransmissions());
930 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
932 // The second retransmits 2 packets.
933 manager_.OnRetransmissionTimeout();
934 EXPECT_EQ(QuicTime::Delta::Zero(),
935 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
936 RetransmitNextPacket(8);
937 RetransmitNextPacket(9);
938 EXPECT_FALSE(manager_.HasPendingRetransmissions());
939 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
941 // Now ack the two crypto packets and the speculatively encrypted request,
942 // and ensure the first four crypto packets get abandoned, but not lost.
943 QuicPacketSequenceNumber acked[] = { 3, 4, 5, 8, 9 };
944 ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0);
945 QuicAckFrame ack_frame;
946 ack_frame.largest_observed = 9;
947 ack_frame.missing_packets.insert(1);
948 ack_frame.missing_packets.insert(2);
949 ack_frame.missing_packets.insert(6);
950 ack_frame.missing_packets.insert(7);
951 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
953 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
956 TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeoutVersionNegotiation) {
957 // Send 2 crypto packets and 3 data packets.
958 const size_t kNumSentCryptoPackets = 2;
959 for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) {
960 SendCryptoPacket(i);
962 const size_t kNumSentDataPackets = 3;
963 for (size_t i = 1; i <= kNumSentDataPackets; ++i) {
964 SendDataPacket(kNumSentCryptoPackets + i);
966 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
968 // The first retransmission timeout retransmits 2 crypto packets.
969 manager_.OnRetransmissionTimeout();
970 RetransmitNextPacket(6);
971 RetransmitNextPacket(7);
972 EXPECT_FALSE(manager_.HasPendingRetransmissions());
973 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
975 // Now act like a version negotiation packet arrived, which would cause all
976 // unacked packets to be retransmitted.
977 manager_.RetransmitUnackedPackets(ALL_UNACKED_RETRANSMISSION);
979 // Ensure the first two pending packets are the crypto retransmits.
980 ASSERT_TRUE(manager_.HasPendingRetransmissions());
981 EXPECT_EQ(6u, manager_.NextPendingRetransmission().sequence_number);
982 RetransmitNextPacket(8);
983 EXPECT_EQ(7u, manager_.NextPendingRetransmission().sequence_number);
984 RetransmitNextPacket(9);
986 EXPECT_TRUE(manager_.HasPendingRetransmissions());
987 // Send 3 more data packets and ensure the least unacked is raised.
988 RetransmitNextPacket(10);
989 RetransmitNextPacket(11);
990 RetransmitNextPacket(12);
991 EXPECT_FALSE(manager_.HasPendingRetransmissions());
993 EXPECT_EQ(8u, manager_.GetLeastUnacked());
996 TEST_F(QuicSentPacketManagerTest, CryptoHandshakeSpuriousRetransmission) {
997 // Send 1 crypto packet.
998 SendCryptoPacket(1);
999 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1001 // Retransmit the crypto packet as 2.
1002 manager_.OnRetransmissionTimeout();
1003 RetransmitNextPacket(2);
1005 // Retransmit the crypto packet as 3.
1006 manager_.OnRetransmissionTimeout();
1007 RetransmitNextPacket(3);
1009 // Now ack the second crypto packet, and ensure the first gets removed, but
1010 // the third does not.
1011 ExpectUpdatedRtt(2);
1012 QuicAckFrame ack_frame;
1013 ack_frame.largest_observed = 2;
1014 ack_frame.missing_packets.insert(1);
1015 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
1017 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1018 QuicPacketSequenceNumber unacked[] = { 3 };
1019 VerifyUnackedPackets(unacked, arraysize(unacked));
1022 TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeoutUnsentDataPacket) {
1023 // Send 2 crypto packets and serialize 1 data packet.
1024 const size_t kNumSentCryptoPackets = 2;
1025 for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) {
1026 SendCryptoPacket(i);
1028 SerializedPacket packet(CreateDataPacket(3));
1029 manager_.OnSerializedPacket(packet);
1030 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1032 // Retransmit 2 crypto packets, but not the serialized packet.
1033 manager_.OnRetransmissionTimeout();
1034 RetransmitNextPacket(4);
1035 RetransmitNextPacket(5);
1036 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1037 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1040 TEST_F(QuicSentPacketManagerTest,
1041 CryptoHandshakeRetransmissionThenRetransmitAll) {
1042 // Send 1 crypto packet.
1043 SendCryptoPacket(1);
1044 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1046 // Retransmit the crypto packet as 2.
1047 manager_.OnRetransmissionTimeout();
1048 RetransmitNextPacket(2);
1050 // Now retransmit all the unacked packets, which occurs when there is a
1051 // version negotiation.
1052 manager_.RetransmitUnackedPackets(ALL_UNACKED_RETRANSMISSION);
1053 QuicPacketSequenceNumber unacked[] = { 1, 2 };
1054 VerifyUnackedPackets(unacked, arraysize(unacked));
1055 EXPECT_TRUE(manager_.HasPendingRetransmissions());
1056 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1057 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
1060 TEST_F(QuicSentPacketManagerTest,
1061 CryptoHandshakeRetransmissionThenNeuterAndAck) {
1062 // Send 1 crypto packet.
1063 SendCryptoPacket(1);
1064 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1066 // Retransmit the crypto packet as 2.
1067 manager_.OnRetransmissionTimeout();
1068 RetransmitNextPacket(2);
1070 // Retransmit the crypto packet as 3.
1071 manager_.OnRetransmissionTimeout();
1072 RetransmitNextPacket(3);
1074 // Now neuter all unacked unencrypted packets, which occurs when the
1075 // connection goes forward secure.
1076 manager_.NeuterUnencryptedPackets();
1077 QuicPacketSequenceNumber unacked[] = { 1, 2, 3};
1078 VerifyUnackedPackets(unacked, arraysize(unacked));
1079 VerifyRetransmittablePackets(NULL, 0);
1080 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1081 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1082 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
1084 // Ensure both packets get discarded when packet 2 is acked.
1085 QuicAckFrame ack_frame;
1086 ack_frame.largest_observed = 3;
1087 ack_frame.missing_packets.insert(1);
1088 ack_frame.missing_packets.insert(2);
1089 ExpectUpdatedRtt(3);
1090 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
1091 VerifyUnackedPackets(NULL, 0);
1092 VerifyRetransmittablePackets(NULL, 0);
1095 TEST_F(QuicSentPacketManagerTest, TailLossProbeTimeoutUnsentDataPacket) {
1096 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
1097 // Serialize two data packets and send the latter.
1098 SerializedPacket packet(CreateDataPacket(1));
1099 manager_.OnSerializedPacket(packet);
1100 SendDataPacket(2);
1101 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1102 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
1104 // Retransmit 1 unacked packets, but not the first serialized packet.
1105 manager_.OnRetransmissionTimeout();
1106 EXPECT_EQ(QuicTime::Delta::Zero(),
1107 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
1108 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1109 manager_.MaybeRetransmitTailLossProbe();
1110 EXPECT_TRUE(manager_.HasPendingRetransmissions());
1111 RetransmitNextPacket(3);
1112 EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).WillOnce(Return(
1113 QuicTime::Delta::Infinite()));
1114 EXPECT_EQ(QuicTime::Delta::Infinite(),
1115 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
1116 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1117 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1118 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
1121 TEST_F(QuicSentPacketManagerTest, ResetRecentMinRTTWithEmptyWindow) {
1122 QuicTime::Delta min_rtt = QuicTime::Delta::FromMilliseconds(50);
1123 QuicSentPacketManagerPeer::GetRttStats(&manager_)->UpdateRtt(
1124 min_rtt, QuicTime::Delta::Zero(), QuicTime::Zero());
1125 EXPECT_EQ(min_rtt,
1126 QuicSentPacketManagerPeer::GetRttStats(&manager_)->min_rtt());
1127 EXPECT_EQ(min_rtt,
1128 QuicSentPacketManagerPeer::GetRttStats(
1129 &manager_)->recent_min_rtt());
1131 // Send two packets with no prior bytes in flight.
1132 SendDataPacket(1);
1133 SendDataPacket(2);
1135 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(100));
1136 // Ack two packets with 100ms RTT observations.
1137 QuicAckFrame ack_frame;
1138 ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero();
1139 ack_frame.largest_observed = 1;
1140 ExpectAck(1);
1141 manager_.OnIncomingAck(ack_frame, clock_.Now());
1143 // First ack does not change recent min rtt.
1144 EXPECT_EQ(min_rtt,
1145 QuicSentPacketManagerPeer::GetRttStats(
1146 &manager_)->recent_min_rtt());
1148 ack_frame.largest_observed = 2;
1149 ExpectAck(2);
1150 manager_.OnIncomingAck(ack_frame, clock_.Now());
1152 EXPECT_EQ(min_rtt,
1153 QuicSentPacketManagerPeer::GetRttStats(&manager_)->min_rtt());
1154 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100),
1155 QuicSentPacketManagerPeer::GetRttStats(
1156 &manager_)->recent_min_rtt());
1159 TEST_F(QuicSentPacketManagerTest, RetransmissionTimeout) {
1160 // Send 100 packets and then ensure all are abandoned when the RTO fires.
1161 const size_t kNumSentPackets = 100;
1162 for (size_t i = 1; i <= kNumSentPackets; ++i) {
1163 SendDataPacket(i);
1166 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
1167 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
1168 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
1169 .WillOnce(Return(2 * kDefaultTCPMSS));
1170 EXPECT_FALSE(manager_.MaybeRetransmitTailLossProbe());
1171 manager_.OnRetransmissionTimeout();
1174 TEST_F(QuicSentPacketManagerTest, GetTransmissionTime) {
1175 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
1178 TEST_F(QuicSentPacketManagerTest, GetTransmissionTimeCryptoHandshake) {
1179 SendCryptoPacket(1);
1181 // Check the min.
1182 QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt_us(
1183 1 * base::Time::kMicrosecondsPerMillisecond);
1184 EXPECT_EQ(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(10)),
1185 manager_.GetRetransmissionTime());
1187 // Test with a standard smoothed RTT.
1188 QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt_us(
1189 100 * base::Time::kMicrosecondsPerMillisecond);
1191 QuicTime::Delta srtt = manager_.GetRttStats()->SmoothedRtt();
1192 QuicTime expected_time = clock_.Now().Add(srtt.Multiply(1.5));
1193 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1195 // Retransmit the packet by invoking the retransmission timeout.
1196 clock_.AdvanceTime(srtt.Multiply(1.5));
1197 manager_.OnRetransmissionTimeout();
1198 RetransmitNextPacket(2);
1200 // The retransmission time should now be twice as far in the future.
1201 expected_time = clock_.Now().Add(srtt.Multiply(2).Multiply(1.5));
1202 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1205 TEST_F(QuicSentPacketManagerTest, GetTransmissionTimeTailLossProbe) {
1206 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
1207 SendDataPacket(1);
1208 SendDataPacket(2);
1210 // Check the min.
1211 QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt_us(
1212 1 * base::Time::kMicrosecondsPerMillisecond);
1213 EXPECT_EQ(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(10)),
1214 manager_.GetRetransmissionTime());
1216 // Test with a standard smoothed RTT.
1217 QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt_us(
1218 100 * base::Time::kMicrosecondsPerMillisecond);
1219 QuicTime::Delta srtt = manager_.GetRttStats()->SmoothedRtt();
1220 QuicTime::Delta expected_tlp_delay = srtt.Multiply(2);
1221 QuicTime expected_time = clock_.Now().Add(expected_tlp_delay);
1222 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1224 // Retransmit the packet by invoking the retransmission timeout.
1225 clock_.AdvanceTime(expected_tlp_delay);
1226 manager_.OnRetransmissionTimeout();
1227 EXPECT_EQ(QuicTime::Delta::Zero(),
1228 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
1229 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1230 EXPECT_TRUE(manager_.MaybeRetransmitTailLossProbe());
1231 EXPECT_TRUE(manager_.HasPendingRetransmissions());
1232 RetransmitNextPacket(3);
1233 EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).WillOnce(Return(
1234 QuicTime::Delta::Infinite()));
1235 EXPECT_EQ(QuicTime::Delta::Infinite(),
1236 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
1237 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1239 expected_time = clock_.Now().Add(expected_tlp_delay);
1240 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1243 TEST_F(QuicSentPacketManagerTest, GetTransmissionTimeRTO) {
1244 QuicSentPacketManagerPeer::GetRttStats(&manager_)->UpdateRtt(
1245 QuicTime::Delta::FromMilliseconds(100),
1246 QuicTime::Delta::Zero(),
1247 QuicTime::Zero());
1249 SendDataPacket(1);
1250 SendDataPacket(2);
1251 SendDataPacket(3);
1252 SendDataPacket(4);
1254 QuicTime::Delta expected_rto_delay = QuicTime::Delta::FromMilliseconds(500);
1255 EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
1256 .WillRepeatedly(Return(expected_rto_delay));
1257 QuicTime expected_time = clock_.Now().Add(expected_rto_delay);
1258 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1260 // Retransmit the packet by invoking the retransmission timeout.
1261 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
1262 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
1263 .WillOnce(Return(2 * kDefaultTCPMSS));
1264 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
1265 clock_.AdvanceTime(expected_rto_delay);
1266 manager_.OnRetransmissionTimeout();
1267 EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1268 RetransmitNextPacket(5);
1269 RetransmitNextPacket(6);
1270 EXPECT_EQ(2 * kDefaultLength,
1271 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1272 EXPECT_TRUE(manager_.HasPendingRetransmissions());
1274 // The delay should double the second time.
1275 expected_time = clock_.Now().Add(expected_rto_delay).Add(expected_rto_delay);
1276 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1278 // Ack a packet and ensure the RTO goes back to the original value.
1279 QuicAckFrame ack_frame;
1280 ack_frame.largest_observed = 2;
1281 ack_frame.missing_packets.insert(1);
1282 ExpectUpdatedRtt(2);
1283 EXPECT_CALL(*send_algorithm_, RevertRetransmissionTimeout());
1284 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
1285 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1286 EXPECT_EQ(4 * kDefaultLength,
1287 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1289 // Wait 2RTTs from now for the RTO, since it's the max of the RTO time
1290 // and the TLP time. In production, there would always be two TLP's first.
1291 expected_time = clock_.Now().Add(QuicTime::Delta::FromMilliseconds(200));
1292 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1295 TEST_F(QuicSentPacketManagerTest, GetTransmissionDelayMin) {
1296 SendDataPacket(1);
1297 EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
1298 .WillRepeatedly(Return(QuicTime::Delta::FromMilliseconds(1)));
1299 QuicTime::Delta delay = QuicTime::Delta::FromMilliseconds(200);
1301 // If the delay is smaller than the min, ensure it exponentially backs off
1302 // from the min.
1303 for (int i = 0; i < 5; ++i) {
1304 EXPECT_EQ(delay,
1305 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
1306 delay = delay.Add(delay);
1307 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
1308 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
1309 .WillOnce(Return(2 * kDefaultTCPMSS));
1310 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
1311 manager_.OnRetransmissionTimeout();
1312 RetransmitNextPacket(i + 2);
1316 TEST_F(QuicSentPacketManagerTest, GetTransmissionDelayMax) {
1317 EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
1318 .WillOnce(Return(QuicTime::Delta::FromSeconds(500)));
1320 EXPECT_EQ(QuicTime::Delta::FromSeconds(60),
1321 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
1324 TEST_F(QuicSentPacketManagerTest, GetTransmissionDelay) {
1325 SendDataPacket(1);
1326 QuicTime::Delta delay = QuicTime::Delta::FromMilliseconds(500);
1327 EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
1328 .WillRepeatedly(Return(delay));
1330 // Delay should back off exponentially.
1331 for (int i = 0; i < 5; ++i) {
1332 EXPECT_EQ(delay,
1333 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
1334 delay = delay.Add(delay);
1335 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
1336 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
1337 .WillOnce(Return(2 * kDefaultTCPMSS));
1338 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
1339 manager_.OnRetransmissionTimeout();
1340 RetransmitNextPacket(i + 2);
1344 TEST_F(QuicSentPacketManagerTest, GetLossDelay) {
1345 MockLossAlgorithm* loss_algorithm = new MockLossAlgorithm();
1346 QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm);
1348 EXPECT_CALL(*loss_algorithm, GetLossTimeout())
1349 .WillRepeatedly(Return(QuicTime::Zero()));
1350 SendDataPacket(1);
1351 SendDataPacket(2);
1353 // Handle an ack which causes the loss algorithm to be evaluated and
1354 // set the loss timeout.
1355 ExpectAck(2);
1356 EXPECT_CALL(*loss_algorithm, DetectLostPackets(_, _, _, _))
1357 .WillOnce(Return(SequenceNumberSet()));
1358 QuicAckFrame ack_frame;
1359 ack_frame.largest_observed = 2;
1360 ack_frame.missing_packets.insert(1);
1361 manager_.OnIncomingAck(ack_frame, clock_.Now());
1363 QuicTime timeout(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(10)));
1364 EXPECT_CALL(*loss_algorithm, GetLossTimeout())
1365 .WillRepeatedly(Return(timeout));
1366 EXPECT_EQ(timeout, manager_.GetRetransmissionTime());
1368 // Fire the retransmission timeout and ensure the loss detection algorithm
1369 // is invoked.
1370 EXPECT_CALL(*loss_algorithm, DetectLostPackets(_, _, _, _))
1371 .WillOnce(Return(SequenceNumberSet()));
1372 manager_.OnRetransmissionTimeout();
1375 TEST_F(QuicSentPacketManagerTest, NegotiateTimeLossDetection) {
1376 EXPECT_EQ(kNack,
1377 QuicSentPacketManagerPeer::GetLossAlgorithm(
1378 &manager_)->GetLossDetectionType());
1380 QuicConfig config;
1381 QuicConfigPeer::SetReceivedLossDetection(&config, kTIME);
1382 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1383 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
1384 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
1385 .WillOnce(Return(100 * kDefaultTCPMSS));
1386 manager_.SetFromConfig(config);
1388 EXPECT_EQ(kTime,
1389 QuicSentPacketManagerPeer::GetLossAlgorithm(
1390 &manager_)->GetLossDetectionType());
1393 TEST_F(QuicSentPacketManagerTest, NegotiateTimeLossDetectionFromOptions) {
1394 EXPECT_EQ(kNack,
1395 QuicSentPacketManagerPeer::GetLossAlgorithm(
1396 &manager_)->GetLossDetectionType());
1398 QuicConfig config;
1399 QuicTagVector options;
1400 options.push_back(kTIME);
1401 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1402 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1403 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
1404 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
1405 .WillOnce(Return(100 * kDefaultTCPMSS));
1406 manager_.SetFromConfig(config);
1408 EXPECT_EQ(kTime,
1409 QuicSentPacketManagerPeer::GetLossAlgorithm(
1410 &manager_)->GetLossDetectionType());
1413 TEST_F(QuicSentPacketManagerTest, NegotiateCongestionControlFromOptions) {
1414 QuicConfig config;
1415 QuicTagVector options;
1417 options.push_back(kRENO);
1418 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1419 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
1420 manager_.SetFromConfig(config);
1421 EXPECT_EQ(kReno, QuicSentPacketManagerPeer::GetCongestionControlAlgorithm(
1422 manager_)->GetCongestionControlType());
1424 // TODO(rtenneti): Enable the following code after BBR code is checked in.
1425 #if 0
1426 options.clear();
1427 options.push_back(kTBBR);
1428 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1429 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
1430 manager_.SetFromConfig(config);
1431 EXPECT_EQ(kBBR, QuicSentPacketManagerPeer::GetCongestionControlAlgorithm(
1432 manager_)->GetCongestionControlType());
1433 #endif
1436 TEST_F(QuicSentPacketManagerTest, NegotiatePacingFromOptions) {
1437 EXPECT_FALSE(manager_.using_pacing());
1439 QuicConfig config;
1440 QuicTagVector options;
1441 options.push_back(kPACE);
1442 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1443 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
1444 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
1445 .WillOnce(Return(100 * kDefaultTCPMSS));
1446 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1447 manager_.SetFromConfig(config);
1449 EXPECT_TRUE(manager_.using_pacing());
1452 TEST_F(QuicSentPacketManagerTest, UseInitialRoundTripTimeToSend) {
1453 uint32 initial_rtt_us = 325000;
1454 EXPECT_NE(initial_rtt_us,
1455 manager_.GetRttStats()->SmoothedRtt().ToMicroseconds());
1457 QuicConfig config;
1458 config.SetInitialRoundTripTimeUsToSend(initial_rtt_us);
1459 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1460 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
1461 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
1462 .WillOnce(Return(100 * kDefaultTCPMSS));
1463 manager_.SetFromConfig(config);
1465 EXPECT_EQ(initial_rtt_us,
1466 manager_.GetRttStats()->SmoothedRtt().ToMicroseconds());
1469 } // namespace
1470 } // namespace test
1471 } // namespace net