blob: 4624a8ae944775118550ea8dab1a77d0af440e24 [file] [log] [blame]
QUICHE teama6ef0a62019-03-07 20:34:33 -05001// 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.
4
5#include "net/third_party/quiche/src/quic/core/quic_sent_packet_manager.h"
6
7#include <memory>
8
9#include "net/third_party/quiche/src/quic/core/quic_pending_retransmission.h"
10#include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h"
11#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
12#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
13#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
14#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
15#include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
16#include "net/third_party/quiche/src/quic/test_tools/quic_sent_packet_manager_peer.h"
17#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
18
19using testing::_;
20using testing::AnyNumber;
21using testing::Invoke;
22using testing::InvokeWithoutArgs;
23using testing::IsEmpty;
24using testing::Not;
25using testing::Pointwise;
26using testing::Return;
27using testing::StrictMock;
28using testing::WithArgs;
29
30namespace quic {
31namespace test {
32namespace {
33// Default packet length.
34const uint32_t kDefaultLength = 1000;
35
36// Stream ID for data sent in CreatePacket().
37const QuicStreamId kStreamId = 7;
38
39// Matcher to check that the packet number matches the second argument.
40MATCHER(PacketNumberEq, "") {
41 return ::testing::get<0>(arg).packet_number ==
42 QuicPacketNumber(::testing::get<1>(arg));
43}
44
45class MockDebugDelegate : public QuicSentPacketManager::DebugDelegate {
46 public:
47 MOCK_METHOD2(OnSpuriousPacketRetransmission,
48 void(TransmissionType transmission_type,
49 QuicByteCount byte_size));
50 MOCK_METHOD3(OnPacketLoss,
51 void(QuicPacketNumber lost_packet_number,
52 TransmissionType transmission_type,
53 QuicTime detection_time));
54};
55
56class QuicSentPacketManagerTest : public QuicTestWithParam<bool> {
57 public:
58 void RetransmitCryptoPacket(uint64_t packet_number) {
59 EXPECT_CALL(
60 *send_algorithm_,
61 OnPacketSent(_, BytesInFlight(), QuicPacketNumber(packet_number),
62 kDefaultLength, HAS_RETRANSMITTABLE_DATA));
63 SerializedPacket packet(CreatePacket(packet_number, false));
64 packet.retransmittable_frames.push_back(
65 QuicFrame(QuicStreamFrame(1, false, 0, QuicStringPiece())));
66 packet.has_crypto_handshake = IS_HANDSHAKE;
67 manager_.OnPacketSent(&packet, QuicPacketNumber(), clock_.Now(),
68 HANDSHAKE_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
69 }
70
71 void RetransmitDataPacket(uint64_t packet_number, TransmissionType type) {
72 EXPECT_CALL(
73 *send_algorithm_,
74 OnPacketSent(_, BytesInFlight(), QuicPacketNumber(packet_number),
75 kDefaultLength, HAS_RETRANSMITTABLE_DATA));
76 SerializedPacket packet(CreatePacket(packet_number, true));
77 manager_.OnPacketSent(&packet, QuicPacketNumber(), clock_.Now(), type,
78 HAS_RETRANSMITTABLE_DATA);
79 }
80
81 protected:
82 QuicSentPacketManagerTest()
83 : manager_(Perspective::IS_SERVER, &clock_, &stats_, kCubicBytes, kNack),
84 send_algorithm_(new StrictMock<MockSendAlgorithm>),
85 network_change_visitor_(new StrictMock<MockNetworkChangeVisitor>) {
86 QuicSentPacketManagerPeer::SetSendAlgorithm(&manager_, send_algorithm_);
87 // Disable tail loss probes for most tests.
88 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 0);
89 // Advance the time 1s so the send times are never QuicTime::Zero.
90 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000));
91 manager_.SetNetworkChangeVisitor(network_change_visitor_.get());
92 manager_.SetSessionNotifier(&notifier_);
93 manager_.SetSessionDecideWhatToWrite(GetParam());
94
95 EXPECT_CALL(*send_algorithm_, HasReliableBandwidthEstimate())
96 .Times(AnyNumber());
97 EXPECT_CALL(*send_algorithm_, BandwidthEstimate())
98 .Times(AnyNumber())
99 .WillRepeatedly(Return(QuicBandwidth::Zero()));
100 EXPECT_CALL(*send_algorithm_, InSlowStart()).Times(AnyNumber());
101 EXPECT_CALL(*send_algorithm_, InRecovery()).Times(AnyNumber());
102 EXPECT_CALL(*network_change_visitor_, OnPathMtuIncreased(1000))
103 .Times(AnyNumber());
104 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(true));
105 EXPECT_CALL(notifier_, HasUnackedCryptoData())
106 .WillRepeatedly(Return(false));
107 EXPECT_CALL(notifier_, OnStreamFrameRetransmitted(_)).Times(AnyNumber());
108 EXPECT_CALL(notifier_, OnFrameAcked(_, _)).WillRepeatedly(Return(true));
109 }
110
111 ~QuicSentPacketManagerTest() override {}
112
113 QuicByteCount BytesInFlight() {
114 return QuicSentPacketManagerPeer::GetBytesInFlight(&manager_);
115 }
116 void VerifyUnackedPackets(uint64_t* packets, size_t num_packets) {
117 if (num_packets == 0) {
118 EXPECT_TRUE(manager_.unacked_packets().empty());
119 EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetNumRetransmittablePackets(
120 &manager_));
121 return;
122 }
123
124 EXPECT_FALSE(manager_.unacked_packets().empty());
125 EXPECT_EQ(QuicPacketNumber(packets[0]), manager_.GetLeastUnacked());
126 for (size_t i = 0; i < num_packets; ++i) {
127 EXPECT_TRUE(QuicSentPacketManagerPeer::IsUnacked(&manager_, packets[i]))
128 << packets[i];
129 }
130 }
131
132 void VerifyRetransmittablePackets(uint64_t* packets, size_t num_packets) {
133 EXPECT_EQ(
134 num_packets,
135 QuicSentPacketManagerPeer::GetNumRetransmittablePackets(&manager_));
136 for (size_t i = 0; i < num_packets; ++i) {
137 EXPECT_TRUE(QuicSentPacketManagerPeer::HasRetransmittableFrames(
138 &manager_, packets[i]))
139 << " packets[" << i << "]:" << packets[i];
140 }
141 }
142
143 void ExpectAck(uint64_t largest_observed) {
144 EXPECT_CALL(
145 *send_algorithm_,
146 // Ensure the AckedPacketVector argument contains largest_observed.
147 OnCongestionEvent(true, _, _,
148 Pointwise(PacketNumberEq(), {largest_observed}),
149 IsEmpty()));
150 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
151 }
152
153 void ExpectUpdatedRtt(uint64_t largest_observed) {
154 EXPECT_CALL(*send_algorithm_,
155 OnCongestionEvent(true, _, _, IsEmpty(), IsEmpty()));
156 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
157 }
158
159 void ExpectAckAndLoss(bool rtt_updated,
160 uint64_t largest_observed,
161 uint64_t lost_packet) {
162 EXPECT_CALL(
163 *send_algorithm_,
164 OnCongestionEvent(rtt_updated, _, _,
165 Pointwise(PacketNumberEq(), {largest_observed}),
166 Pointwise(PacketNumberEq(), {lost_packet})));
167 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
168 }
169
170 // |packets_acked| and |packets_lost| should be in packet number order.
171 void ExpectAcksAndLosses(bool rtt_updated,
172 uint64_t* packets_acked,
173 size_t num_packets_acked,
174 uint64_t* packets_lost,
175 size_t num_packets_lost) {
176 std::vector<QuicPacketNumber> ack_vector;
177 for (size_t i = 0; i < num_packets_acked; ++i) {
178 ack_vector.push_back(QuicPacketNumber(packets_acked[i]));
179 }
180 std::vector<QuicPacketNumber> lost_vector;
181 for (size_t i = 0; i < num_packets_lost; ++i) {
182 lost_vector.push_back(QuicPacketNumber(packets_lost[i]));
183 }
184 EXPECT_CALL(*send_algorithm_,
185 OnCongestionEvent(rtt_updated, _, _,
186 Pointwise(PacketNumberEq(), ack_vector),
187 Pointwise(PacketNumberEq(), lost_vector)));
188 EXPECT_CALL(*network_change_visitor_, OnCongestionChange())
189 .Times(AnyNumber());
190 }
191
192 void RetransmitAndSendPacket(uint64_t old_packet_number,
193 uint64_t new_packet_number) {
194 RetransmitAndSendPacket(old_packet_number, new_packet_number,
195 TLP_RETRANSMISSION);
196 }
197
198 void RetransmitAndSendPacket(uint64_t old_packet_number,
199 uint64_t new_packet_number,
200 TransmissionType transmission_type) {
201 bool is_lost = false;
202 if (manager_.session_decides_what_to_write()) {
203 if (transmission_type == HANDSHAKE_RETRANSMISSION ||
204 transmission_type == TLP_RETRANSMISSION ||
205 transmission_type == RTO_RETRANSMISSION ||
206 transmission_type == PROBING_RETRANSMISSION) {
207 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
208 .WillOnce(WithArgs<1>(
209 Invoke([this, new_packet_number](TransmissionType type) {
210 RetransmitDataPacket(new_packet_number, type);
211 })));
212 } else {
213 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(1);
214 is_lost = true;
215 }
216 }
217 QuicSentPacketManagerPeer::MarkForRetransmission(
218 &manager_, old_packet_number, transmission_type);
219 if (manager_.session_decides_what_to_write()) {
220 if (!is_lost) {
221 return;
222 }
223 EXPECT_CALL(
224 *send_algorithm_,
225 OnPacketSent(_, BytesInFlight(), QuicPacketNumber(new_packet_number),
226 kDefaultLength, HAS_RETRANSMITTABLE_DATA));
227 SerializedPacket packet(CreatePacket(new_packet_number, true));
228 manager_.OnPacketSent(&packet, QuicPacketNumber(), clock_.Now(),
229 transmission_type, HAS_RETRANSMITTABLE_DATA);
230 return;
231 }
232 EXPECT_TRUE(manager_.HasPendingRetransmissions());
233 QuicPendingRetransmission next_retransmission =
234 manager_.NextPendingRetransmission();
235 EXPECT_EQ(QuicPacketNumber(old_packet_number),
236 next_retransmission.packet_number);
237 EXPECT_EQ(transmission_type, next_retransmission.transmission_type);
238
239 EXPECT_CALL(
240 *send_algorithm_,
241 OnPacketSent(_, BytesInFlight(), QuicPacketNumber(new_packet_number),
242 kDefaultLength, HAS_RETRANSMITTABLE_DATA));
243 SerializedPacket packet(CreatePacket(new_packet_number, false));
244 manager_.OnPacketSent(&packet, QuicPacketNumber(old_packet_number),
245 clock_.Now(), transmission_type,
246 HAS_RETRANSMITTABLE_DATA);
247 EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(&manager_,
248 new_packet_number));
249 }
250
251 SerializedPacket CreateDataPacket(uint64_t packet_number) {
252 return CreatePacket(packet_number, true);
253 }
254
255 SerializedPacket CreatePacket(uint64_t packet_number, bool retransmittable) {
256 SerializedPacket packet(QuicPacketNumber(packet_number),
257 PACKET_4BYTE_PACKET_NUMBER, nullptr, kDefaultLength,
258 false, false);
259 if (retransmittable) {
260 packet.retransmittable_frames.push_back(
261 QuicFrame(QuicStreamFrame(kStreamId, false, 0, QuicStringPiece())));
262 }
263 return packet;
264 }
265
266 void SendDataPacket(uint64_t packet_number) {
QUICHE teamc279cec2019-03-22 06:51:48 -0700267 SendDataPacket(packet_number, ENCRYPTION_INITIAL);
268 }
269
270 void SendDataPacket(uint64_t packet_number,
271 EncryptionLevel encryption_level) {
QUICHE teama6ef0a62019-03-07 20:34:33 -0500272 EXPECT_CALL(*send_algorithm_,
273 OnPacketSent(_, BytesInFlight(),
274 QuicPacketNumber(packet_number), _, _));
275 SerializedPacket packet(CreateDataPacket(packet_number));
QUICHE teamc279cec2019-03-22 06:51:48 -0700276 packet.encryption_level = encryption_level;
QUICHE teama6ef0a62019-03-07 20:34:33 -0500277 manager_.OnPacketSent(&packet, QuicPacketNumber(), clock_.Now(),
278 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
279 }
280
281 void SendCryptoPacket(uint64_t packet_number) {
282 EXPECT_CALL(
283 *send_algorithm_,
284 OnPacketSent(_, BytesInFlight(), QuicPacketNumber(packet_number),
285 kDefaultLength, HAS_RETRANSMITTABLE_DATA));
286 SerializedPacket packet(CreatePacket(packet_number, false));
287 packet.retransmittable_frames.push_back(
288 QuicFrame(QuicStreamFrame(1, false, 0, QuicStringPiece())));
289 packet.has_crypto_handshake = IS_HANDSHAKE;
290 manager_.OnPacketSent(&packet, QuicPacketNumber(), clock_.Now(),
291 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
292 if (manager_.session_decides_what_to_write()) {
293 EXPECT_CALL(notifier_, HasUnackedCryptoData())
294 .WillRepeatedly(Return(true));
295 }
296 }
297
298 void SendAckPacket(uint64_t packet_number, uint64_t largest_acked) {
299 EXPECT_CALL(
300 *send_algorithm_,
301 OnPacketSent(_, BytesInFlight(), QuicPacketNumber(packet_number),
302 kDefaultLength, NO_RETRANSMITTABLE_DATA));
303 SerializedPacket packet(CreatePacket(packet_number, false));
304 packet.largest_acked = QuicPacketNumber(largest_acked);
305 manager_.OnPacketSent(&packet, QuicPacketNumber(), clock_.Now(),
306 NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA);
307 }
308
309 // Based on QuicConnection's WritePendingRetransmissions.
310 void RetransmitNextPacket(uint64_t retransmission_packet_number) {
311 EXPECT_TRUE(manager_.HasPendingRetransmissions());
312 EXPECT_CALL(
313 *send_algorithm_,
314 OnPacketSent(_, _, QuicPacketNumber(retransmission_packet_number),
315 kDefaultLength, HAS_RETRANSMITTABLE_DATA));
316 const QuicPendingRetransmission pending =
317 manager_.NextPendingRetransmission();
318 SerializedPacket packet(CreatePacket(retransmission_packet_number, false));
319 manager_.OnPacketSent(&packet, pending.packet_number, clock_.Now(),
320 pending.transmission_type, HAS_RETRANSMITTABLE_DATA);
321 }
322
323 QuicSentPacketManager manager_;
324 MockClock clock_;
325 QuicConnectionStats stats_;
326 MockSendAlgorithm* send_algorithm_;
327 std::unique_ptr<MockNetworkChangeVisitor> network_change_visitor_;
328 StrictMock<MockSessionNotifier> notifier_;
329};
330
331INSTANTIATE_TEST_SUITE_P(Tests, QuicSentPacketManagerTest, testing::Bool());
332
333TEST_P(QuicSentPacketManagerTest, IsUnacked) {
334 VerifyUnackedPackets(nullptr, 0);
335 SendDataPacket(1);
336
337 uint64_t unacked[] = {1};
338 VerifyUnackedPackets(unacked, QUIC_ARRAYSIZE(unacked));
339 uint64_t retransmittable[] = {1};
340 VerifyRetransmittablePackets(retransmittable,
341 QUIC_ARRAYSIZE(retransmittable));
342}
343
344TEST_P(QuicSentPacketManagerTest, IsUnAckedRetransmit) {
345 SendDataPacket(1);
346 RetransmitAndSendPacket(1, 2);
347
348 EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(&manager_, 2));
349 uint64_t unacked[] = {1, 2};
350 VerifyUnackedPackets(unacked, QUIC_ARRAYSIZE(unacked));
351 std::vector<uint64_t> retransmittable;
352 if (manager_.session_decides_what_to_write()) {
353 retransmittable = {1, 2};
354 } else {
355 retransmittable = {2};
356 }
357 VerifyRetransmittablePackets(&retransmittable[0], retransmittable.size());
358}
359
360TEST_P(QuicSentPacketManagerTest, RetransmitThenAck) {
361 SendDataPacket(1);
362 RetransmitAndSendPacket(1, 2);
363
364 // Ack 2 but not 1.
365 ExpectAck(2);
366 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
367 clock_.Now());
368 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(3));
369 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
370 if (manager_.session_decides_what_to_write()) {
371 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
372 }
373 // Packet 1 is unacked, pending, but not retransmittable.
374 uint64_t unacked[] = {1};
375 VerifyUnackedPackets(unacked, QUIC_ARRAYSIZE(unacked));
376 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
377 VerifyRetransmittablePackets(nullptr, 0);
378}
379
380TEST_P(QuicSentPacketManagerTest, RetransmitThenAckBeforeSend) {
381 SendDataPacket(1);
382 if (manager_.session_decides_what_to_write()) {
383 if (manager_.session_decides_what_to_write()) {
384 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
385 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
386 RetransmitDataPacket(2, type);
387 })));
388 }
389 }
390 QuicSentPacketManagerPeer::MarkForRetransmission(&manager_, 1,
391 TLP_RETRANSMISSION);
392 if (!manager_.session_decides_what_to_write()) {
393 EXPECT_TRUE(manager_.HasPendingRetransmissions());
394 }
395 // Ack 1.
396 ExpectAck(1);
397 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
398 clock_.Now());
399 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
400 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
401
402 // There should no longer be a pending retransmission.
403 EXPECT_FALSE(manager_.HasPendingRetransmissions());
404
405 if (manager_.session_decides_what_to_write()) {
406 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
407 uint64_t unacked[] = {2};
408 VerifyUnackedPackets(unacked, QUIC_ARRAYSIZE(unacked));
409 // We do not know packet 2 is a spurious retransmission until it gets acked.
410 } else {
411 // No unacked packets remain.
412 VerifyUnackedPackets(nullptr, 0);
413 }
414 VerifyRetransmittablePackets(nullptr, 0);
415 EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted);
416}
417
418TEST_P(QuicSentPacketManagerTest, RetransmitThenStopRetransmittingBeforeSend) {
419 SendDataPacket(1);
420 if (manager_.session_decides_what_to_write()) {
421 EXPECT_CALL(notifier_, RetransmitFrames(_, _));
422 }
423 QuicSentPacketManagerPeer::MarkForRetransmission(&manager_, 1,
424 TLP_RETRANSMISSION);
425 if (!manager_.session_decides_what_to_write()) {
426 EXPECT_TRUE(manager_.HasPendingRetransmissions());
427 }
428
429 manager_.CancelRetransmissionsForStream(kStreamId);
430 if (manager_.session_decides_what_to_write()) {
431 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
432 }
433
434 // There should no longer be a pending retransmission.
435 EXPECT_FALSE(manager_.HasPendingRetransmissions());
436
437 uint64_t unacked[] = {1};
438 VerifyUnackedPackets(unacked, QUIC_ARRAYSIZE(unacked));
439 VerifyRetransmittablePackets(nullptr, 0);
440 EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted);
441}
442
443TEST_P(QuicSentPacketManagerTest, RetransmitThenAckPrevious) {
444 SendDataPacket(1);
445 RetransmitAndSendPacket(1, 2);
446 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
447 clock_.AdvanceTime(rtt);
448
449 // Ack 1 but not 2.
450 ExpectAck(1);
451 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
452 clock_.Now());
453 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
454 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
455 if (manager_.session_decides_what_to_write()) {
456 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
457 }
458 // 2 remains unacked, but no packets have retransmittable data.
459 uint64_t unacked[] = {2};
460 VerifyUnackedPackets(unacked, QUIC_ARRAYSIZE(unacked));
461 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
462 VerifyRetransmittablePackets(nullptr, 0);
463 if (manager_.session_decides_what_to_write()) {
464 // Ack 2 causes 2 be considered as spurious retransmission.
465 EXPECT_CALL(notifier_, OnFrameAcked(_, _)).WillOnce(Return(false));
466 ExpectAck(2);
467 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
468 clock_.Now());
469 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
470 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
471 }
472
473 EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted);
474}
475
476TEST_P(QuicSentPacketManagerTest, RetransmitThenAckPreviousThenNackRetransmit) {
477 SendDataPacket(1);
478 RetransmitAndSendPacket(1, 2);
479 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
480 clock_.AdvanceTime(rtt);
481
482 // First, ACK packet 1 which makes packet 2 non-retransmittable.
483 ExpectAck(1);
484 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
485 clock_.Now());
486 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
487 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
488
489 SendDataPacket(3);
490 SendDataPacket(4);
491 SendDataPacket(5);
492 clock_.AdvanceTime(rtt);
493
494 // Next, NACK packet 2 three times.
495 ExpectAck(3);
496 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
497 clock_.Now());
498 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(4));
499 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
500 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
501
502 ExpectAck(4);
503 manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
504 clock_.Now());
505 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(5));
506 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
507 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
508
509 ExpectAckAndLoss(true, 5, 2);
510 if (manager_.session_decides_what_to_write()) {
511 // Frames in all packets are acked.
512 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
513 // Notify session that stream frame in packet 2 gets lost although it is
514 // not outstanding.
515 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(1);
516 }
517 manager_.OnAckFrameStart(QuicPacketNumber(5), QuicTime::Delta::Infinite(),
518 clock_.Now());
519 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(6));
520 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
521 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
522
523 if (manager_.session_decides_what_to_write()) {
524 uint64_t unacked[] = {2};
525 VerifyUnackedPackets(unacked, QUIC_ARRAYSIZE(unacked));
526 } else {
527 // No packets remain unacked.
528 VerifyUnackedPackets(nullptr, 0);
529 }
530 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
531 VerifyRetransmittablePackets(nullptr, 0);
532
533 // Verify that the retransmission alarm would not fire,
534 // since there is no retransmittable data outstanding.
535 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
536}
537
538TEST_P(QuicSentPacketManagerTest,
539 DISABLED_RetransmitTwiceThenAckPreviousBeforeSend) {
540 SendDataPacket(1);
541 RetransmitAndSendPacket(1, 2);
542
543 // Fire the RTO, which will mark 2 for retransmission (but will not send it).
544 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
545 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
546 manager_.OnRetransmissionTimeout();
547 EXPECT_TRUE(manager_.HasPendingRetransmissions());
548
549 // Ack 1 but not 2, before 2 is able to be sent.
550 // Since 1 has been retransmitted, it has already been lost, and so the
551 // send algorithm is not informed that it has been ACK'd.
552 ExpectUpdatedRtt(1);
553 EXPECT_CALL(*send_algorithm_, RevertRetransmissionTimeout());
554 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
555 clock_.Now());
556 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
557 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
558
559 // Since 2 was marked for retransmit, when 1 is acked, 2 is kept for RTT.
560 uint64_t unacked[] = {2};
561 VerifyUnackedPackets(unacked, QUIC_ARRAYSIZE(unacked));
562 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
563 VerifyRetransmittablePackets(nullptr, 0);
564
565 // Verify that the retransmission alarm would not fire,
566 // since there is no retransmittable data outstanding.
567 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
568}
569
570TEST_P(QuicSentPacketManagerTest, RetransmitTwiceThenAckFirst) {
571 StrictMock<MockDebugDelegate> debug_delegate;
572 if (manager_.session_decides_what_to_write()) {
573 EXPECT_CALL(debug_delegate, OnSpuriousPacketRetransmission(
574 TLP_RETRANSMISSION, kDefaultLength))
575 .Times(1);
576 } else {
577 EXPECT_CALL(debug_delegate, OnSpuriousPacketRetransmission(
578 TLP_RETRANSMISSION, kDefaultLength))
579 .Times(2);
580 }
581 manager_.SetDebugDelegate(&debug_delegate);
582
583 SendDataPacket(1);
584 RetransmitAndSendPacket(1, 2);
585 RetransmitAndSendPacket(2, 3);
586 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
587 clock_.AdvanceTime(rtt);
588
589 // Ack 1 but not 2 or 3.
590 ExpectAck(1);
591 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
592 clock_.Now());
593 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
594 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
595 if (manager_.session_decides_what_to_write()) {
596 // Frames in packets 2 and 3 are acked.
597 EXPECT_CALL(notifier_, IsFrameOutstanding(_))
598 .Times(2)
599 .WillRepeatedly(Return(false));
600 }
601
602 // 2 and 3 remain unacked, but no packets have retransmittable data.
603 uint64_t unacked[] = {2, 3};
604 VerifyUnackedPackets(unacked, QUIC_ARRAYSIZE(unacked));
605 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
606 VerifyRetransmittablePackets(nullptr, 0);
607
608 // Ensure packet 2 is lost when 4 is sent and 3 and 4 are acked.
609 SendDataPacket(4);
610 if (manager_.session_decides_what_to_write()) {
611 // No new data gets acked in packet 3.
612 EXPECT_CALL(notifier_, OnFrameAcked(_, _))
613 .WillOnce(Return(false))
614 .WillRepeatedly(Return(true));
615 }
616 uint64_t acked[] = {3, 4};
617 ExpectAcksAndLosses(true, acked, QUIC_ARRAYSIZE(acked), nullptr, 0);
618 manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
619 clock_.Now());
620 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(5));
621 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
622 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
623
624 uint64_t unacked2[] = {2};
625 VerifyUnackedPackets(unacked2, QUIC_ARRAYSIZE(unacked2));
626 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
627
628 SendDataPacket(5);
629 ExpectAckAndLoss(true, 5, 2);
630 EXPECT_CALL(debug_delegate,
631 OnPacketLoss(QuicPacketNumber(2), LOSS_RETRANSMISSION, _));
632 if (manager_.session_decides_what_to_write()) {
633 // Frames in all packets are acked.
634 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
635 // Notify session that stream frame in packet 2 gets lost although it is
636 // not outstanding.
637 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(1);
638 }
639 manager_.OnAckFrameStart(QuicPacketNumber(5), QuicTime::Delta::Infinite(),
640 clock_.Now());
641 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(6));
642 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
643 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
644
645 if (manager_.session_decides_what_to_write()) {
646 uint64_t unacked[] = {2};
647 VerifyUnackedPackets(unacked, QUIC_ARRAYSIZE(unacked));
648 } else {
649 VerifyUnackedPackets(nullptr, 0);
650 }
651 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
652 if (manager_.session_decides_what_to_write()) {
653 // Spurious retransmission is detected when packet 3 gets acked. We cannot
654 // know packet 2 is a spurious until it gets acked.
655 EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted);
656 } else {
657 EXPECT_EQ(2u, stats_.packets_spuriously_retransmitted);
658 }
659}
660
661TEST_P(QuicSentPacketManagerTest, AckOriginalTransmission) {
662 auto loss_algorithm = QuicMakeUnique<MockLossAlgorithm>();
663 QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm.get());
664
665 SendDataPacket(1);
666 RetransmitAndSendPacket(1, 2);
667
668 // Ack original transmission, but that wasn't lost via fast retransmit,
669 // so no call on OnSpuriousRetransmission is expected.
670 {
671 ExpectAck(1);
672 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
673 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
674 clock_.Now());
675 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
676 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
677 }
678
679 SendDataPacket(3);
680 SendDataPacket(4);
681 // Ack 4, which causes 3 to be retransmitted.
682 {
683 ExpectAck(4);
684 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
685 manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
686 clock_.Now());
687 manager_.OnAckRange(QuicPacketNumber(4), QuicPacketNumber(5));
688 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
689 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
690 RetransmitAndSendPacket(3, 5, LOSS_RETRANSMISSION);
691 }
692
693 // Ack 3, which causes SpuriousRetransmitDetected to be called.
694 {
695 uint64_t acked[] = {3};
696 ExpectAcksAndLosses(false, acked, QUIC_ARRAYSIZE(acked), nullptr, 0);
697 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
698 EXPECT_CALL(*loss_algorithm,
699 SpuriousRetransmitDetected(_, _, _, QuicPacketNumber(5)));
700 manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
701 clock_.Now());
702 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(5));
703 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
704 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
705 if (manager_.session_decides_what_to_write()) {
706 // Ack 3 will not cause 5 be considered as a spurious retransmission. Ack
707 // 5 will cause 5 be considered as a spurious retransmission as no new
708 // data gets acked.
709 ExpectAck(5);
710 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
711 EXPECT_CALL(notifier_, OnFrameAcked(_, _)).WillOnce(Return(false));
712 manager_.OnAckFrameStart(QuicPacketNumber(5), QuicTime::Delta::Infinite(),
713 clock_.Now());
714 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(6));
715 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
716 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
717 }
718 }
719}
720
721TEST_P(QuicSentPacketManagerTest, GetLeastUnacked) {
722 EXPECT_EQ(QuicPacketNumber(1u), manager_.GetLeastUnacked());
723}
724
725TEST_P(QuicSentPacketManagerTest, GetLeastUnackedUnacked) {
726 SendDataPacket(1);
727 EXPECT_EQ(QuicPacketNumber(1u), manager_.GetLeastUnacked());
728}
729
730TEST_P(QuicSentPacketManagerTest, AckAckAndUpdateRtt) {
731 EXPECT_FALSE(manager_.largest_packet_peer_knows_is_acked().IsInitialized());
732 SendDataPacket(1);
733 SendAckPacket(2, 1);
734
735 // Now ack the ack and expect an RTT update.
736 uint64_t acked[] = {1, 2};
737 ExpectAcksAndLosses(true, acked, QUIC_ARRAYSIZE(acked), nullptr, 0);
738 manager_.OnAckFrameStart(QuicPacketNumber(2),
739 QuicTime::Delta::FromMilliseconds(5), clock_.Now());
740 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
741 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
742 EXPECT_EQ(QuicPacketNumber(1), manager_.largest_packet_peer_knows_is_acked());
743
744 SendAckPacket(3, 3);
745
746 // Now ack the ack and expect only an RTT update.
747 uint64_t acked2[] = {3};
748 ExpectAcksAndLosses(true, acked2, QUIC_ARRAYSIZE(acked2), nullptr, 0);
749 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
750 clock_.Now());
751 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(4));
752 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
753 EXPECT_EQ(QuicPacketNumber(3u),
754 manager_.largest_packet_peer_knows_is_acked());
755}
756
757TEST_P(QuicSentPacketManagerTest, Rtt) {
758 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(20);
759 SendDataPacket(1);
760 clock_.AdvanceTime(expected_rtt);
761
762 ExpectAck(1);
763 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
764 clock_.Now());
765 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
766 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
767 EXPECT_EQ(expected_rtt, manager_.GetRttStats()->latest_rtt());
768}
769
770TEST_P(QuicSentPacketManagerTest, RttWithInvalidDelta) {
771 // Expect that the RTT is equal to the local time elapsed, since the
772 // ack_delay_time is larger than the local time elapsed
773 // and is hence invalid.
774 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10);
775 SendDataPacket(1);
776 clock_.AdvanceTime(expected_rtt);
777
778 ExpectAck(1);
779 manager_.OnAckFrameStart(QuicPacketNumber(1),
780 QuicTime::Delta::FromMilliseconds(11), clock_.Now());
781 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
782 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
783 EXPECT_EQ(expected_rtt, manager_.GetRttStats()->latest_rtt());
784}
785
786TEST_P(QuicSentPacketManagerTest, RttWithInfiniteDelta) {
787 // Expect that the RTT is equal to the local time elapsed, since the
788 // ack_delay_time is infinite, and is hence invalid.
789 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10);
790 SendDataPacket(1);
791 clock_.AdvanceTime(expected_rtt);
792
793 ExpectAck(1);
794 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
795 clock_.Now());
796 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
797 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
798 EXPECT_EQ(expected_rtt, manager_.GetRttStats()->latest_rtt());
799}
800
801TEST_P(QuicSentPacketManagerTest, RttZeroDelta) {
802 // Expect that the RTT is the time between send and receive since the
803 // ack_delay_time is zero.
804 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10);
805 SendDataPacket(1);
806 clock_.AdvanceTime(expected_rtt);
807
808 ExpectAck(1);
809 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Zero(),
810 clock_.Now());
811 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
812 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
813 EXPECT_EQ(expected_rtt, manager_.GetRttStats()->latest_rtt());
814}
815
816TEST_P(QuicSentPacketManagerTest, TailLossProbeTimeout) {
817 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
818
819 // Send 1 packet.
820 SendDataPacket(1);
821
822 // The first tail loss probe retransmits 1 packet.
823 manager_.OnRetransmissionTimeout();
824 EXPECT_EQ(QuicTime::Delta::Zero(), manager_.TimeUntilSend(clock_.Now()));
825 EXPECT_FALSE(manager_.HasPendingRetransmissions());
826 if (manager_.session_decides_what_to_write()) {
827 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
828 .WillOnce(WithArgs<1>(Invoke(
829 [this](TransmissionType type) { RetransmitDataPacket(2, type); })));
830 }
831 manager_.MaybeRetransmitTailLossProbe();
832 if (!manager_.session_decides_what_to_write()) {
833 EXPECT_TRUE(manager_.HasPendingRetransmissions());
834 RetransmitNextPacket(2);
835 EXPECT_FALSE(manager_.HasPendingRetransmissions());
836 }
837
838 // The second tail loss probe retransmits 1 packet.
839 manager_.OnRetransmissionTimeout();
840 EXPECT_EQ(QuicTime::Delta::Zero(), manager_.TimeUntilSend(clock_.Now()));
841 EXPECT_FALSE(manager_.HasPendingRetransmissions());
842 if (manager_.session_decides_what_to_write()) {
843 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
844 .WillOnce(WithArgs<1>(Invoke(
845 [this](TransmissionType type) { RetransmitDataPacket(3, type); })));
846 }
847 manager_.MaybeRetransmitTailLossProbe();
848 if (!manager_.session_decides_what_to_write()) {
849 EXPECT_TRUE(manager_.HasPendingRetransmissions());
850 RetransmitNextPacket(3);
851 }
852 EXPECT_CALL(*send_algorithm_, CanSend(_)).WillOnce(Return(false));
853 EXPECT_EQ(QuicTime::Delta::Infinite(), manager_.TimeUntilSend(clock_.Now()));
854 EXPECT_FALSE(manager_.HasPendingRetransmissions());
855
856 // Ack the third and ensure the first two are still pending.
857 ExpectAck(3);
858
859 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
860 clock_.Now());
861 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(4));
862 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
863
864 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
865
866 // Acking two more packets will lose both of them due to nacks.
867 SendDataPacket(4);
868 SendDataPacket(5);
869 uint64_t acked[] = {4, 5};
870 uint64_t lost[] = {1, 2};
871 ExpectAcksAndLosses(true, acked, QUIC_ARRAYSIZE(acked), lost,
872 QUIC_ARRAYSIZE(lost));
873 if (manager_.session_decides_what_to_write()) {
874 // Frames in all packets are acked.
875 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
876 // Notify session that stream frame in packets 1 and 2 get lost although
877 // they are not outstanding.
878 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(2);
879 }
880 manager_.OnAckFrameStart(QuicPacketNumber(5), QuicTime::Delta::Infinite(),
881 clock_.Now());
882 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(6));
883 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
884
885 EXPECT_FALSE(manager_.HasPendingRetransmissions());
886 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
887 EXPECT_EQ(2u, stats_.tlp_count);
888 EXPECT_EQ(0u, stats_.rto_count);
889}
890
891TEST_P(QuicSentPacketManagerTest, TailLossProbeThenRTO) {
892 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
893
894 // Send 100 packets.
895 const size_t kNumSentPackets = 100;
896 for (size_t i = 1; i <= kNumSentPackets; ++i) {
897 SendDataPacket(i);
898 }
899 QuicTime rto_packet_time = clock_.Now();
900 // Advance the time.
901 clock_.AdvanceTime(manager_.GetRetransmissionTime() - clock_.Now());
902
903 // The first tail loss probe retransmits 1 packet.
904 manager_.OnRetransmissionTimeout();
905 EXPECT_EQ(QuicTime::Delta::Zero(), manager_.TimeUntilSend(clock_.Now()));
906 EXPECT_FALSE(manager_.HasPendingRetransmissions());
907 if (manager_.session_decides_what_to_write()) {
908 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
909 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
910 RetransmitDataPacket(101, type);
911 })));
912 }
913 manager_.MaybeRetransmitTailLossProbe();
914 if (!manager_.session_decides_what_to_write()) {
915 EXPECT_TRUE(manager_.HasPendingRetransmissions());
916 RetransmitNextPacket(101);
917 }
918 EXPECT_CALL(*send_algorithm_, CanSend(_)).WillOnce(Return(false));
919 EXPECT_EQ(QuicTime::Delta::Infinite(), manager_.TimeUntilSend(clock_.Now()));
920 EXPECT_FALSE(manager_.HasPendingRetransmissions());
921 clock_.AdvanceTime(manager_.GetRetransmissionTime() - clock_.Now());
922
923 // The second tail loss probe retransmits 1 packet.
924 manager_.OnRetransmissionTimeout();
925 EXPECT_EQ(QuicTime::Delta::Zero(), manager_.TimeUntilSend(clock_.Now()));
926 EXPECT_FALSE(manager_.HasPendingRetransmissions());
927 if (manager_.session_decides_what_to_write()) {
928 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
929 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
930 RetransmitDataPacket(102, type);
931 })));
932 }
933 EXPECT_TRUE(manager_.MaybeRetransmitTailLossProbe());
934 if (!manager_.session_decides_what_to_write()) {
935 EXPECT_TRUE(manager_.HasPendingRetransmissions());
936 RetransmitNextPacket(102);
937 }
938 EXPECT_CALL(*send_algorithm_, CanSend(_)).WillOnce(Return(false));
939 EXPECT_EQ(QuicTime::Delta::Infinite(), manager_.TimeUntilSend(clock_.Now()));
940
941 // Ensure the RTO is set based on the correct packet.
942 rto_packet_time = clock_.Now();
943 EXPECT_EQ(rto_packet_time + QuicTime::Delta::FromMilliseconds(500),
944 manager_.GetRetransmissionTime());
945
946 // Advance the time enough to ensure all packets are RTO'd.
947 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000));
948
949 if (manager_.session_decides_what_to_write()) {
950 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
951 .Times(2)
952 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
953 RetransmitDataPacket(103, type);
954 })))
955 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
956 RetransmitDataPacket(104, type);
957 })));
958 }
959 manager_.OnRetransmissionTimeout();
960 EXPECT_EQ(2u, stats_.tlp_count);
961 EXPECT_EQ(1u, stats_.rto_count);
962 if (manager_.session_decides_what_to_write()) {
963 // There are 2 RTO retransmissions.
964 EXPECT_EQ(104 * kDefaultLength,
965 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
966 }
967 if (!manager_.session_decides_what_to_write()) {
968 // Send and Ack the RTO and ensure OnRetransmissionTimeout is called.
969 EXPECT_EQ(102 * kDefaultLength,
970 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
971 EXPECT_TRUE(manager_.HasPendingRetransmissions());
972 RetransmitNextPacket(103);
973 }
974 QuicPacketNumber largest_acked = QuicPacketNumber(103);
975 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
976 EXPECT_CALL(*send_algorithm_,
977 OnCongestionEvent(
978 true, _, _, Pointwise(PacketNumberEq(), {largest_acked}), _));
979 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
980 if (manager_.session_decides_what_to_write()) {
981 // Although frames in packet 3 gets acked, it would be kept for another
982 // RTT.
983 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(true));
984 // Packets [1, 102] are lost, although stream frame in packet 3 is not
985 // outstanding.
986 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(102);
987 }
988 manager_.OnAckFrameStart(QuicPacketNumber(103), QuicTime::Delta::Infinite(),
989 clock_.Now());
990 manager_.OnAckRange(QuicPacketNumber(103), QuicPacketNumber(104));
991 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
992 // All packets before 103 should be lost.
993 if (manager_.session_decides_what_to_write()) {
994 // Packet 104 is still in flight.
995 EXPECT_EQ(1000u, QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
996 } else {
997 EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
998 }
999}
1000
1001TEST_P(QuicSentPacketManagerTest, CryptoHandshakeTimeout) {
1002 // Send 2 crypto packets and 3 data packets.
1003 const size_t kNumSentCryptoPackets = 2;
1004 for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) {
1005 SendCryptoPacket(i);
1006 }
1007 const size_t kNumSentDataPackets = 3;
1008 for (size_t i = 1; i <= kNumSentDataPackets; ++i) {
1009 SendDataPacket(kNumSentCryptoPackets + i);
1010 }
1011 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1012
1013 // The first retransmits 2 packets.
1014 if (manager_.session_decides_what_to_write()) {
1015 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1016 .Times(2)
1017 .WillOnce(InvokeWithoutArgs([this]() { RetransmitCryptoPacket(6); }))
1018 .WillOnce(InvokeWithoutArgs([this]() { RetransmitCryptoPacket(7); }));
1019 }
1020 manager_.OnRetransmissionTimeout();
1021 if (!manager_.session_decides_what_to_write()) {
1022 EXPECT_EQ(QuicTime::Delta::Zero(), manager_.TimeUntilSend(clock_.Now()));
1023 RetransmitNextPacket(6);
1024 RetransmitNextPacket(7);
1025 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1026 }
1027 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1028
1029 // The second retransmits 2 packets.
1030 if (manager_.session_decides_what_to_write()) {
1031 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1032 .Times(2)
1033 .WillOnce(InvokeWithoutArgs([this]() { RetransmitCryptoPacket(8); }))
1034 .WillOnce(InvokeWithoutArgs([this]() { RetransmitCryptoPacket(9); }));
1035 }
1036 manager_.OnRetransmissionTimeout();
1037 if (!manager_.session_decides_what_to_write()) {
1038 EXPECT_EQ(QuicTime::Delta::Zero(), manager_.TimeUntilSend(clock_.Now()));
1039 RetransmitNextPacket(8);
1040 RetransmitNextPacket(9);
1041 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1042 }
1043 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1044
1045 // Now ack the two crypto packets and the speculatively encrypted request,
1046 // and ensure the first four crypto packets get abandoned, but not lost.
1047 uint64_t acked[] = {3, 4, 5, 8, 9};
1048 ExpectAcksAndLosses(true, acked, QUIC_ARRAYSIZE(acked), nullptr, 0);
1049 if (manager_.session_decides_what_to_write()) {
1050 EXPECT_CALL(notifier_, HasUnackedCryptoData())
1051 .WillRepeatedly(Return(false));
1052 }
1053 manager_.OnAckFrameStart(QuicPacketNumber(9), QuicTime::Delta::Infinite(),
1054 clock_.Now());
1055 manager_.OnAckRange(QuicPacketNumber(8), QuicPacketNumber(10));
1056 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(6));
1057 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
1058
1059 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1060}
1061
1062TEST_P(QuicSentPacketManagerTest, CryptoHandshakeTimeoutVersionNegotiation) {
1063 // Send 2 crypto packets and 3 data packets.
1064 const size_t kNumSentCryptoPackets = 2;
1065 for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) {
1066 SendCryptoPacket(i);
1067 }
1068 const size_t kNumSentDataPackets = 3;
1069 for (size_t i = 1; i <= kNumSentDataPackets; ++i) {
1070 SendDataPacket(kNumSentCryptoPackets + i);
1071 }
1072 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1073
1074 if (manager_.session_decides_what_to_write()) {
1075 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1076 .Times(2)
1077 .WillOnce(InvokeWithoutArgs([this]() { RetransmitCryptoPacket(6); }))
1078 .WillOnce(InvokeWithoutArgs([this]() { RetransmitCryptoPacket(7); }));
1079 }
1080 manager_.OnRetransmissionTimeout();
1081 if (!manager_.session_decides_what_to_write()) {
1082 RetransmitNextPacket(6);
1083 RetransmitNextPacket(7);
1084 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1085 }
1086 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1087
1088 // Now act like a version negotiation packet arrived, which would cause all
1089 // unacked packets to be retransmitted.
1090 if (manager_.session_decides_what_to_write()) {
1091 // Mark packets [1, 7] lost. And the frames in 6 and 7 are same as packets 1
1092 // and 2, respectively.
1093 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(7);
1094 }
1095 manager_.RetransmitUnackedPackets(ALL_UNACKED_RETRANSMISSION);
1096
1097 // Ensure the first two pending packets are the crypto retransmits.
1098 if (manager_.session_decides_what_to_write()) {
1099 RetransmitCryptoPacket(8);
1100 RetransmitCryptoPacket(9);
1101 RetransmitDataPacket(10, ALL_UNACKED_RETRANSMISSION);
1102 RetransmitDataPacket(11, ALL_UNACKED_RETRANSMISSION);
1103 RetransmitDataPacket(12, ALL_UNACKED_RETRANSMISSION);
1104 } else {
1105 ASSERT_TRUE(manager_.HasPendingRetransmissions());
1106 EXPECT_EQ(QuicPacketNumber(6u),
1107 manager_.NextPendingRetransmission().packet_number);
1108 RetransmitNextPacket(8);
1109 EXPECT_EQ(QuicPacketNumber(7u),
1110 manager_.NextPendingRetransmission().packet_number);
1111 RetransmitNextPacket(9);
1112 EXPECT_TRUE(manager_.HasPendingRetransmissions());
1113 // Send 3 more data packets and ensure the least unacked is raised.
1114 RetransmitNextPacket(10);
1115 RetransmitNextPacket(11);
1116 RetransmitNextPacket(12);
1117 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1118 }
1119
1120 EXPECT_EQ(QuicPacketNumber(1u), manager_.GetLeastUnacked());
1121 // Least unacked isn't raised until an ack is received, so ack the
1122 // crypto packets.
1123 uint64_t acked[] = {8, 9};
1124 ExpectAcksAndLosses(true, acked, QUIC_ARRAYSIZE(acked), nullptr, 0);
1125 manager_.OnAckFrameStart(QuicPacketNumber(9), QuicTime::Delta::Infinite(),
1126 clock_.Now());
1127 manager_.OnAckRange(QuicPacketNumber(8), QuicPacketNumber(10));
1128 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
1129 if (manager_.session_decides_what_to_write()) {
1130 EXPECT_CALL(notifier_, HasUnackedCryptoData())
1131 .WillRepeatedly(Return(false));
1132 }
1133 EXPECT_EQ(QuicPacketNumber(10u), manager_.GetLeastUnacked());
1134}
1135
1136TEST_P(QuicSentPacketManagerTest, CryptoHandshakeSpuriousRetransmission) {
1137 // Send 1 crypto packet.
1138 SendCryptoPacket(1);
1139 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1140
1141 // Retransmit the crypto packet as 2.
1142 if (manager_.session_decides_what_to_write()) {
1143 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1144 .WillOnce(InvokeWithoutArgs([this]() { RetransmitCryptoPacket(2); }));
1145 }
1146 manager_.OnRetransmissionTimeout();
1147 if (!manager_.session_decides_what_to_write()) {
1148 RetransmitNextPacket(2);
1149 }
1150
1151 // Retransmit the crypto packet as 3.
1152 if (manager_.session_decides_what_to_write()) {
1153 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1154 .WillOnce(InvokeWithoutArgs([this]() { RetransmitCryptoPacket(3); }));
1155 }
1156 manager_.OnRetransmissionTimeout();
1157 if (!manager_.session_decides_what_to_write()) {
1158 RetransmitNextPacket(3);
1159 }
1160
1161 // Now ack the second crypto packet, and ensure the first gets removed, but
1162 // the third does not.
1163 uint64_t acked[] = {2};
1164 ExpectAcksAndLosses(true, acked, QUIC_ARRAYSIZE(acked), nullptr, 0);
1165 if (manager_.session_decides_what_to_write()) {
1166 EXPECT_CALL(notifier_, HasUnackedCryptoData())
1167 .WillRepeatedly(Return(false));
1168 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
1169 }
1170 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
1171 clock_.Now());
1172 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(3));
1173 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
1174
1175 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1176 uint64_t unacked[] = {3};
1177 VerifyUnackedPackets(unacked, QUIC_ARRAYSIZE(unacked));
1178}
1179
1180TEST_P(QuicSentPacketManagerTest, CryptoHandshakeTimeoutUnsentDataPacket) {
1181 // Send 2 crypto packets and 1 data packet.
1182 const size_t kNumSentCryptoPackets = 2;
1183 for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) {
1184 SendCryptoPacket(i);
1185 }
1186 SendDataPacket(3);
1187 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1188
1189 // Retransmit 2 crypto packets, but not the serialized packet.
1190 if (manager_.session_decides_what_to_write()) {
1191 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1192 .Times(2)
1193 .WillOnce(InvokeWithoutArgs([this]() { RetransmitCryptoPacket(4); }))
1194 .WillOnce(InvokeWithoutArgs([this]() { RetransmitCryptoPacket(5); }));
1195 }
1196 manager_.OnRetransmissionTimeout();
1197 if (!manager_.session_decides_what_to_write()) {
1198 RetransmitNextPacket(4);
1199 RetransmitNextPacket(5);
1200 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1201 }
1202 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1203}
1204
1205TEST_P(QuicSentPacketManagerTest,
1206 CryptoHandshakeRetransmissionThenRetransmitAll) {
1207 // Send 1 crypto packet.
1208 SendCryptoPacket(1);
1209
1210 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1211
1212 // Retransmit the crypto packet as 2.
1213 if (manager_.session_decides_what_to_write()) {
1214 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1215 .WillOnce(InvokeWithoutArgs([this]() { RetransmitCryptoPacket(2); }));
1216 }
1217 manager_.OnRetransmissionTimeout();
1218 if (!manager_.session_decides_what_to_write()) {
1219 RetransmitNextPacket(2);
1220 }
1221 // Now retransmit all the unacked packets, which occurs when there is a
1222 // version negotiation.
1223 if (manager_.session_decides_what_to_write()) {
1224 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(2);
1225 }
1226 manager_.RetransmitUnackedPackets(ALL_UNACKED_RETRANSMISSION);
1227 if (manager_.session_decides_what_to_write()) {
1228 // Both packets 1 and 2 are unackable.
1229 EXPECT_FALSE(QuicSentPacketManagerPeer::IsUnacked(&manager_, 1));
1230 EXPECT_FALSE(QuicSentPacketManagerPeer::IsUnacked(&manager_, 2));
1231 } else {
1232 // Packet 2 is useful because it does not get retransmitted and still has
1233 // retransmittable frames.
1234 uint64_t unacked[] = {1, 2};
1235 VerifyUnackedPackets(unacked, QUIC_ARRAYSIZE(unacked));
1236 EXPECT_TRUE(manager_.HasPendingRetransmissions());
1237 }
1238 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1239 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
1240}
1241
1242TEST_P(QuicSentPacketManagerTest,
1243 CryptoHandshakeRetransmissionThenNeuterAndAck) {
1244 // Send 1 crypto packet.
1245 SendCryptoPacket(1);
1246
1247 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1248
1249 // Retransmit the crypto packet as 2.
1250 if (manager_.session_decides_what_to_write()) {
1251 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1252 .WillOnce(InvokeWithoutArgs([this]() { RetransmitCryptoPacket(2); }));
1253 }
1254 manager_.OnRetransmissionTimeout();
1255 if (!manager_.session_decides_what_to_write()) {
1256 RetransmitNextPacket(2);
1257 }
1258 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1259
1260 // Retransmit the crypto packet as 3.
1261 if (manager_.session_decides_what_to_write()) {
1262 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1263 .WillOnce(InvokeWithoutArgs([this]() { RetransmitCryptoPacket(3); }));
1264 }
1265 manager_.OnRetransmissionTimeout();
1266 if (!manager_.session_decides_what_to_write()) {
1267 RetransmitNextPacket(3);
1268 }
1269 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1270
1271 // Now neuter all unacked unencrypted packets, which occurs when the
1272 // connection goes forward secure.
1273 manager_.NeuterUnencryptedPackets();
1274 if (manager_.session_decides_what_to_write()) {
1275 EXPECT_CALL(notifier_, HasUnackedCryptoData())
1276 .WillRepeatedly(Return(false));
1277 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
1278 }
1279 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1280 uint64_t unacked[] = {1, 2, 3};
1281 VerifyUnackedPackets(unacked, QUIC_ARRAYSIZE(unacked));
1282 VerifyRetransmittablePackets(nullptr, 0);
1283 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1284 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
1285 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
1286
1287 // Ensure both packets get discarded when packet 2 is acked.
1288 uint64_t acked[] = {3};
1289 ExpectAcksAndLosses(true, acked, QUIC_ARRAYSIZE(acked), nullptr, 0);
1290 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
1291 clock_.Now());
1292 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(4));
1293 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
1294 VerifyUnackedPackets(nullptr, 0);
1295 VerifyRetransmittablePackets(nullptr, 0);
1296}
1297
1298TEST_P(QuicSentPacketManagerTest, RetransmissionTimeout) {
1299 StrictMock<MockDebugDelegate> debug_delegate;
1300 manager_.SetDebugDelegate(&debug_delegate);
1301
1302 // Send 100 packets.
1303 const size_t kNumSentPackets = 100;
1304 for (size_t i = 1; i <= kNumSentPackets; ++i) {
1305 SendDataPacket(i);
1306 }
1307
1308 EXPECT_FALSE(manager_.MaybeRetransmitTailLossProbe());
1309 if (manager_.session_decides_what_to_write()) {
1310 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1311 .Times(2)
1312 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
1313 RetransmitDataPacket(101, type);
1314 })))
1315 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
1316 RetransmitDataPacket(102, type);
1317 })));
1318 }
1319 manager_.OnRetransmissionTimeout();
1320 if (manager_.session_decides_what_to_write()) {
1321 EXPECT_EQ(102 * kDefaultLength,
1322 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1323 } else {
1324 ASSERT_TRUE(manager_.HasPendingRetransmissions());
1325 EXPECT_EQ(100 * kDefaultLength,
1326 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1327 RetransmitNextPacket(101);
1328 ASSERT_TRUE(manager_.HasPendingRetransmissions());
1329 RetransmitNextPacket(102);
1330 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1331 }
1332
1333 // Ack a retransmission.
1334 // Ensure no packets are lost.
1335 QuicPacketNumber largest_acked = QuicPacketNumber(102);
1336 EXPECT_CALL(*send_algorithm_,
1337 OnCongestionEvent(true, _, _,
1338 Pointwise(PacketNumberEq(), {largest_acked}),
1339 /*lost_packets=*/IsEmpty()));
1340 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1341 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
1342 // RTO's use loss detection instead of immediately declaring retransmitted
1343 // packets lost.
1344 for (int i = 1; i <= 99; ++i) {
1345 EXPECT_CALL(debug_delegate,
1346 OnPacketLoss(QuicPacketNumber(i), LOSS_RETRANSMISSION, _));
1347 }
1348 if (manager_.session_decides_what_to_write()) {
1349 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(true));
1350 // Packets [1, 99] are considered as lost, although stream frame in packet
1351 // 2 is not outstanding.
1352 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(99);
1353 }
1354 manager_.OnAckFrameStart(QuicPacketNumber(102), QuicTime::Delta::Zero(),
1355 clock_.Now());
1356 manager_.OnAckRange(QuicPacketNumber(102), QuicPacketNumber(103));
1357 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
1358}
1359
1360TEST_P(QuicSentPacketManagerTest, RetransmissionTimeoutOnePacket) {
1361 // Set the 1RTO connection option.
1362 QuicConfig client_config;
1363 QuicTagVector options;
1364 options.push_back(k1RTO);
1365 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
1366 client_config.SetConnectionOptionsToSend(options);
1367 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1368 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1369 EXPECT_CALL(*send_algorithm_, PacingRate(_))
1370 .WillRepeatedly(Return(QuicBandwidth::Zero()));
1371 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
1372 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
1373 manager_.SetFromConfig(client_config);
1374 EXPECT_CALL(*send_algorithm_, CanSend(_)).WillRepeatedly(Return(true));
1375
1376 StrictMock<MockDebugDelegate> debug_delegate;
1377 manager_.SetDebugDelegate(&debug_delegate);
1378
1379 // Send 100 packets.
1380 const size_t kNumSentPackets = 100;
1381 for (size_t i = 1; i <= kNumSentPackets; ++i) {
1382 SendDataPacket(i);
1383 }
1384
1385 EXPECT_FALSE(manager_.MaybeRetransmitTailLossProbe());
1386 if (manager_.session_decides_what_to_write()) {
1387 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1388 .Times(1)
1389 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
1390 RetransmitDataPacket(101, type);
1391 })));
1392 }
1393 manager_.OnRetransmissionTimeout();
1394 if (manager_.session_decides_what_to_write()) {
1395 EXPECT_EQ(101 * kDefaultLength,
1396 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1397 } else {
1398 ASSERT_TRUE(manager_.HasPendingRetransmissions());
1399 EXPECT_EQ(100 * kDefaultLength,
1400 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1401 RetransmitNextPacket(101);
1402 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1403 }
1404}
1405
1406TEST_P(QuicSentPacketManagerTest, NewRetransmissionTimeout) {
1407 QuicConfig client_config;
1408 QuicTagVector options;
1409 options.push_back(kNRTO);
1410 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
1411 client_config.SetConnectionOptionsToSend(options);
1412 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1413 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1414 EXPECT_CALL(*send_algorithm_, PacingRate(_))
1415 .WillRepeatedly(Return(QuicBandwidth::Zero()));
1416 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
1417 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
1418 manager_.SetFromConfig(client_config);
1419 EXPECT_TRUE(QuicSentPacketManagerPeer::GetUseNewRto(&manager_));
1420 EXPECT_CALL(*send_algorithm_, CanSend(_)).WillRepeatedly(Return(true));
1421
1422 // Send 100 packets.
1423 const size_t kNumSentPackets = 100;
1424 for (size_t i = 1; i <= kNumSentPackets; ++i) {
1425 SendDataPacket(i);
1426 }
1427
1428 EXPECT_FALSE(manager_.MaybeRetransmitTailLossProbe());
1429 if (manager_.session_decides_what_to_write()) {
1430 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1431 .Times(2)
1432 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
1433 RetransmitDataPacket(101, type);
1434 })))
1435 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
1436 RetransmitDataPacket(102, type);
1437 })));
1438 }
1439 manager_.OnRetransmissionTimeout();
1440 if (manager_.session_decides_what_to_write()) {
1441 EXPECT_EQ(102 * kDefaultLength,
1442 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1443 } else {
1444 EXPECT_TRUE(manager_.HasPendingRetransmissions());
1445 EXPECT_EQ(100 * kDefaultLength,
1446 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1447 RetransmitNextPacket(101);
1448 RetransmitNextPacket(102);
1449 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1450 }
1451
1452 // Ack a retransmission and expect no call to OnRetransmissionTimeout.
1453 // This will include packets in the lost packet map.
1454 QuicPacketNumber largest_acked = QuicPacketNumber(102);
1455 EXPECT_CALL(*send_algorithm_,
1456 OnCongestionEvent(true, _, _,
1457 Pointwise(PacketNumberEq(), {largest_acked}),
1458 /*lost_packets=*/Not(IsEmpty())));
1459 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1460 if (manager_.session_decides_what_to_write()) {
1461 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(true));
1462 // Packets [1, 99] are considered as lost, although stream frame in packet
1463 // 2 is not outstanding.
1464 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(99);
1465 }
1466 manager_.OnAckFrameStart(QuicPacketNumber(102), QuicTime::Delta::Zero(),
1467 clock_.Now());
1468 manager_.OnAckRange(QuicPacketNumber(102), QuicPacketNumber(103));
1469 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
1470}
1471
1472TEST_P(QuicSentPacketManagerTest, TwoRetransmissionTimeoutsAckSecond) {
1473 // Send 1 packet.
1474 SendDataPacket(1);
1475
1476 if (manager_.session_decides_what_to_write()) {
1477 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1478 .WillOnce(WithArgs<1>(Invoke(
1479 [this](TransmissionType type) { RetransmitDataPacket(2, type); })));
1480 }
1481 manager_.OnRetransmissionTimeout();
1482 if (manager_.session_decides_what_to_write()) {
1483 EXPECT_EQ(2 * kDefaultLength,
1484 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1485 } else {
1486 EXPECT_TRUE(manager_.HasPendingRetransmissions());
1487 EXPECT_EQ(kDefaultLength,
1488 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1489 RetransmitNextPacket(2);
1490 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1491 }
1492
1493 // Rto a second time.
1494 if (manager_.session_decides_what_to_write()) {
1495 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1496 .WillOnce(WithArgs<1>(Invoke(
1497 [this](TransmissionType type) { RetransmitDataPacket(3, type); })));
1498 }
1499 manager_.OnRetransmissionTimeout();
1500 if (manager_.session_decides_what_to_write()) {
1501 EXPECT_EQ(3 * kDefaultLength,
1502 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1503 } else {
1504 EXPECT_TRUE(manager_.HasPendingRetransmissions());
1505 EXPECT_EQ(2 * kDefaultLength,
1506 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1507 RetransmitNextPacket(3);
1508 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1509 }
1510
1511 // Ack a retransmission and ensure OnRetransmissionTimeout is called.
1512 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
1513 ExpectAck(2);
1514 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Zero(),
1515 clock_.Now());
1516 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(3));
1517 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
1518
1519 // The original packet and newest should be outstanding.
1520 EXPECT_EQ(2 * kDefaultLength,
1521 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1522}
1523
1524TEST_P(QuicSentPacketManagerTest, TwoRetransmissionTimeoutsAckFirst) {
1525 // Send 1 packet.
1526 SendDataPacket(1);
1527
1528 if (manager_.session_decides_what_to_write()) {
1529 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1530 .WillOnce(WithArgs<1>(Invoke(
1531 [this](TransmissionType type) { RetransmitDataPacket(2, type); })));
1532 }
1533 manager_.OnRetransmissionTimeout();
1534 if (manager_.session_decides_what_to_write()) {
1535 EXPECT_EQ(2 * kDefaultLength,
1536 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1537 } else {
1538 EXPECT_TRUE(manager_.HasPendingRetransmissions());
1539 EXPECT_EQ(kDefaultLength,
1540 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1541 RetransmitNextPacket(2);
1542 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1543 }
1544
1545 // Rto a second time.
1546 if (manager_.session_decides_what_to_write()) {
1547 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1548 .WillOnce(WithArgs<1>(Invoke(
1549 [this](TransmissionType type) { RetransmitDataPacket(3, type); })));
1550 }
1551 manager_.OnRetransmissionTimeout();
1552 if (manager_.session_decides_what_to_write()) {
1553 EXPECT_EQ(3 * kDefaultLength,
1554 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1555 } else {
1556 EXPECT_TRUE(manager_.HasPendingRetransmissions());
1557 EXPECT_EQ(2 * kDefaultLength,
1558 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1559 RetransmitNextPacket(3);
1560 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1561 }
1562
1563 // Ack a retransmission and ensure OnRetransmissionTimeout is called.
1564 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
1565 ExpectAck(3);
1566 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Zero(),
1567 clock_.Now());
1568 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(4));
1569 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
1570
1571 // The first two packets should still be outstanding.
1572 EXPECT_EQ(2 * kDefaultLength,
1573 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1574}
1575
1576TEST_P(QuicSentPacketManagerTest, GetTransmissionTime) {
1577 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
1578}
1579
1580TEST_P(QuicSentPacketManagerTest, GetTransmissionTimeCryptoHandshake) {
1581 QuicTime crypto_packet_send_time = clock_.Now();
1582 SendCryptoPacket(1);
1583
1584 // Check the min.
1585 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
1586 rtt_stats->set_initial_rtt(QuicTime::Delta::FromMilliseconds(1));
1587 EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromMilliseconds(10),
1588 manager_.GetRetransmissionTime());
1589
1590 // Test with a standard smoothed RTT.
1591 rtt_stats->set_initial_rtt(QuicTime::Delta::FromMilliseconds(100));
1592
1593 QuicTime::Delta srtt = rtt_stats->initial_rtt();
1594 QuicTime expected_time = clock_.Now() + 1.5 * srtt;
1595 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1596
1597 // Retransmit the packet by invoking the retransmission timeout.
1598 clock_.AdvanceTime(1.5 * srtt);
1599 if (manager_.session_decides_what_to_write()) {
1600 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1601 .WillOnce(InvokeWithoutArgs([this]() { RetransmitCryptoPacket(2); }));
1602 // When session decides what to write, crypto_packet_send_time gets updated.
1603 crypto_packet_send_time = clock_.Now();
1604 }
1605 manager_.OnRetransmissionTimeout();
1606 if (!manager_.session_decides_what_to_write()) {
1607 RetransmitNextPacket(2);
1608 }
1609
1610 // The retransmission time should now be twice as far in the future.
1611 expected_time = crypto_packet_send_time + srtt * 2 * 1.5;
1612 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1613
1614 // Retransmit the packet for the 2nd time.
1615 clock_.AdvanceTime(2 * 1.5 * srtt);
1616 if (manager_.session_decides_what_to_write()) {
1617 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1618 .WillOnce(InvokeWithoutArgs([this]() { RetransmitCryptoPacket(3); }));
1619 // When session decides what to write, crypto_packet_send_time gets updated.
1620 crypto_packet_send_time = clock_.Now();
1621 }
1622 manager_.OnRetransmissionTimeout();
1623 if (!manager_.session_decides_what_to_write()) {
1624 RetransmitNextPacket(3);
1625 }
1626
1627 // Verify exponential backoff of the retransmission timeout.
1628 expected_time = crypto_packet_send_time + srtt * 4 * 1.5;
1629 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1630}
1631
1632TEST_P(QuicSentPacketManagerTest,
1633 GetConservativeTransmissionTimeCryptoHandshake) {
1634 QuicConfig config;
1635 QuicTagVector options;
1636 options.push_back(kCONH);
1637 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1638 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1639 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1640 manager_.SetFromConfig(config);
1641 // Calling SetFromConfig requires mocking out some send algorithm methods.
1642 EXPECT_CALL(*send_algorithm_, PacingRate(_))
1643 .WillRepeatedly(Return(QuicBandwidth::Zero()));
1644 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
1645 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
1646
1647 QuicTime crypto_packet_send_time = clock_.Now();
1648 SendCryptoPacket(1);
1649
1650 // Check the min.
1651 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
1652 rtt_stats->set_initial_rtt(QuicTime::Delta::FromMilliseconds(1));
1653 EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromMilliseconds(25),
1654 manager_.GetRetransmissionTime());
1655
1656 // Test with a standard smoothed RTT.
1657 rtt_stats->set_initial_rtt(QuicTime::Delta::FromMilliseconds(100));
1658
1659 QuicTime::Delta srtt = rtt_stats->initial_rtt();
1660 QuicTime expected_time = clock_.Now() + 2 * srtt;
1661 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1662
1663 // Retransmit the packet by invoking the retransmission timeout.
1664 clock_.AdvanceTime(2 * srtt);
1665 if (manager_.session_decides_what_to_write()) {
1666 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1667 .WillOnce(InvokeWithoutArgs([this]() { RetransmitCryptoPacket(2); }));
1668 crypto_packet_send_time = clock_.Now();
1669 }
1670 manager_.OnRetransmissionTimeout();
1671 if (!manager_.session_decides_what_to_write()) {
1672 RetransmitNextPacket(2);
1673 }
1674
1675 // The retransmission time should now be twice as far in the future.
1676 expected_time = crypto_packet_send_time + srtt * 2 * 2;
1677 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1678}
1679
1680TEST_P(QuicSentPacketManagerTest, GetTransmissionTimeTailLossProbe) {
1681 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
1682 SendDataPacket(1);
1683 SendDataPacket(2);
1684
1685 // Check the min.
1686 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
1687 rtt_stats->set_initial_rtt(QuicTime::Delta::FromMilliseconds(1));
1688 EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromMilliseconds(10),
1689 manager_.GetRetransmissionTime());
1690
1691 // Test with a standard smoothed RTT.
1692 rtt_stats->set_initial_rtt(QuicTime::Delta::FromMilliseconds(100));
1693 QuicTime::Delta srtt = rtt_stats->initial_rtt();
1694 QuicTime::Delta expected_tlp_delay = 2 * srtt;
1695 QuicTime expected_time = clock_.Now() + expected_tlp_delay;
1696 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1697
1698 // Retransmit the packet by invoking the retransmission timeout.
1699 clock_.AdvanceTime(expected_tlp_delay);
1700 manager_.OnRetransmissionTimeout();
1701 EXPECT_EQ(QuicTime::Delta::Zero(), manager_.TimeUntilSend(clock_.Now()));
1702 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1703 if (manager_.session_decides_what_to_write()) {
1704 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1705 .WillOnce(WithArgs<1>(Invoke(
1706 [this](TransmissionType type) { RetransmitDataPacket(3, type); })));
1707 }
1708 EXPECT_TRUE(manager_.MaybeRetransmitTailLossProbe());
1709 if (!manager_.session_decides_what_to_write()) {
1710 EXPECT_TRUE(manager_.HasPendingRetransmissions());
1711 RetransmitNextPacket(3);
1712 }
1713 EXPECT_CALL(*send_algorithm_, CanSend(_)).WillOnce(Return(false));
1714 EXPECT_EQ(QuicTime::Delta::Infinite(), manager_.TimeUntilSend(clock_.Now()));
1715 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1716
1717 expected_time = clock_.Now() + expected_tlp_delay;
1718 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1719}
1720
1721TEST_P(QuicSentPacketManagerTest, GetTransmissionTimeSpuriousRTO) {
1722 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
1723 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
1724 QuicTime::Delta::Zero(), QuicTime::Zero());
1725
1726 SendDataPacket(1);
1727 SendDataPacket(2);
1728 SendDataPacket(3);
1729 SendDataPacket(4);
1730
1731 QuicTime::Delta expected_rto_delay =
1732 rtt_stats->smoothed_rtt() + 4 * rtt_stats->mean_deviation();
1733 QuicTime expected_time = clock_.Now() + expected_rto_delay;
1734 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1735
1736 // Retransmit the packet by invoking the retransmission timeout.
1737 clock_.AdvanceTime(expected_rto_delay);
1738 if (manager_.session_decides_what_to_write()) {
1739 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1740 .Times(2)
1741 .WillOnce(WithArgs<1>(Invoke(
1742 [this](TransmissionType type) { RetransmitDataPacket(5, type); })))
1743 .WillOnce(WithArgs<1>(Invoke(
1744 [this](TransmissionType type) { RetransmitDataPacket(6, type); })));
1745 }
1746 manager_.OnRetransmissionTimeout();
1747 if (!manager_.session_decides_what_to_write()) {
1748 // All packets are still considered inflight.
1749 EXPECT_EQ(4 * kDefaultLength,
1750 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1751 RetransmitNextPacket(5);
1752 RetransmitNextPacket(6);
1753 }
1754 // All previous packets are inflight, plus two rto retransmissions.
1755 EXPECT_EQ(6 * kDefaultLength,
1756 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1757 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1758
1759 // The delay should double the second time.
1760 expected_time = clock_.Now() + expected_rto_delay + expected_rto_delay;
1761 // Once we always base the timer on the right edge, leaving the older packets
1762 // in flight doesn't change the timeout.
1763 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1764
1765 // Ack a packet before the first RTO and ensure the RTO timeout returns to the
1766 // original value and OnRetransmissionTimeout is not called or reverted.
1767 ExpectAck(2);
1768 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
1769 clock_.Now());
1770 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(3));
1771 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
1772 EXPECT_FALSE(manager_.HasPendingRetransmissions());
1773 EXPECT_EQ(5 * kDefaultLength,
1774 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
1775
1776 // Wait 2RTTs from now for the RTO, since it's the max of the RTO time
1777 // and the TLP time. In production, there would always be two TLP's first.
1778 // Since retransmission was spurious, smoothed_rtt_ is expired, and replaced
1779 // by the latest RTT sample of 500ms.
1780 expected_time = clock_.Now() + QuicTime::Delta::FromMilliseconds(1000);
1781 // Once we always base the timer on the right edge, leaving the older packets
1782 // in flight doesn't change the timeout.
1783 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1784}
1785
1786TEST_P(QuicSentPacketManagerTest, GetTransmissionDelayMin) {
1787 SendDataPacket(1);
1788 // Provide a 1ms RTT sample.
1789 const_cast<RttStats*>(manager_.GetRttStats())
1790 ->UpdateRtt(QuicTime::Delta::FromMilliseconds(1), QuicTime::Delta::Zero(),
1791 QuicTime::Zero());
1792 QuicTime::Delta delay = QuicTime::Delta::FromMilliseconds(200);
1793
1794 // If the delay is smaller than the min, ensure it exponentially backs off
1795 // from the min.
1796 for (int i = 0; i < 5; ++i) {
1797 EXPECT_EQ(delay,
1798 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
1799 EXPECT_EQ(delay,
1800 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_, i));
1801 delay = delay + delay;
1802 if (manager_.session_decides_what_to_write()) {
1803 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1804 .WillOnce(WithArgs<1>(Invoke([this, i](TransmissionType type) {
1805 RetransmitDataPacket(i + 2, type);
1806 })));
1807 }
1808 manager_.OnRetransmissionTimeout();
1809 if (!manager_.session_decides_what_to_write()) {
1810 RetransmitNextPacket(i + 2);
1811 }
1812 }
1813}
1814
1815TEST_P(QuicSentPacketManagerTest, GetTransmissionDelayMax) {
1816 SendDataPacket(1);
1817 // Provide a 60s RTT sample.
1818 const_cast<RttStats*>(manager_.GetRttStats())
1819 ->UpdateRtt(QuicTime::Delta::FromSeconds(60), QuicTime::Delta::Zero(),
1820 QuicTime::Zero());
1821
1822 EXPECT_EQ(QuicTime::Delta::FromSeconds(60),
1823 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
1824 EXPECT_EQ(QuicTime::Delta::FromSeconds(60),
1825 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_, 0));
1826}
1827
1828TEST_P(QuicSentPacketManagerTest, GetTransmissionDelayExponentialBackoff) {
1829 SendDataPacket(1);
1830 QuicTime::Delta delay = QuicTime::Delta::FromMilliseconds(500);
1831
1832 // Delay should back off exponentially.
1833 for (int i = 0; i < 5; ++i) {
1834 EXPECT_EQ(delay,
1835 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
1836 EXPECT_EQ(delay,
1837 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_, i));
1838 delay = delay + delay;
1839 if (manager_.session_decides_what_to_write()) {
1840 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1841 .WillOnce(WithArgs<1>(Invoke([this, i](TransmissionType type) {
1842 RetransmitDataPacket(i + 2, type);
1843 })));
1844 }
1845 manager_.OnRetransmissionTimeout();
1846 if (!manager_.session_decides_what_to_write()) {
1847 RetransmitNextPacket(i + 2);
1848 }
1849 }
1850}
1851
1852TEST_P(QuicSentPacketManagerTest, RetransmissionDelay) {
1853 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
1854 const int64_t kRttMs = 250;
1855 const int64_t kDeviationMs = 5;
1856
1857 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(kRttMs),
1858 QuicTime::Delta::Zero(), clock_.Now());
1859
1860 // Initial value is to set the median deviation to half of the initial rtt,
1861 // the median in then multiplied by a factor of 4 and finally the smoothed rtt
1862 // is added which is the initial rtt.
1863 QuicTime::Delta expected_delay =
1864 QuicTime::Delta::FromMilliseconds(kRttMs + kRttMs / 2 * 4);
1865 EXPECT_EQ(expected_delay,
1866 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
1867 EXPECT_EQ(expected_delay,
1868 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_, 0));
1869
1870 for (int i = 0; i < 100; ++i) {
1871 // Run to make sure that we converge.
1872 rtt_stats->UpdateRtt(
1873 QuicTime::Delta::FromMilliseconds(kRttMs + kDeviationMs),
1874 QuicTime::Delta::Zero(), clock_.Now());
1875 rtt_stats->UpdateRtt(
1876 QuicTime::Delta::FromMilliseconds(kRttMs - kDeviationMs),
1877 QuicTime::Delta::Zero(), clock_.Now());
1878 }
1879 expected_delay = QuicTime::Delta::FromMilliseconds(kRttMs + kDeviationMs * 4);
1880
1881 EXPECT_NEAR(kRttMs, rtt_stats->smoothed_rtt().ToMilliseconds(), 1);
1882 EXPECT_NEAR(expected_delay.ToMilliseconds(),
1883 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_)
1884 .ToMilliseconds(),
1885 1);
1886 EXPECT_EQ(QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_, 0),
1887 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
1888}
1889
1890TEST_P(QuicSentPacketManagerTest, GetLossDelay) {
1891 auto loss_algorithm = QuicMakeUnique<MockLossAlgorithm>();
1892 QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm.get());
1893
1894 EXPECT_CALL(*loss_algorithm, GetLossTimeout())
1895 .WillRepeatedly(Return(QuicTime::Zero()));
1896 SendDataPacket(1);
1897 SendDataPacket(2);
1898
1899 // Handle an ack which causes the loss algorithm to be evaluated and
1900 // set the loss timeout.
1901 ExpectAck(2);
1902 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
1903 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
1904 clock_.Now());
1905 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(3));
1906 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
1907
1908 QuicTime timeout(clock_.Now() + QuicTime::Delta::FromMilliseconds(10));
1909 EXPECT_CALL(*loss_algorithm, GetLossTimeout())
1910 .WillRepeatedly(Return(timeout));
1911 EXPECT_EQ(timeout, manager_.GetRetransmissionTime());
1912
1913 // Fire the retransmission timeout and ensure the loss detection algorithm
1914 // is invoked.
1915 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
1916 manager_.OnRetransmissionTimeout();
1917}
1918
1919TEST_P(QuicSentPacketManagerTest, NegotiateTimeLossDetectionFromOptions) {
1920 EXPECT_EQ(kNack, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_)
1921 ->GetLossDetectionType());
1922
1923 QuicConfig config;
1924 QuicTagVector options;
1925 options.push_back(kTIME);
1926 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1927 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1928 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1929 manager_.SetFromConfig(config);
1930
1931 EXPECT_EQ(kTime, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_)
1932 ->GetLossDetectionType());
1933}
1934
1935TEST_P(QuicSentPacketManagerTest, NegotiateCongestionControlFromOptions) {
1936 QuicConfig config;
1937 QuicTagVector options;
1938
1939 options.push_back(kRENO);
1940 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1941 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1942 manager_.SetFromConfig(config);
1943 EXPECT_EQ(kRenoBytes, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
1944 ->GetCongestionControlType());
1945
1946 options.clear();
1947 options.push_back(kTBBR);
1948 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1949 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1950 manager_.SetFromConfig(config);
1951 EXPECT_EQ(kBBR, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
1952 ->GetCongestionControlType());
1953
1954 options.clear();
1955 options.push_back(kBYTE);
1956 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1957 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1958 manager_.SetFromConfig(config);
1959 EXPECT_EQ(kCubicBytes, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
1960 ->GetCongestionControlType());
1961 options.clear();
1962 options.push_back(kRENO);
1963 options.push_back(kBYTE);
1964 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1965 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1966 manager_.SetFromConfig(config);
1967 EXPECT_EQ(kRenoBytes, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
1968 ->GetCongestionControlType());
1969}
1970
1971TEST_P(QuicSentPacketManagerTest, NegotiateClientCongestionControlFromOptions) {
1972 QuicConfig config;
1973 QuicTagVector options;
1974
1975 // No change if the server receives client options.
1976 const SendAlgorithmInterface* mock_sender =
1977 QuicSentPacketManagerPeer::GetSendAlgorithm(manager_);
1978 options.push_back(kRENO);
1979 config.SetClientConnectionOptions(options);
1980 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1981 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1982 manager_.SetFromConfig(config);
1983 EXPECT_EQ(mock_sender, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_));
1984
1985 // Change the congestion control on the client with client options.
1986 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
1987 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1988 manager_.SetFromConfig(config);
1989 EXPECT_EQ(kRenoBytes, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
1990 ->GetCongestionControlType());
1991
1992 options.clear();
1993 options.push_back(kTBBR);
1994 config.SetClientConnectionOptions(options);
1995 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1996 manager_.SetFromConfig(config);
1997 EXPECT_EQ(kBBR, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
1998 ->GetCongestionControlType());
1999
2000 options.clear();
2001 options.push_back(kBYTE);
2002 config.SetClientConnectionOptions(options);
2003 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2004 manager_.SetFromConfig(config);
2005 EXPECT_EQ(kCubicBytes, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
2006 ->GetCongestionControlType());
2007
2008 options.clear();
2009 options.push_back(kRENO);
2010 options.push_back(kBYTE);
2011 config.SetClientConnectionOptions(options);
2012 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2013 manager_.SetFromConfig(config);
2014 EXPECT_EQ(kRenoBytes, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
2015 ->GetCongestionControlType());
2016}
2017
2018TEST_P(QuicSentPacketManagerTest, NegotiateNumConnectionsFromOptions) {
2019 QuicConfig config;
2020 QuicTagVector options;
2021
2022 options.push_back(k1CON);
2023 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
2024 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2025 EXPECT_CALL(*send_algorithm_, SetNumEmulatedConnections(1));
2026 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2027 manager_.SetFromConfig(config);
2028
2029 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
2030 QuicConfig client_config;
2031 client_config.SetConnectionOptionsToSend(options);
2032 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2033 EXPECT_CALL(*send_algorithm_, SetNumEmulatedConnections(1));
2034 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2035 manager_.SetFromConfig(client_config);
2036}
2037
2038TEST_P(QuicSentPacketManagerTest, NegotiateNoMinTLPFromOptionsAtServer) {
2039 QuicConfig config;
2040 QuicTagVector options;
2041
2042 options.push_back(kMAD2);
2043 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
2044 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2045 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2046 EXPECT_CALL(*send_algorithm_, PacingRate(_))
2047 .WillRepeatedly(Return(QuicBandwidth::Zero()));
2048 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
2049 .WillOnce(Return(10 * kDefaultTCPMSS));
2050 manager_.SetFromConfig(config);
2051 // Set the initial RTT to 1us.
2052 QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt(
2053 QuicTime::Delta::FromMicroseconds(1));
2054 // The TLP with fewer than 2 packets outstanding includes 1/2 min RTO(200ms).
2055 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(100002),
2056 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_));
2057 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(100002),
2058 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_, 0));
2059
2060 // Send two packets, and the TLP should be 2 us.
2061 SendDataPacket(1);
2062 SendDataPacket(2);
2063 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
2064 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_));
2065 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
2066 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_, 0));
2067}
2068
2069TEST_P(QuicSentPacketManagerTest, NegotiateNoMinTLPFromOptionsAtClient) {
2070 QuicConfig client_config;
2071 QuicTagVector options;
2072
2073 options.push_back(kMAD2);
2074 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
2075 client_config.SetConnectionOptionsToSend(options);
2076 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2077 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2078 EXPECT_CALL(*send_algorithm_, PacingRate(_))
2079 .WillRepeatedly(Return(QuicBandwidth::Zero()));
2080 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
2081 .WillOnce(Return(10 * kDefaultTCPMSS));
2082 manager_.SetFromConfig(client_config);
2083 // Set the initial RTT to 1us.
2084 QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt(
2085 QuicTime::Delta::FromMicroseconds(1));
2086 // The TLP with fewer than 2 packets outstanding includes 1/2 min RTO(200ms).
2087 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(100002),
2088 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_));
2089 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(100002),
2090 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_, 0));
2091 // Send two packets, and the TLP should be 2 us.
2092 SendDataPacket(1);
2093 SendDataPacket(2);
2094 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
2095 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_));
2096 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
2097 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_, 0));
2098}
2099
2100TEST_P(QuicSentPacketManagerTest, NegotiateIETFTLPFromOptionsAtServer) {
2101 QuicConfig config;
2102 QuicTagVector options;
2103
2104 options.push_back(kMAD4);
2105 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
2106 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2107 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2108 manager_.SetFromConfig(config);
2109 // Provide an RTT measurement of 100ms.
2110 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2111 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
2112 QuicTime::Delta::Zero(), QuicTime::Zero());
2113 // Expect 1.5x * SRTT + 0ms MAD
2114 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(150),
2115 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_));
2116 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(150),
2117 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_, 0));
2118 // Expect 1.5x * SRTT + 50ms MAD
2119 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(150),
2120 QuicTime::Delta::FromMilliseconds(50), QuicTime::Zero());
2121 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100), rtt_stats->smoothed_rtt());
2122 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200),
2123 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_));
2124 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200),
2125 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_, 0));
2126}
2127
2128TEST_P(QuicSentPacketManagerTest, NegotiateIETFTLPFromOptionsAtClient) {
2129 QuicConfig client_config;
2130 QuicTagVector options;
2131
2132 options.push_back(kMAD4);
2133 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
2134 client_config.SetConnectionOptionsToSend(options);
2135 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2136 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2137 manager_.SetFromConfig(client_config);
2138 // Provide an RTT measurement of 100ms.
2139 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2140 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
2141 QuicTime::Delta::Zero(), QuicTime::Zero());
2142 // Expect 1.5x * SRTT + 0ms MAD
2143 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(150),
2144 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_));
2145 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(150),
2146 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_, 0));
2147 // Expect 1.5x * SRTT + 50ms MAD
2148 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(150),
2149 QuicTime::Delta::FromMilliseconds(50), QuicTime::Zero());
2150 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100), rtt_stats->smoothed_rtt());
2151 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200),
2152 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_));
2153 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200),
2154 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_, 0));
2155}
2156
2157TEST_P(QuicSentPacketManagerTest, NegotiateNoMinRTOFromOptionsAtServer) {
2158 QuicConfig config;
2159 QuicTagVector options;
2160
2161 options.push_back(kMAD3);
2162 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
2163 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2164 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2165 manager_.SetFromConfig(config);
2166 // Provide one RTT measurement, because otherwise we use the default of 500ms.
2167 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2168 rtt_stats->UpdateRtt(QuicTime::Delta::FromMicroseconds(1),
2169 QuicTime::Delta::Zero(), QuicTime::Zero());
2170 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(1),
2171 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
2172 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(1),
2173 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_, 0));
2174 // The TLP with fewer than 2 packets outstanding includes 1/2 min RTO(0ms).
2175 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
2176 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_));
2177 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
2178 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_, 0));
2179}
2180
2181TEST_P(QuicSentPacketManagerTest, NegotiateNoMinRTOFromOptionsAtClient) {
2182 QuicConfig client_config;
2183 QuicTagVector options;
2184
2185 options.push_back(kMAD3);
2186 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
2187 client_config.SetConnectionOptionsToSend(options);
2188 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2189 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2190 manager_.SetFromConfig(client_config);
2191 // Provide one RTT measurement, because otherwise we use the default of 500ms.
2192 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2193 rtt_stats->UpdateRtt(QuicTime::Delta::FromMicroseconds(1),
2194 QuicTime::Delta::Zero(), QuicTime::Zero());
2195 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(1),
2196 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
2197 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(1),
2198 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_, 0));
2199 // The TLP with fewer than 2 packets outstanding includes 1/2 min RTO(0ms).
2200 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
2201 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_));
2202 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
2203 QuicSentPacketManagerPeer::GetTailLossProbeDelay(&manager_, 0));
2204}
2205
2206TEST_P(QuicSentPacketManagerTest, NegotiateNoTLPFromOptionsAtServer) {
2207 QuicConfig config;
2208 QuicTagVector options;
2209
2210 options.push_back(kNTLP);
2211 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
2212 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2213 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2214 manager_.SetFromConfig(config);
2215 EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetMaxTailLossProbes(&manager_));
2216}
2217
2218TEST_P(QuicSentPacketManagerTest, NegotiateNoTLPFromOptionsAtClient) {
2219 QuicConfig client_config;
2220 QuicTagVector options;
2221
2222 options.push_back(kNTLP);
2223 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
2224 client_config.SetConnectionOptionsToSend(options);
2225 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2226 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2227 manager_.SetFromConfig(client_config);
2228 EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetMaxTailLossProbes(&manager_));
2229}
2230
2231TEST_P(QuicSentPacketManagerTest, Negotiate1TLPFromOptionsAtServer) {
2232 QuicConfig config;
2233 QuicTagVector options;
2234
2235 options.push_back(k1TLP);
2236 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
2237 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2238 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2239 manager_.SetFromConfig(config);
2240 EXPECT_EQ(1u, QuicSentPacketManagerPeer::GetMaxTailLossProbes(&manager_));
2241}
2242
2243TEST_P(QuicSentPacketManagerTest, Negotiate1TLPFromOptionsAtClient) {
2244 QuicConfig client_config;
2245 QuicTagVector options;
2246
2247 options.push_back(k1TLP);
2248 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
2249 client_config.SetConnectionOptionsToSend(options);
2250 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2251 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2252 manager_.SetFromConfig(client_config);
2253 EXPECT_EQ(1u, QuicSentPacketManagerPeer::GetMaxTailLossProbes(&manager_));
2254}
2255
2256TEST_P(QuicSentPacketManagerTest, NegotiateTLPRttFromOptionsAtServer) {
2257 QuicConfig config;
2258 QuicTagVector options;
2259
2260 options.push_back(kTLPR);
2261 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
2262 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2263 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2264 manager_.SetFromConfig(config);
2265 EXPECT_TRUE(
2266 QuicSentPacketManagerPeer::GetEnableHalfRttTailLossProbe(&manager_));
2267}
2268
2269TEST_P(QuicSentPacketManagerTest, NegotiateTLPRttFromOptionsAtClient) {
2270 QuicConfig client_config;
2271 QuicTagVector options;
2272
2273 options.push_back(kTLPR);
2274 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
2275 client_config.SetConnectionOptionsToSend(options);
2276 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2277 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2278 manager_.SetFromConfig(client_config);
2279 EXPECT_TRUE(
2280 QuicSentPacketManagerPeer::GetEnableHalfRttTailLossProbe(&manager_));
2281}
2282
2283TEST_P(QuicSentPacketManagerTest, NegotiateNewRTOFromOptionsAtServer) {
2284 EXPECT_FALSE(QuicSentPacketManagerPeer::GetUseNewRto(&manager_));
2285 QuicConfig config;
2286 QuicTagVector options;
2287
2288 options.push_back(kNRTO);
2289 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
2290 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2291 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2292 manager_.SetFromConfig(config);
2293 EXPECT_TRUE(QuicSentPacketManagerPeer::GetUseNewRto(&manager_));
2294}
2295
2296TEST_P(QuicSentPacketManagerTest, NegotiateNewRTOFromOptionsAtClient) {
2297 EXPECT_FALSE(QuicSentPacketManagerPeer::GetUseNewRto(&manager_));
2298 QuicConfig client_config;
2299 QuicTagVector options;
2300
2301 options.push_back(kNRTO);
2302 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
2303 client_config.SetConnectionOptionsToSend(options);
2304 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2305 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2306 manager_.SetFromConfig(client_config);
2307 EXPECT_TRUE(QuicSentPacketManagerPeer::GetUseNewRto(&manager_));
2308}
2309
2310TEST_P(QuicSentPacketManagerTest, UseInitialRoundTripTimeToSend) {
2311 QuicTime::Delta initial_rtt = QuicTime::Delta::FromMilliseconds(325);
2312 EXPECT_NE(initial_rtt, manager_.GetRttStats()->smoothed_rtt());
2313
2314 QuicConfig config;
2315 config.SetInitialRoundTripTimeUsToSend(initial_rtt.ToMicroseconds());
2316 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2317 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2318 manager_.SetFromConfig(config);
2319
2320 EXPECT_EQ(QuicTime::Delta::Zero(), manager_.GetRttStats()->smoothed_rtt());
2321 EXPECT_EQ(initial_rtt, manager_.GetRttStats()->initial_rtt());
2322}
2323
2324TEST_P(QuicSentPacketManagerTest, ResumeConnectionState) {
2325 // The sent packet manager should use the RTT from CachedNetworkParameters if
2326 // it is provided.
2327 const QuicTime::Delta kRtt = QuicTime::Delta::FromMilliseconds(1234);
2328 CachedNetworkParameters cached_network_params;
2329 cached_network_params.set_min_rtt_ms(kRtt.ToMilliseconds());
2330
2331 EXPECT_CALL(*send_algorithm_,
2332 AdjustNetworkParameters(QuicBandwidth::Zero(), kRtt));
2333 manager_.ResumeConnectionState(cached_network_params, false);
2334 EXPECT_EQ(kRtt, manager_.GetRttStats()->initial_rtt());
2335}
2336
2337TEST_P(QuicSentPacketManagerTest, ConnectionMigrationUnspecifiedChange) {
2338 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2339 QuicTime::Delta default_init_rtt = rtt_stats->initial_rtt();
2340 rtt_stats->set_initial_rtt(default_init_rtt * 2);
2341 EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt());
2342
2343 QuicSentPacketManagerPeer::SetConsecutiveRtoCount(&manager_, 1);
2344 EXPECT_EQ(1u, manager_.GetConsecutiveRtoCount());
2345 QuicSentPacketManagerPeer::SetConsecutiveTlpCount(&manager_, 2);
2346 EXPECT_EQ(2u, manager_.GetConsecutiveTlpCount());
2347
2348 EXPECT_CALL(*send_algorithm_, OnConnectionMigration());
2349 manager_.OnConnectionMigration(IPV4_TO_IPV4_CHANGE);
2350
2351 EXPECT_EQ(default_init_rtt, rtt_stats->initial_rtt());
2352 EXPECT_EQ(0u, manager_.GetConsecutiveRtoCount());
2353 EXPECT_EQ(0u, manager_.GetConsecutiveTlpCount());
2354}
2355
2356TEST_P(QuicSentPacketManagerTest, ConnectionMigrationIPSubnetChange) {
2357 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2358 QuicTime::Delta default_init_rtt = rtt_stats->initial_rtt();
2359 rtt_stats->set_initial_rtt(default_init_rtt * 2);
2360 EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt());
2361
2362 QuicSentPacketManagerPeer::SetConsecutiveRtoCount(&manager_, 1);
2363 EXPECT_EQ(1u, manager_.GetConsecutiveRtoCount());
2364 QuicSentPacketManagerPeer::SetConsecutiveTlpCount(&manager_, 2);
2365 EXPECT_EQ(2u, manager_.GetConsecutiveTlpCount());
2366
2367 manager_.OnConnectionMigration(IPV4_SUBNET_CHANGE);
2368
2369 EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt());
2370 EXPECT_EQ(1u, manager_.GetConsecutiveRtoCount());
2371 EXPECT_EQ(2u, manager_.GetConsecutiveTlpCount());
2372}
2373
2374TEST_P(QuicSentPacketManagerTest, ConnectionMigrationPortChange) {
2375 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2376 QuicTime::Delta default_init_rtt = rtt_stats->initial_rtt();
2377 rtt_stats->set_initial_rtt(default_init_rtt * 2);
2378 EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt());
2379
2380 QuicSentPacketManagerPeer::SetConsecutiveRtoCount(&manager_, 1);
2381 EXPECT_EQ(1u, manager_.GetConsecutiveRtoCount());
2382 QuicSentPacketManagerPeer::SetConsecutiveTlpCount(&manager_, 2);
2383 EXPECT_EQ(2u, manager_.GetConsecutiveTlpCount());
2384
2385 manager_.OnConnectionMigration(PORT_CHANGE);
2386
2387 EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt());
2388 EXPECT_EQ(1u, manager_.GetConsecutiveRtoCount());
2389 EXPECT_EQ(2u, manager_.GetConsecutiveTlpCount());
2390}
2391
2392TEST_P(QuicSentPacketManagerTest, PathMtuIncreased) {
2393 EXPECT_CALL(*send_algorithm_,
2394 OnPacketSent(_, BytesInFlight(), QuicPacketNumber(1), _, _));
2395 SerializedPacket packet(QuicPacketNumber(1), PACKET_4BYTE_PACKET_NUMBER,
2396 nullptr, kDefaultLength + 100, false, false);
2397 manager_.OnPacketSent(&packet, QuicPacketNumber(), clock_.Now(),
2398 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
2399
2400 // Ack the large packet and expect the path MTU to increase.
2401 ExpectAck(1);
2402 EXPECT_CALL(*network_change_visitor_,
2403 OnPathMtuIncreased(kDefaultLength + 100));
2404 QuicAckFrame ack_frame = InitAckFrame(1);
2405 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
2406 clock_.Now());
2407 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
2408 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
2409}
2410
2411TEST_P(QuicSentPacketManagerTest, OnAckRangeSlowPath) {
2412 // Send packets 1 - 20.
2413 for (size_t i = 1; i <= 20; ++i) {
2414 SendDataPacket(i);
2415 }
2416 // Ack [5, 7), [10, 12), [15, 17).
2417 uint64_t acked1[] = {5, 6, 10, 11, 15, 16};
2418 uint64_t lost1[] = {1, 2, 3, 4, 7, 8, 9, 12, 13};
2419 ExpectAcksAndLosses(true, acked1, QUIC_ARRAYSIZE(acked1), lost1,
2420 QUIC_ARRAYSIZE(lost1));
2421 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(AnyNumber());
2422 manager_.OnAckFrameStart(QuicPacketNumber(16), QuicTime::Delta::Infinite(),
2423 clock_.Now());
2424 manager_.OnAckRange(QuicPacketNumber(15), QuicPacketNumber(17));
2425 manager_.OnAckRange(QuicPacketNumber(10), QuicPacketNumber(12));
2426 manager_.OnAckRange(QuicPacketNumber(5), QuicPacketNumber(7));
2427 // Make sure empty range does not harm.
2428 manager_.OnAckRange(QuicPacketNumber(4), QuicPacketNumber(4));
2429 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
2430
2431 // Ack [4, 8), [9, 13), [14, 21).
2432 uint64_t acked2[] = {4, 7, 9, 12, 14, 17, 18, 19, 20};
2433 ExpectAcksAndLosses(true, acked2, QUIC_ARRAYSIZE(acked2), nullptr, 0);
2434 manager_.OnAckFrameStart(QuicPacketNumber(20), QuicTime::Delta::Infinite(),
2435 clock_.Now());
2436 manager_.OnAckRange(QuicPacketNumber(14), QuicPacketNumber(21));
2437 manager_.OnAckRange(QuicPacketNumber(9), QuicPacketNumber(13));
2438 manager_.OnAckRange(QuicPacketNumber(4), QuicPacketNumber(8));
2439 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
2440}
2441
QUICHE team9929cc42019-03-13 08:17:43 -07002442TEST_P(QuicSentPacketManagerTest, TolerateReneging) {
2443 if (!manager_.tolerate_reneging()) {
2444 return;
2445 }
2446 // Send packets 1 - 20.
2447 for (size_t i = 1; i <= 20; ++i) {
2448 SendDataPacket(i);
2449 }
2450 // Ack [5, 7), [10, 12), [15, 17).
2451 uint64_t acked1[] = {5, 6, 10, 11, 15, 16};
2452 uint64_t lost1[] = {1, 2, 3, 4, 7, 8, 9, 12, 13};
2453 ExpectAcksAndLosses(true, acked1, QUIC_ARRAYSIZE(acked1), lost1,
2454 QUIC_ARRAYSIZE(lost1));
2455 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(AnyNumber());
2456 manager_.OnAckFrameStart(QuicPacketNumber(16), QuicTime::Delta::Infinite(),
2457 clock_.Now());
2458 manager_.OnAckRange(QuicPacketNumber(15), QuicPacketNumber(17));
2459 manager_.OnAckRange(QuicPacketNumber(10), QuicPacketNumber(12));
2460 manager_.OnAckRange(QuicPacketNumber(5), QuicPacketNumber(7));
2461 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
2462
2463 // Making sure reneged ACK does not harm. Ack [4, 8), [9, 13).
2464 uint64_t acked2[] = {4, 7, 9, 12};
2465 ExpectAcksAndLosses(true, acked2, QUIC_ARRAYSIZE(acked2), nullptr, 0);
2466 manager_.OnAckFrameStart(QuicPacketNumber(12), QuicTime::Delta::Infinite(),
2467 clock_.Now());
2468 manager_.OnAckRange(QuicPacketNumber(9), QuicPacketNumber(13));
2469 manager_.OnAckRange(QuicPacketNumber(4), QuicPacketNumber(8));
2470 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
2471 EXPECT_EQ(QuicPacketNumber(16), manager_.GetLargestObserved());
2472}
2473
QUICHE teamc279cec2019-03-22 06:51:48 -07002474TEST_P(QuicSentPacketManagerTest, MultiplePacketNumberSpaces) {
2475 if (!GetQuicReloadableFlag(quic_use_uber_loss_algorithm)) {
2476 return;
2477 }
2478 manager_.EnableMultiplePacketNumberSpacesSupport();
2479 EXPECT_FALSE(
2480 manager_.GetLargestSentPacket(ENCRYPTION_INITIAL).IsInitialized());
2481 EXPECT_FALSE(
2482 manager_.GetLargestAckedPacket(ENCRYPTION_INITIAL).IsInitialized());
2483 // Send packet 1.
2484 SendDataPacket(1, ENCRYPTION_INITIAL);
2485 EXPECT_EQ(QuicPacketNumber(1),
2486 manager_.GetLargestSentPacket(ENCRYPTION_INITIAL));
2487 EXPECT_FALSE(
2488 manager_.GetLargestSentPacket(ENCRYPTION_HANDSHAKE).IsInitialized());
2489 // Ack packet 1.
2490 ExpectAck(1);
2491 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
2492 clock_.Now());
2493 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
2494 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
2495 EXPECT_EQ(QuicPacketNumber(1),
2496 manager_.GetLargestAckedPacket(ENCRYPTION_INITIAL));
2497 EXPECT_FALSE(
2498 manager_.GetLargestAckedPacket(ENCRYPTION_HANDSHAKE).IsInitialized());
2499 // Send packets 2 and 3.
2500 SendDataPacket(2, ENCRYPTION_HANDSHAKE);
2501 SendDataPacket(3, ENCRYPTION_HANDSHAKE);
2502 EXPECT_EQ(QuicPacketNumber(1),
2503 manager_.GetLargestSentPacket(ENCRYPTION_INITIAL));
2504 EXPECT_EQ(QuicPacketNumber(3),
2505 manager_.GetLargestSentPacket(ENCRYPTION_HANDSHAKE));
2506 EXPECT_FALSE(
2507 manager_.GetLargestSentPacket(ENCRYPTION_ZERO_RTT).IsInitialized());
2508 // Ack packet 2.
2509 ExpectAck(2);
2510 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
2511 clock_.Now());
2512 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(3));
2513 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
2514 EXPECT_EQ(QuicPacketNumber(2),
2515 manager_.GetLargestAckedPacket(ENCRYPTION_HANDSHAKE));
2516 EXPECT_FALSE(
2517 manager_.GetLargestAckedPacket(ENCRYPTION_ZERO_RTT).IsInitialized());
2518 // Ack packet 3.
2519 ExpectAck(3);
2520 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
2521 clock_.Now());
2522 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(4));
2523 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
2524 EXPECT_EQ(QuicPacketNumber(3),
2525 manager_.GetLargestAckedPacket(ENCRYPTION_HANDSHAKE));
2526 EXPECT_FALSE(
2527 manager_.GetLargestAckedPacket(ENCRYPTION_ZERO_RTT).IsInitialized());
2528 // Send packets 4 and 5.
2529 SendDataPacket(4, ENCRYPTION_ZERO_RTT);
2530 SendDataPacket(5, ENCRYPTION_ZERO_RTT);
2531 EXPECT_EQ(QuicPacketNumber(1),
2532 manager_.GetLargestSentPacket(ENCRYPTION_INITIAL));
2533 EXPECT_EQ(QuicPacketNumber(3),
2534 manager_.GetLargestSentPacket(ENCRYPTION_HANDSHAKE));
2535 EXPECT_EQ(QuicPacketNumber(5),
2536 manager_.GetLargestSentPacket(ENCRYPTION_ZERO_RTT));
2537 EXPECT_EQ(QuicPacketNumber(5),
2538 manager_.GetLargestSentPacket(ENCRYPTION_FORWARD_SECURE));
2539 // Ack packet 5.
2540 ExpectAck(5);
2541 manager_.OnAckFrameStart(QuicPacketNumber(5), QuicTime::Delta::Infinite(),
2542 clock_.Now());
2543 manager_.OnAckRange(QuicPacketNumber(5), QuicPacketNumber(6));
2544 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
2545 EXPECT_EQ(QuicPacketNumber(3),
2546 manager_.GetLargestAckedPacket(ENCRYPTION_HANDSHAKE));
2547 EXPECT_EQ(QuicPacketNumber(5),
2548 manager_.GetLargestAckedPacket(ENCRYPTION_ZERO_RTT));
2549 EXPECT_EQ(QuicPacketNumber(5),
2550 manager_.GetLargestAckedPacket(ENCRYPTION_FORWARD_SECURE));
2551
2552 // Send packets 6 - 8.
2553 SendDataPacket(6, ENCRYPTION_FORWARD_SECURE);
2554 SendDataPacket(7, ENCRYPTION_FORWARD_SECURE);
2555 SendDataPacket(8, ENCRYPTION_FORWARD_SECURE);
2556 EXPECT_EQ(QuicPacketNumber(1),
2557 manager_.GetLargestSentPacket(ENCRYPTION_INITIAL));
2558 EXPECT_EQ(QuicPacketNumber(3),
2559 manager_.GetLargestSentPacket(ENCRYPTION_HANDSHAKE));
2560 EXPECT_EQ(QuicPacketNumber(8),
2561 manager_.GetLargestSentPacket(ENCRYPTION_ZERO_RTT));
2562 EXPECT_EQ(QuicPacketNumber(8),
2563 manager_.GetLargestSentPacket(ENCRYPTION_FORWARD_SECURE));
2564 // Ack all packets.
2565 uint64_t acked[] = {4, 6, 7, 8};
2566 ExpectAcksAndLosses(true, acked, QUIC_ARRAYSIZE(acked), nullptr, 0);
2567 manager_.OnAckFrameStart(QuicPacketNumber(8), QuicTime::Delta::Infinite(),
2568 clock_.Now());
2569 manager_.OnAckRange(QuicPacketNumber(4), QuicPacketNumber(9));
2570 EXPECT_TRUE(manager_.OnAckFrameEnd(clock_.Now()));
2571 EXPECT_EQ(QuicPacketNumber(3),
2572 manager_.GetLargestAckedPacket(ENCRYPTION_HANDSHAKE));
2573 EXPECT_EQ(QuicPacketNumber(8),
2574 manager_.GetLargestAckedPacket(ENCRYPTION_ZERO_RTT));
2575 EXPECT_EQ(QuicPacketNumber(8),
2576 manager_.GetLargestAckedPacket(ENCRYPTION_FORWARD_SECURE));
2577}
2578
QUICHE teama6ef0a62019-03-07 20:34:33 -05002579} // namespace
2580} // namespace test
2581} // namespace quic