1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "quiche/quic/core/quic_sent_packet_manager.h"
6
7 #include <memory>
8 #include <utility>
9
10 #include "absl/base/macros.h"
11 #include "absl/strings/string_view.h"
12 #include "quiche/quic/core/frames/quic_ack_frequency_frame.h"
13 #include "quiche/quic/core/quic_time.h"
14 #include "quiche/quic/core/quic_types.h"
15 #include "quiche/quic/platform/api/quic_expect_bug.h"
16 #include "quiche/quic/platform/api/quic_flags.h"
17 #include "quiche/quic/platform/api/quic_test.h"
18 #include "quiche/quic/test_tools/quic_config_peer.h"
19 #include "quiche/quic/test_tools/quic_sent_packet_manager_peer.h"
20 #include "quiche/quic/test_tools/quic_test_utils.h"
21 #include "quiche/common/platform/api/quiche_mem_slice.h"
22
23 using testing::_;
24 using testing::AnyNumber;
25 using testing::Invoke;
26 using testing::InvokeWithoutArgs;
27 using testing::IsEmpty;
28 using testing::Not;
29 using testing::Pointwise;
30 using testing::Return;
31 using testing::StrictMock;
32 using testing::WithArgs;
33
34 namespace quic {
35 namespace test {
36 namespace {
37 // Default packet length.
38 const uint32_t kDefaultLength = 1000;
39
40 // Stream ID for data sent in CreatePacket().
41 const QuicStreamId kStreamId = 7;
42
43 // The compiler won't allow std::nullopt as an argument.
44 const std::optional<QuicEcnCounts> kEmptyCounts = std::nullopt;
45
46 // Matcher to check that the packet number matches the second argument.
47 MATCHER(PacketNumberEq, "") {
48 return std::get<0>(arg).packet_number == QuicPacketNumber(std::get<1>(arg));
49 }
50
51 class MockDebugDelegate : public QuicSentPacketManager::DebugDelegate {
52 public:
53 MOCK_METHOD(void, OnSpuriousPacketRetransmission,
54 (TransmissionType transmission_type, QuicByteCount byte_size),
55 (override));
56 MOCK_METHOD(void, OnPacketLoss,
57 (QuicPacketNumber lost_packet_number,
58 EncryptionLevel encryption_level,
59 TransmissionType transmission_type, QuicTime detection_time),
60 (override));
61 };
62
63 class QuicSentPacketManagerTest : public QuicTest {
64 public:
RetransmitCryptoPacket(uint64_t packet_number)65 bool RetransmitCryptoPacket(uint64_t packet_number) {
66 EXPECT_CALL(
67 *send_algorithm_,
68 OnPacketSent(_, BytesInFlight(), QuicPacketNumber(packet_number),
69 kDefaultLength, HAS_RETRANSMITTABLE_DATA));
70 SerializedPacket packet(CreatePacket(packet_number, false));
71 packet.retransmittable_frames.push_back(
72 QuicFrame(QuicStreamFrame(1, false, 0, absl::string_view())));
73 packet.has_crypto_handshake = IS_HANDSHAKE;
74 manager_.OnPacketSent(&packet, clock_.Now(), HANDSHAKE_RETRANSMISSION,
75 HAS_RETRANSMITTABLE_DATA, true, ECN_NOT_ECT);
76 return true;
77 }
78
RetransmitDataPacket(uint64_t packet_number,TransmissionType type,EncryptionLevel level)79 bool RetransmitDataPacket(uint64_t packet_number, TransmissionType type,
80 EncryptionLevel level) {
81 EXPECT_CALL(
82 *send_algorithm_,
83 OnPacketSent(_, BytesInFlight(), QuicPacketNumber(packet_number),
84 kDefaultLength, HAS_RETRANSMITTABLE_DATA));
85 SerializedPacket packet(CreatePacket(packet_number, true));
86 packet.encryption_level = level;
87 manager_.OnPacketSent(&packet, clock_.Now(), type, HAS_RETRANSMITTABLE_DATA,
88 true, ECN_NOT_ECT);
89 return true;
90 }
91
RetransmitDataPacket(uint64_t packet_number,TransmissionType type)92 bool RetransmitDataPacket(uint64_t packet_number, TransmissionType type) {
93 return RetransmitDataPacket(packet_number, type, ENCRYPTION_INITIAL);
94 }
95
96 protected:
97 const CongestionControlType kInitialCongestionControlType = kCubicBytes;
QuicSentPacketManagerTest()98 QuicSentPacketManagerTest()
99 : manager_(Perspective::IS_SERVER, &clock_, QuicRandom::GetInstance(),
100 &stats_, kInitialCongestionControlType),
101 send_algorithm_(new StrictMock<MockSendAlgorithm>),
102 network_change_visitor_(new StrictMock<MockNetworkChangeVisitor>) {
103 QuicSentPacketManagerPeer::SetSendAlgorithm(&manager_, send_algorithm_);
104 // Advance the time 1s so the send times are never QuicTime::Zero.
105 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000));
106 manager_.SetNetworkChangeVisitor(network_change_visitor_.get());
107 manager_.SetSessionNotifier(¬ifier_);
108
109 EXPECT_CALL(*send_algorithm_, GetCongestionControlType())
110 .WillRepeatedly(Return(kInitialCongestionControlType));
111 EXPECT_CALL(*send_algorithm_, BandwidthEstimate())
112 .Times(AnyNumber())
113 .WillRepeatedly(Return(QuicBandwidth::Zero()));
114 EXPECT_CALL(*send_algorithm_, InSlowStart()).Times(AnyNumber());
115 EXPECT_CALL(*send_algorithm_, InRecovery()).Times(AnyNumber());
116 EXPECT_CALL(*send_algorithm_, OnPacketNeutered(_)).Times(AnyNumber());
117 EXPECT_CALL(*network_change_visitor_, OnPathMtuIncreased(1000))
118 .Times(AnyNumber());
119 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(true));
120 EXPECT_CALL(notifier_, HasUnackedCryptoData())
121 .WillRepeatedly(Return(false));
122 EXPECT_CALL(notifier_, OnStreamFrameRetransmitted(_)).Times(AnyNumber());
123 EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).WillRepeatedly(Return(true));
124 }
125
~QuicSentPacketManagerTest()126 ~QuicSentPacketManagerTest() override {}
127
BytesInFlight()128 QuicByteCount BytesInFlight() { return manager_.GetBytesInFlight(); }
VerifyUnackedPackets(uint64_t * packets,size_t num_packets)129 void VerifyUnackedPackets(uint64_t* packets, size_t num_packets) {
130 if (num_packets == 0) {
131 EXPECT_TRUE(manager_.unacked_packets().empty());
132 EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetNumRetransmittablePackets(
133 &manager_));
134 return;
135 }
136
137 EXPECT_FALSE(manager_.unacked_packets().empty());
138 EXPECT_EQ(QuicPacketNumber(packets[0]), manager_.GetLeastUnacked());
139 for (size_t i = 0; i < num_packets; ++i) {
140 EXPECT_TRUE(
141 manager_.unacked_packets().IsUnacked(QuicPacketNumber(packets[i])))
142 << packets[i];
143 }
144 }
145
VerifyRetransmittablePackets(uint64_t * packets,size_t num_packets)146 void VerifyRetransmittablePackets(uint64_t* packets, size_t num_packets) {
147 EXPECT_EQ(
148 num_packets,
149 QuicSentPacketManagerPeer::GetNumRetransmittablePackets(&manager_));
150 for (size_t i = 0; i < num_packets; ++i) {
151 EXPECT_TRUE(QuicSentPacketManagerPeer::HasRetransmittableFrames(
152 &manager_, packets[i]))
153 << " packets[" << i << "]:" << packets[i];
154 }
155 }
156
ExpectAck(uint64_t largest_observed)157 void ExpectAck(uint64_t largest_observed) {
158 EXPECT_CALL(
159 *send_algorithm_,
160 // Ensure the AckedPacketVector argument contains largest_observed.
161 OnCongestionEvent(true, _, _,
162 Pointwise(PacketNumberEq(), {largest_observed}),
163 IsEmpty(), _, _));
164 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
165 }
166
ExpectUpdatedRtt(uint64_t)167 void ExpectUpdatedRtt(uint64_t /*largest_observed*/) {
168 EXPECT_CALL(*send_algorithm_,
169 OnCongestionEvent(true, _, _, IsEmpty(), IsEmpty(), _, _));
170 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
171 }
172
ExpectAckAndLoss(bool rtt_updated,uint64_t largest_observed,uint64_t lost_packet)173 void ExpectAckAndLoss(bool rtt_updated, uint64_t largest_observed,
174 uint64_t lost_packet) {
175 EXPECT_CALL(
176 *send_algorithm_,
177 OnCongestionEvent(rtt_updated, _, _,
178 Pointwise(PacketNumberEq(), {largest_observed}),
179 Pointwise(PacketNumberEq(), {lost_packet}), _, _));
180 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
181 }
182
183 // |packets_acked| and |packets_lost| should be in packet number order.
ExpectAcksAndLosses(bool rtt_updated,uint64_t * packets_acked,size_t num_packets_acked,uint64_t * packets_lost,size_t num_packets_lost)184 void ExpectAcksAndLosses(bool rtt_updated, uint64_t* packets_acked,
185 size_t num_packets_acked, uint64_t* packets_lost,
186 size_t num_packets_lost) {
187 std::vector<QuicPacketNumber> ack_vector;
188 for (size_t i = 0; i < num_packets_acked; ++i) {
189 ack_vector.push_back(QuicPacketNumber(packets_acked[i]));
190 }
191 std::vector<QuicPacketNumber> lost_vector;
192 for (size_t i = 0; i < num_packets_lost; ++i) {
193 lost_vector.push_back(QuicPacketNumber(packets_lost[i]));
194 }
195 EXPECT_CALL(*send_algorithm_,
196 OnCongestionEvent(
197 rtt_updated, _, _, Pointwise(PacketNumberEq(), ack_vector),
198 Pointwise(PacketNumberEq(), lost_vector), _, _));
199 EXPECT_CALL(*network_change_visitor_, OnCongestionChange())
200 .Times(AnyNumber());
201 }
202
RetransmitAndSendPacket(uint64_t old_packet_number,uint64_t new_packet_number)203 void RetransmitAndSendPacket(uint64_t old_packet_number,
204 uint64_t new_packet_number) {
205 RetransmitAndSendPacket(old_packet_number, new_packet_number,
206 PTO_RETRANSMISSION);
207 }
208
RetransmitAndSendPacket(uint64_t old_packet_number,uint64_t new_packet_number,TransmissionType transmission_type)209 void RetransmitAndSendPacket(uint64_t old_packet_number,
210 uint64_t new_packet_number,
211 TransmissionType transmission_type) {
212 bool is_lost = false;
213 if (transmission_type == HANDSHAKE_RETRANSMISSION ||
214 transmission_type == PTO_RETRANSMISSION) {
215 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
216 .WillOnce(WithArgs<1>(
217 Invoke([this, new_packet_number](TransmissionType type) {
218 return RetransmitDataPacket(new_packet_number, type);
219 })));
220 } else {
221 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(1);
222 is_lost = true;
223 }
224 QuicSentPacketManagerPeer::MarkForRetransmission(
225 &manager_, old_packet_number, transmission_type);
226 if (!is_lost) {
227 return;
228 }
229 EXPECT_CALL(
230 *send_algorithm_,
231 OnPacketSent(_, BytesInFlight(), QuicPacketNumber(new_packet_number),
232 kDefaultLength, HAS_RETRANSMITTABLE_DATA));
233 SerializedPacket packet(CreatePacket(new_packet_number, true));
234 manager_.OnPacketSent(&packet, clock_.Now(), transmission_type,
235 HAS_RETRANSMITTABLE_DATA, true, ECN_NOT_ECT);
236 }
237
CreateDataPacket(uint64_t packet_number)238 SerializedPacket CreateDataPacket(uint64_t packet_number) {
239 return CreatePacket(packet_number, true);
240 }
241
CreatePacket(uint64_t packet_number,bool retransmittable)242 SerializedPacket CreatePacket(uint64_t packet_number, bool retransmittable) {
243 SerializedPacket packet(QuicPacketNumber(packet_number),
244 PACKET_4BYTE_PACKET_NUMBER, nullptr, kDefaultLength,
245 false, false);
246 if (retransmittable) {
247 packet.retransmittable_frames.push_back(
248 QuicFrame(QuicStreamFrame(kStreamId, false, 0, absl::string_view())));
249 }
250 return packet;
251 }
252
CreatePingPacket(uint64_t packet_number)253 SerializedPacket CreatePingPacket(uint64_t packet_number) {
254 SerializedPacket packet(QuicPacketNumber(packet_number),
255 PACKET_4BYTE_PACKET_NUMBER, nullptr, kDefaultLength,
256 false, false);
257 packet.retransmittable_frames.push_back(QuicFrame(QuicPingFrame()));
258 return packet;
259 }
260
SendDataPacket(uint64_t packet_number)261 void SendDataPacket(uint64_t packet_number) {
262 SendDataPacket(packet_number, ENCRYPTION_INITIAL, ECN_NOT_ECT);
263 }
264
SendDataPacket(uint64_t packet_number,EncryptionLevel encryption_level)265 void SendDataPacket(uint64_t packet_number,
266 EncryptionLevel encryption_level) {
267 SendDataPacket(packet_number, encryption_level, ECN_NOT_ECT);
268 }
269
SendDataPacket(uint64_t packet_number,EncryptionLevel encryption_level,QuicEcnCodepoint ecn_codepoint)270 void SendDataPacket(uint64_t packet_number, EncryptionLevel encryption_level,
271 QuicEcnCodepoint ecn_codepoint) {
272 EXPECT_CALL(*send_algorithm_,
273 OnPacketSent(_, BytesInFlight(),
274 QuicPacketNumber(packet_number), _, _));
275 SerializedPacket packet(CreateDataPacket(packet_number));
276 packet.encryption_level = encryption_level;
277 manager_.OnPacketSent(&packet, clock_.Now(), NOT_RETRANSMISSION,
278 HAS_RETRANSMITTABLE_DATA, true, ecn_codepoint);
279 }
280
SendPingPacket(uint64_t packet_number,EncryptionLevel encryption_level)281 void SendPingPacket(uint64_t packet_number,
282 EncryptionLevel encryption_level) {
283 EXPECT_CALL(*send_algorithm_,
284 OnPacketSent(_, BytesInFlight(),
285 QuicPacketNumber(packet_number), _, _));
286 SerializedPacket packet(CreatePingPacket(packet_number));
287 packet.encryption_level = encryption_level;
288 manager_.OnPacketSent(&packet, clock_.Now(), NOT_RETRANSMISSION,
289 HAS_RETRANSMITTABLE_DATA, true, ECN_NOT_ECT);
290 }
291
SendCryptoPacket(uint64_t packet_number)292 void SendCryptoPacket(uint64_t packet_number) {
293 EXPECT_CALL(
294 *send_algorithm_,
295 OnPacketSent(_, BytesInFlight(), QuicPacketNumber(packet_number),
296 kDefaultLength, HAS_RETRANSMITTABLE_DATA));
297 SerializedPacket packet(CreatePacket(packet_number, false));
298 packet.retransmittable_frames.push_back(
299 QuicFrame(QuicStreamFrame(1, false, 0, absl::string_view())));
300 packet.has_crypto_handshake = IS_HANDSHAKE;
301 manager_.OnPacketSent(&packet, clock_.Now(), NOT_RETRANSMISSION,
302 HAS_RETRANSMITTABLE_DATA, true, ECN_NOT_ECT);
303 EXPECT_CALL(notifier_, HasUnackedCryptoData()).WillRepeatedly(Return(true));
304 }
305
SendAckPacket(uint64_t packet_number,uint64_t largest_acked)306 void SendAckPacket(uint64_t packet_number, uint64_t largest_acked) {
307 SendAckPacket(packet_number, largest_acked, ENCRYPTION_INITIAL);
308 }
309
SendAckPacket(uint64_t packet_number,uint64_t largest_acked,EncryptionLevel level)310 void SendAckPacket(uint64_t packet_number, uint64_t largest_acked,
311 EncryptionLevel level) {
312 EXPECT_CALL(
313 *send_algorithm_,
314 OnPacketSent(_, BytesInFlight(), QuicPacketNumber(packet_number),
315 kDefaultLength, NO_RETRANSMITTABLE_DATA));
316 SerializedPacket packet(CreatePacket(packet_number, false));
317 packet.largest_acked = QuicPacketNumber(largest_acked);
318 packet.encryption_level = level;
319 manager_.OnPacketSent(&packet, clock_.Now(), NOT_RETRANSMISSION,
320 NO_RETRANSMITTABLE_DATA, true, ECN_NOT_ECT);
321 }
322
323 quiche::SimpleBufferAllocator allocator_;
324 QuicSentPacketManager manager_;
325 MockClock clock_;
326 QuicConnectionStats stats_;
327 MockSendAlgorithm* send_algorithm_;
328 std::unique_ptr<MockNetworkChangeVisitor> network_change_visitor_;
329 StrictMock<MockSessionNotifier> notifier_;
330 };
331
TEST_F(QuicSentPacketManagerTest,IsUnacked)332 TEST_F(QuicSentPacketManagerTest, IsUnacked) {
333 VerifyUnackedPackets(nullptr, 0);
334 SendDataPacket(1);
335
336 uint64_t unacked[] = {1};
337 VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
338 uint64_t retransmittable[] = {1};
339 VerifyRetransmittablePackets(retransmittable,
340 ABSL_ARRAYSIZE(retransmittable));
341 }
342
TEST_F(QuicSentPacketManagerTest,IsUnAckedRetransmit)343 TEST_F(QuicSentPacketManagerTest, IsUnAckedRetransmit) {
344 SendDataPacket(1);
345 RetransmitAndSendPacket(1, 2);
346
347 EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(&manager_, 2));
348 uint64_t unacked[] = {1, 2};
349 VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
350 std::vector<uint64_t> retransmittable = {1, 2};
351 VerifyRetransmittablePackets(&retransmittable[0], retransmittable.size());
352 }
353
TEST_F(QuicSentPacketManagerTest,RetransmitThenAck)354 TEST_F(QuicSentPacketManagerTest, RetransmitThenAck) {
355 SendDataPacket(1);
356 RetransmitAndSendPacket(1, 2);
357
358 // Ack 2 but not 1.
359 ExpectAck(2);
360 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
361 clock_.Now());
362 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(3));
363 EXPECT_EQ(PACKETS_NEWLY_ACKED,
364 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
365 ENCRYPTION_INITIAL, kEmptyCounts));
366 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
367 // Packet 1 is unacked, pending, but not retransmittable.
368 uint64_t unacked[] = {1};
369 VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
370 EXPECT_TRUE(manager_.HasInFlightPackets());
371 VerifyRetransmittablePackets(nullptr, 0);
372 }
373
TEST_F(QuicSentPacketManagerTest,RetransmitThenAckBeforeSend)374 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckBeforeSend) {
375 SendDataPacket(1);
376 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
377 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
378 return RetransmitDataPacket(2, type);
379 })));
380 QuicSentPacketManagerPeer::MarkForRetransmission(&manager_, 1,
381 PTO_RETRANSMISSION);
382 // Ack 1.
383 ExpectAck(1);
384 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
385 clock_.Now());
386 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
387 EXPECT_EQ(PACKETS_NEWLY_ACKED,
388 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
389 ENCRYPTION_INITIAL, kEmptyCounts));
390
391 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
392 uint64_t unacked[] = {2};
393 VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
394 // We do not know packet 2 is a spurious retransmission until it gets acked.
395 VerifyRetransmittablePackets(nullptr, 0);
396 EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted);
397 }
398
TEST_F(QuicSentPacketManagerTest,RetransmitThenStopRetransmittingBeforeSend)399 TEST_F(QuicSentPacketManagerTest, RetransmitThenStopRetransmittingBeforeSend) {
400 SendDataPacket(1);
401 EXPECT_CALL(notifier_, RetransmitFrames(_, _)).WillRepeatedly(Return(true));
402 QuicSentPacketManagerPeer::MarkForRetransmission(&manager_, 1,
403 PTO_RETRANSMISSION);
404
405 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
406
407 uint64_t unacked[] = {1};
408 VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
409 VerifyRetransmittablePackets(nullptr, 0);
410 EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted);
411 }
412
TEST_F(QuicSentPacketManagerTest,RetransmitThenAckPrevious)413 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPrevious) {
414 SendDataPacket(1);
415 RetransmitAndSendPacket(1, 2);
416 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
417 clock_.AdvanceTime(rtt);
418
419 // Ack 1 but not 2.
420 ExpectAck(1);
421 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
422 clock_.Now());
423 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
424 EXPECT_EQ(PACKETS_NEWLY_ACKED,
425 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
426 ENCRYPTION_INITIAL, kEmptyCounts));
427 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
428 // 2 remains unacked, but no packets have retransmittable data.
429 uint64_t unacked[] = {2};
430 VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
431 EXPECT_TRUE(manager_.HasInFlightPackets());
432 VerifyRetransmittablePackets(nullptr, 0);
433 // Ack 2 causes 2 be considered as spurious retransmission.
434 EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).WillOnce(Return(false));
435 ExpectAck(2);
436 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
437 clock_.Now());
438 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
439 EXPECT_EQ(PACKETS_NEWLY_ACKED,
440 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
441 ENCRYPTION_INITIAL, kEmptyCounts));
442
443 EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted);
444 }
445
TEST_F(QuicSentPacketManagerTest,RetransmitThenAckPreviousThenNackRetransmit)446 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPreviousThenNackRetransmit) {
447 SendDataPacket(1);
448 RetransmitAndSendPacket(1, 2);
449 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
450 clock_.AdvanceTime(rtt);
451
452 // First, ACK packet 1 which makes packet 2 non-retransmittable.
453 ExpectAck(1);
454 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
455 clock_.Now());
456 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
457 EXPECT_EQ(PACKETS_NEWLY_ACKED,
458 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
459 ENCRYPTION_INITIAL, kEmptyCounts));
460
461 SendDataPacket(3);
462 SendDataPacket(4);
463 SendDataPacket(5);
464 clock_.AdvanceTime(rtt);
465
466 // Next, NACK packet 2 three times.
467 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
468 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(1);
469 ExpectAckAndLoss(true, 3, 2);
470 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
471 clock_.Now());
472 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(4));
473 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
474 EXPECT_EQ(PACKETS_NEWLY_ACKED,
475 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
476 ENCRYPTION_INITIAL, kEmptyCounts));
477
478 ExpectAck(4);
479 manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
480 clock_.Now());
481 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(5));
482 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
483 EXPECT_EQ(PACKETS_NEWLY_ACKED,
484 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(3),
485 ENCRYPTION_INITIAL, kEmptyCounts));
486
487 ExpectAck(5);
488 manager_.OnAckFrameStart(QuicPacketNumber(5), QuicTime::Delta::Infinite(),
489 clock_.Now());
490 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(6));
491 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
492 EXPECT_EQ(PACKETS_NEWLY_ACKED,
493 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(4),
494 ENCRYPTION_INITIAL, kEmptyCounts));
495
496 uint64_t unacked[] = {2};
497 VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
498 EXPECT_FALSE(manager_.HasInFlightPackets());
499 VerifyRetransmittablePackets(nullptr, 0);
500
501 // Verify that the retransmission alarm would not fire,
502 // since there is no retransmittable data outstanding.
503 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
504 }
505
TEST_F(QuicSentPacketManagerTest,DISABLED_RetransmitTwiceThenAckPreviousBeforeSend)506 TEST_F(QuicSentPacketManagerTest,
507 DISABLED_RetransmitTwiceThenAckPreviousBeforeSend) {
508 SendDataPacket(1);
509 RetransmitAndSendPacket(1, 2);
510
511 // Fire the RTO, which will mark 2 for retransmission (but will not send it).
512 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
513 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
514 manager_.OnRetransmissionTimeout();
515
516 // Ack 1 but not 2, before 2 is able to be sent.
517 // Since 1 has been retransmitted, it has already been lost, and so the
518 // send algorithm is not informed that it has been ACK'd.
519 ExpectUpdatedRtt(1);
520 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
521 clock_.Now());
522 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
523 EXPECT_EQ(PACKETS_NEWLY_ACKED,
524 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
525 ENCRYPTION_INITIAL, kEmptyCounts));
526
527 // Since 2 was marked for retransmit, when 1 is acked, 2 is kept for RTT.
528 uint64_t unacked[] = {2};
529 VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
530 EXPECT_FALSE(manager_.HasInFlightPackets());
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
TEST_F(QuicSentPacketManagerTest,RetransmitTwiceThenAckFirst)538 TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckFirst) {
539 StrictMock<MockDebugDelegate> debug_delegate;
540 EXPECT_CALL(debug_delegate, OnSpuriousPacketRetransmission(PTO_RETRANSMISSION,
541 kDefaultLength))
542 .Times(1);
543 manager_.SetDebugDelegate(&debug_delegate);
544
545 SendDataPacket(1);
546 RetransmitAndSendPacket(1, 2);
547 RetransmitAndSendPacket(2, 3);
548 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
549 clock_.AdvanceTime(rtt);
550
551 // Ack 1 but not 2 or 3.
552 ExpectAck(1);
553 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
554 clock_.Now());
555 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
556 EXPECT_EQ(PACKETS_NEWLY_ACKED,
557 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
558 ENCRYPTION_INITIAL, kEmptyCounts));
559 // Frames in packets 2 and 3 are acked.
560 EXPECT_CALL(notifier_, IsFrameOutstanding(_))
561 .Times(2)
562 .WillRepeatedly(Return(false));
563
564 // 2 and 3 remain unacked, but no packets have retransmittable data.
565 uint64_t unacked[] = {2, 3};
566 VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
567 EXPECT_TRUE(manager_.HasInFlightPackets());
568 VerifyRetransmittablePackets(nullptr, 0);
569
570 // Ensure packet 2 is lost when 4 is sent and 3 and 4 are acked.
571 SendDataPacket(4);
572 // No new data gets acked in packet 3.
573 EXPECT_CALL(notifier_, OnFrameAcked(_, _, _))
574 .WillOnce(Return(false))
575 .WillRepeatedly(Return(true));
576 uint64_t acked[] = {3, 4};
577 ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
578 manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
579 clock_.Now());
580 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(5));
581 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
582 EXPECT_EQ(PACKETS_NEWLY_ACKED,
583 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
584 ENCRYPTION_INITIAL, kEmptyCounts));
585
586 uint64_t unacked2[] = {2};
587 VerifyUnackedPackets(unacked2, ABSL_ARRAYSIZE(unacked2));
588 EXPECT_TRUE(manager_.HasInFlightPackets());
589
590 SendDataPacket(5);
591 ExpectAckAndLoss(true, 5, 2);
592 EXPECT_CALL(debug_delegate,
593 OnPacketLoss(QuicPacketNumber(2), _, LOSS_RETRANSMISSION, _));
594 // Frames in all packets are acked.
595 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
596 // Notify session that stream frame in packet 2 gets lost although it is
597 // not outstanding.
598 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(1);
599 manager_.OnAckFrameStart(QuicPacketNumber(5), QuicTime::Delta::Infinite(),
600 clock_.Now());
601 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(6));
602 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
603 EXPECT_EQ(PACKETS_NEWLY_ACKED,
604 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(3),
605 ENCRYPTION_INITIAL, kEmptyCounts));
606
607 uint64_t unacked3[] = {2};
608 VerifyUnackedPackets(unacked3, ABSL_ARRAYSIZE(unacked3));
609 EXPECT_FALSE(manager_.HasInFlightPackets());
610 // Spurious retransmission is detected when packet 3 gets acked. We cannot
611 // know packet 2 is a spurious until it gets acked.
612 EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted);
613 EXPECT_EQ(1u, stats_.packets_lost);
614 EXPECT_LT(0.0, stats_.total_loss_detection_response_time);
615 EXPECT_LE(1u, stats_.sent_packets_max_sequence_reordering);
616 }
617
TEST_F(QuicSentPacketManagerTest,AckOriginalTransmission)618 TEST_F(QuicSentPacketManagerTest, AckOriginalTransmission) {
619 auto loss_algorithm = std::make_unique<MockLossAlgorithm>();
620 QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm.get());
621
622 SendDataPacket(1);
623 RetransmitAndSendPacket(1, 2);
624
625 // Ack original transmission, but that wasn't lost via fast retransmit,
626 // so no call on OnSpuriousRetransmission is expected.
627 {
628 ExpectAck(1);
629 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
630 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
631 clock_.Now());
632 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
633 EXPECT_EQ(PACKETS_NEWLY_ACKED,
634 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
635 ENCRYPTION_INITIAL, kEmptyCounts));
636 }
637
638 SendDataPacket(3);
639 SendDataPacket(4);
640 // Ack 4, which causes 3 to be retransmitted.
641 {
642 ExpectAck(4);
643 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
644 manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
645 clock_.Now());
646 manager_.OnAckRange(QuicPacketNumber(4), QuicPacketNumber(5));
647 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
648 EXPECT_EQ(PACKETS_NEWLY_ACKED,
649 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
650 ENCRYPTION_INITIAL, kEmptyCounts));
651 RetransmitAndSendPacket(3, 5, LOSS_RETRANSMISSION);
652 }
653
654 // Ack 3, which causes SpuriousRetransmitDetected to be called.
655 {
656 uint64_t acked[] = {3};
657 ExpectAcksAndLosses(false, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
658 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
659 EXPECT_CALL(*loss_algorithm,
660 SpuriousLossDetected(_, _, _, QuicPacketNumber(3),
661 QuicPacketNumber(4)));
662 manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
663 clock_.Now());
664 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(5));
665 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
666 EXPECT_EQ(0u, stats_.packet_spuriously_detected_lost);
667 EXPECT_EQ(PACKETS_NEWLY_ACKED,
668 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(3),
669 ENCRYPTION_INITIAL, kEmptyCounts));
670 EXPECT_EQ(1u, stats_.packet_spuriously_detected_lost);
671 // Ack 3 will not cause 5 be considered as a spurious retransmission. Ack
672 // 5 will cause 5 be considered as a spurious retransmission as no new
673 // data gets acked.
674 ExpectAck(5);
675 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
676 EXPECT_CALL(notifier_, OnFrameAcked(_, _, _)).WillOnce(Return(false));
677 manager_.OnAckFrameStart(QuicPacketNumber(5), QuicTime::Delta::Infinite(),
678 clock_.Now());
679 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(6));
680 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
681 EXPECT_EQ(PACKETS_NEWLY_ACKED,
682 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(4),
683 ENCRYPTION_INITIAL, kEmptyCounts));
684 }
685 }
686
TEST_F(QuicSentPacketManagerTest,GetLeastUnacked)687 TEST_F(QuicSentPacketManagerTest, GetLeastUnacked) {
688 EXPECT_EQ(QuicPacketNumber(1u), manager_.GetLeastUnacked());
689 }
690
TEST_F(QuicSentPacketManagerTest,GetLeastUnackedUnacked)691 TEST_F(QuicSentPacketManagerTest, GetLeastUnackedUnacked) {
692 SendDataPacket(1);
693 EXPECT_EQ(QuicPacketNumber(1u), manager_.GetLeastUnacked());
694 }
695
TEST_F(QuicSentPacketManagerTest,AckAckAndUpdateRtt)696 TEST_F(QuicSentPacketManagerTest, AckAckAndUpdateRtt) {
697 EXPECT_FALSE(manager_.largest_packet_peer_knows_is_acked().IsInitialized());
698 SendDataPacket(1);
699 SendAckPacket(2, 1);
700
701 // Now ack the ack and expect an RTT update.
702 uint64_t acked[] = {1, 2};
703 ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
704 manager_.OnAckFrameStart(QuicPacketNumber(2),
705 QuicTime::Delta::FromMilliseconds(5), clock_.Now());
706 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
707 EXPECT_EQ(PACKETS_NEWLY_ACKED,
708 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
709 ENCRYPTION_INITIAL, kEmptyCounts));
710 EXPECT_EQ(QuicPacketNumber(1), manager_.largest_packet_peer_knows_is_acked());
711
712 SendAckPacket(3, 3);
713
714 // Now ack the ack and expect only an RTT update.
715 uint64_t acked2[] = {3};
716 ExpectAcksAndLosses(true, acked2, ABSL_ARRAYSIZE(acked2), nullptr, 0);
717 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
718 clock_.Now());
719 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(4));
720 EXPECT_EQ(PACKETS_NEWLY_ACKED,
721 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
722 ENCRYPTION_INITIAL, kEmptyCounts));
723 EXPECT_EQ(QuicPacketNumber(3u),
724 manager_.largest_packet_peer_knows_is_acked());
725 }
726
TEST_F(QuicSentPacketManagerTest,Rtt)727 TEST_F(QuicSentPacketManagerTest, Rtt) {
728 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(20);
729 SendDataPacket(1);
730 clock_.AdvanceTime(expected_rtt);
731
732 ExpectAck(1);
733 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
734 clock_.Now());
735 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
736 EXPECT_EQ(PACKETS_NEWLY_ACKED,
737 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
738 ENCRYPTION_INITIAL, kEmptyCounts));
739 EXPECT_EQ(expected_rtt, manager_.GetRttStats()->latest_rtt());
740 }
741
TEST_F(QuicSentPacketManagerTest,RttWithInvalidDelta)742 TEST_F(QuicSentPacketManagerTest, RttWithInvalidDelta) {
743 // Expect that the RTT is equal to the local time elapsed, since the
744 // ack_delay_time is larger than the local time elapsed
745 // and is hence invalid.
746 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10);
747 SendDataPacket(1);
748 clock_.AdvanceTime(expected_rtt);
749
750 ExpectAck(1);
751 manager_.OnAckFrameStart(QuicPacketNumber(1),
752 QuicTime::Delta::FromMilliseconds(11), clock_.Now());
753 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
754 EXPECT_EQ(PACKETS_NEWLY_ACKED,
755 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
756 ENCRYPTION_INITIAL, kEmptyCounts));
757 EXPECT_EQ(expected_rtt, manager_.GetRttStats()->latest_rtt());
758 }
759
TEST_F(QuicSentPacketManagerTest,RttWithInfiniteDelta)760 TEST_F(QuicSentPacketManagerTest, RttWithInfiniteDelta) {
761 // Expect that the RTT is equal to the local time elapsed, since the
762 // ack_delay_time is infinite, and is hence invalid.
763 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10);
764 SendDataPacket(1);
765 clock_.AdvanceTime(expected_rtt);
766
767 ExpectAck(1);
768 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
769 clock_.Now());
770 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
771 EXPECT_EQ(PACKETS_NEWLY_ACKED,
772 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
773 ENCRYPTION_INITIAL, kEmptyCounts));
774 EXPECT_EQ(expected_rtt, manager_.GetRttStats()->latest_rtt());
775 }
776
TEST_F(QuicSentPacketManagerTest,RttWithDeltaExceedingLimit)777 TEST_F(QuicSentPacketManagerTest, RttWithDeltaExceedingLimit) {
778 // Initialize min and smoothed rtt to 10ms.
779 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
780 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(10),
781 QuicTime::Delta::Zero(), QuicTime::Zero());
782
783 QuicTime::Delta send_delta = QuicTime::Delta::FromMilliseconds(100);
784 QuicTime::Delta ack_delay =
785 QuicTime::Delta::FromMilliseconds(5) + manager_.peer_max_ack_delay();
786 ASSERT_GT(send_delta - rtt_stats->min_rtt(), ack_delay);
787 SendDataPacket(1);
788 clock_.AdvanceTime(send_delta);
789
790 ExpectAck(1);
791 manager_.OnAckFrameStart(QuicPacketNumber(1), ack_delay, clock_.Now());
792 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
793 EXPECT_EQ(PACKETS_NEWLY_ACKED,
794 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
795 ENCRYPTION_FORWARD_SECURE, kEmptyCounts));
796
797 QuicTime::Delta expected_rtt_sample =
798 send_delta - manager_.peer_max_ack_delay();
799 EXPECT_EQ(expected_rtt_sample, manager_.GetRttStats()->latest_rtt());
800 }
801
TEST_F(QuicSentPacketManagerTest,RttZeroDelta)802 TEST_F(QuicSentPacketManagerTest, RttZeroDelta) {
803 // Expect that the RTT is the time between send and receive since the
804 // ack_delay_time is zero.
805 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10);
806 SendDataPacket(1);
807 clock_.AdvanceTime(expected_rtt);
808
809 ExpectAck(1);
810 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Zero(),
811 clock_.Now());
812 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
813 EXPECT_EQ(PACKETS_NEWLY_ACKED,
814 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
815 ENCRYPTION_INITIAL, kEmptyCounts));
816 EXPECT_EQ(expected_rtt, manager_.GetRttStats()->latest_rtt());
817 }
818
TEST_F(QuicSentPacketManagerTest,CryptoHandshakeTimeout)819 TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeout) {
820 // Send 2 crypto packets and 3 data packets.
821 const size_t kNumSentCryptoPackets = 2;
822 for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) {
823 SendCryptoPacket(i);
824 }
825 const size_t kNumSentDataPackets = 3;
826 for (size_t i = 1; i <= kNumSentDataPackets; ++i) {
827 SendDataPacket(kNumSentCryptoPackets + i);
828 }
829 EXPECT_TRUE(manager_.HasUnackedCryptoPackets());
830 EXPECT_EQ(5 * kDefaultLength, manager_.GetBytesInFlight());
831
832 // The first retransmits 2 packets.
833 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
834 .Times(2)
835 .WillOnce(
836 InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(6); }))
837 .WillOnce(
838 InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(7); }));
839 manager_.OnRetransmissionTimeout();
840 // Expect all 4 handshake packets to be in flight and 3 data packets.
841 EXPECT_EQ(7 * kDefaultLength, manager_.GetBytesInFlight());
842 EXPECT_TRUE(manager_.HasUnackedCryptoPackets());
843
844 // The second retransmits 2 packets.
845 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
846 .Times(2)
847 .WillOnce(
848 InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(8); }))
849 .WillOnce(
850 InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(9); }));
851 manager_.OnRetransmissionTimeout();
852 EXPECT_EQ(9 * kDefaultLength, manager_.GetBytesInFlight());
853 EXPECT_TRUE(manager_.HasUnackedCryptoPackets());
854
855 // Now ack the two crypto packets and the speculatively encrypted request,
856 // and ensure the first four crypto packets get abandoned, but not lost.
857 // Crypto packets remain in flight, so any that aren't acked will be lost.
858 uint64_t acked[] = {3, 4, 5, 8, 9};
859 uint64_t lost[] = {1, 2, 6};
860 ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), lost,
861 ABSL_ARRAYSIZE(lost));
862 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(3);
863 EXPECT_CALL(notifier_, HasUnackedCryptoData()).WillRepeatedly(Return(false));
864 manager_.OnAckFrameStart(QuicPacketNumber(9), QuicTime::Delta::Infinite(),
865 clock_.Now());
866 manager_.OnAckRange(QuicPacketNumber(8), QuicPacketNumber(10));
867 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(6));
868 EXPECT_EQ(PACKETS_NEWLY_ACKED,
869 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
870 ENCRYPTION_INITIAL, kEmptyCounts));
871
872 EXPECT_FALSE(manager_.HasUnackedCryptoPackets());
873 }
874
TEST_F(QuicSentPacketManagerTest,CryptoHandshakeSpuriousRetransmission)875 TEST_F(QuicSentPacketManagerTest, CryptoHandshakeSpuriousRetransmission) {
876 // Send 1 crypto packet.
877 SendCryptoPacket(1);
878 EXPECT_TRUE(manager_.HasUnackedCryptoPackets());
879
880 // Retransmit the crypto packet as 2.
881 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
882 .WillOnce(
883 InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(2); }));
884 manager_.OnRetransmissionTimeout();
885
886 // Retransmit the crypto packet as 3.
887 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
888 .WillOnce(
889 InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(3); }));
890 manager_.OnRetransmissionTimeout();
891
892 // Now ack the second crypto packet, and ensure the first gets removed, but
893 // the third does not.
894 uint64_t acked[] = {2};
895 ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
896 EXPECT_CALL(notifier_, HasUnackedCryptoData()).WillRepeatedly(Return(false));
897 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
898 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
899 clock_.Now());
900 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(3));
901 EXPECT_EQ(PACKETS_NEWLY_ACKED,
902 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
903 ENCRYPTION_INITIAL, kEmptyCounts));
904
905 EXPECT_FALSE(manager_.HasUnackedCryptoPackets());
906 uint64_t unacked[] = {1, 3};
907 VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
908 }
909
TEST_F(QuicSentPacketManagerTest,CryptoHandshakeTimeoutUnsentDataPacket)910 TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeoutUnsentDataPacket) {
911 // Send 2 crypto packets and 1 data packet.
912 const size_t kNumSentCryptoPackets = 2;
913 for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) {
914 SendCryptoPacket(i);
915 }
916 SendDataPacket(3);
917 EXPECT_TRUE(manager_.HasUnackedCryptoPackets());
918
919 // Retransmit 2 crypto packets, but not the serialized packet.
920 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
921 .Times(2)
922 .WillOnce(
923 InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(4); }))
924 .WillOnce(
925 InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(5); }));
926 manager_.OnRetransmissionTimeout();
927 EXPECT_TRUE(manager_.HasUnackedCryptoPackets());
928 }
929
TEST_F(QuicSentPacketManagerTest,CryptoHandshakeRetransmissionThenNeuterAndAck)930 TEST_F(QuicSentPacketManagerTest,
931 CryptoHandshakeRetransmissionThenNeuterAndAck) {
932 // Send 1 crypto packet.
933 SendCryptoPacket(1);
934
935 EXPECT_TRUE(manager_.HasUnackedCryptoPackets());
936
937 // Retransmit the crypto packet as 2.
938 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
939 .WillOnce(
940 InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(2); }));
941 manager_.OnRetransmissionTimeout();
942 EXPECT_TRUE(manager_.HasUnackedCryptoPackets());
943
944 // Retransmit the crypto packet as 3.
945 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
946 .WillOnce(
947 InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(3); }));
948 manager_.OnRetransmissionTimeout();
949 EXPECT_TRUE(manager_.HasUnackedCryptoPackets());
950
951 // Now neuter all unacked unencrypted packets, which occurs when the
952 // connection goes forward secure.
953 EXPECT_CALL(notifier_, HasUnackedCryptoData()).WillRepeatedly(Return(false));
954 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
955 manager_.NeuterUnencryptedPackets();
956 EXPECT_FALSE(manager_.HasUnackedCryptoPackets());
957 uint64_t unacked[] = {1, 2, 3};
958 VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
959 VerifyRetransmittablePackets(nullptr, 0);
960 EXPECT_FALSE(manager_.HasUnackedCryptoPackets());
961 EXPECT_FALSE(manager_.HasInFlightPackets());
962
963 // Ensure both packets get discarded when packet 2 is acked.
964 uint64_t acked[] = {3};
965 ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
966 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
967 clock_.Now());
968 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(4));
969 EXPECT_EQ(PACKETS_NEWLY_ACKED,
970 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
971 ENCRYPTION_INITIAL, kEmptyCounts));
972 VerifyUnackedPackets(nullptr, 0);
973 VerifyRetransmittablePackets(nullptr, 0);
974 }
975
TEST_F(QuicSentPacketManagerTest,GetTransmissionTime)976 TEST_F(QuicSentPacketManagerTest, GetTransmissionTime) {
977 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
978 }
979
TEST_F(QuicSentPacketManagerTest,GetTransmissionTimeCryptoHandshake)980 TEST_F(QuicSentPacketManagerTest, GetTransmissionTimeCryptoHandshake) {
981 QuicTime crypto_packet_send_time = clock_.Now();
982 SendCryptoPacket(1);
983
984 // Check the min.
985 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
986 rtt_stats->set_initial_rtt(QuicTime::Delta::FromMilliseconds(1));
987 EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromMilliseconds(10),
988 manager_.GetRetransmissionTime());
989
990 // Test with a standard smoothed RTT.
991 rtt_stats->set_initial_rtt(QuicTime::Delta::FromMilliseconds(100));
992
993 QuicTime::Delta srtt = rtt_stats->initial_rtt();
994 QuicTime expected_time = clock_.Now() + 1.5 * srtt;
995 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
996
997 // Retransmit the packet by invoking the retransmission timeout.
998 clock_.AdvanceTime(1.5 * srtt);
999 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1000 .WillOnce(
1001 InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(2); }));
1002 // When session decides what to write, crypto_packet_send_time gets updated.
1003 crypto_packet_send_time = clock_.Now();
1004 manager_.OnRetransmissionTimeout();
1005
1006 // The retransmission time should now be twice as far in the future.
1007 expected_time = crypto_packet_send_time + srtt * 2 * 1.5;
1008 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1009
1010 // Retransmit the packet for the 2nd time.
1011 clock_.AdvanceTime(2 * 1.5 * srtt);
1012 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1013 .WillOnce(
1014 InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(3); }));
1015 // When session decides what to write, crypto_packet_send_time gets updated.
1016 crypto_packet_send_time = clock_.Now();
1017 manager_.OnRetransmissionTimeout();
1018
1019 // Verify exponential backoff of the retransmission timeout.
1020 expected_time = crypto_packet_send_time + srtt * 4 * 1.5;
1021 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1022 }
1023
TEST_F(QuicSentPacketManagerTest,GetConservativeTransmissionTimeCryptoHandshake)1024 TEST_F(QuicSentPacketManagerTest,
1025 GetConservativeTransmissionTimeCryptoHandshake) {
1026 QuicConfig config;
1027 QuicTagVector options;
1028 options.push_back(kCONH);
1029 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1030 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1031 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1032 manager_.SetFromConfig(config);
1033 // Calling SetFromConfig requires mocking out some send algorithm methods.
1034 EXPECT_CALL(*send_algorithm_, PacingRate(_))
1035 .WillRepeatedly(Return(QuicBandwidth::Zero()));
1036 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
1037 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
1038
1039 QuicTime crypto_packet_send_time = clock_.Now();
1040 SendCryptoPacket(1);
1041
1042 // Check the min.
1043 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
1044 rtt_stats->set_initial_rtt(QuicTime::Delta::FromMilliseconds(1));
1045 EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromMilliseconds(25),
1046 manager_.GetRetransmissionTime());
1047
1048 // Test with a standard smoothed RTT.
1049 rtt_stats->set_initial_rtt(QuicTime::Delta::FromMilliseconds(100));
1050
1051 QuicTime::Delta srtt = rtt_stats->initial_rtt();
1052 QuicTime expected_time = clock_.Now() + 2 * srtt;
1053 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1054
1055 // Retransmit the packet by invoking the retransmission timeout.
1056 clock_.AdvanceTime(2 * srtt);
1057 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1058 .WillOnce(
1059 InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(2); }));
1060 crypto_packet_send_time = clock_.Now();
1061 manager_.OnRetransmissionTimeout();
1062
1063 // The retransmission time should now be twice as far in the future.
1064 expected_time = crypto_packet_send_time + srtt * 2 * 2;
1065 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
1066 }
1067
TEST_F(QuicSentPacketManagerTest,GetLossDelay)1068 TEST_F(QuicSentPacketManagerTest, GetLossDelay) {
1069 auto loss_algorithm = std::make_unique<MockLossAlgorithm>();
1070 QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm.get());
1071
1072 EXPECT_CALL(*loss_algorithm, GetLossTimeout())
1073 .WillRepeatedly(Return(QuicTime::Zero()));
1074 SendDataPacket(1);
1075 SendDataPacket(2);
1076
1077 // Handle an ack which causes the loss algorithm to be evaluated and
1078 // set the loss timeout.
1079 ExpectAck(2);
1080 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
1081 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
1082 clock_.Now());
1083 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(3));
1084 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1085 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
1086 ENCRYPTION_INITIAL, kEmptyCounts));
1087
1088 QuicTime timeout(clock_.Now() + QuicTime::Delta::FromMilliseconds(10));
1089 EXPECT_CALL(*loss_algorithm, GetLossTimeout())
1090 .WillRepeatedly(Return(timeout));
1091 EXPECT_EQ(timeout, manager_.GetRetransmissionTime());
1092
1093 // Fire the retransmission timeout and ensure the loss detection algorithm
1094 // is invoked.
1095 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
1096 manager_.OnRetransmissionTimeout();
1097 }
1098
TEST_F(QuicSentPacketManagerTest,NegotiateIetfLossDetectionFromOptions)1099 TEST_F(QuicSentPacketManagerTest, NegotiateIetfLossDetectionFromOptions) {
1100 EXPECT_TRUE(
1101 QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled(&manager_));
1102 EXPECT_FALSE(
1103 QuicSentPacketManagerPeer::AdaptiveTimeThresholdEnabled(&manager_));
1104 EXPECT_EQ(kDefaultLossDelayShift,
1105 QuicSentPacketManagerPeer::GetReorderingShift(&manager_));
1106
1107 QuicConfig config;
1108 QuicTagVector options;
1109 options.push_back(kILD0);
1110 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1111 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1112 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1113 manager_.SetFromConfig(config);
1114
1115 EXPECT_EQ(3, QuicSentPacketManagerPeer::GetReorderingShift(&manager_));
1116 EXPECT_FALSE(
1117 QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled(&manager_));
1118 }
1119
TEST_F(QuicSentPacketManagerTest,NegotiateIetfLossDetectionOneFourthRttFromOptions)1120 TEST_F(QuicSentPacketManagerTest,
1121 NegotiateIetfLossDetectionOneFourthRttFromOptions) {
1122 EXPECT_TRUE(
1123 QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled(&manager_));
1124 EXPECT_FALSE(
1125 QuicSentPacketManagerPeer::AdaptiveTimeThresholdEnabled(&manager_));
1126 EXPECT_EQ(kDefaultLossDelayShift,
1127 QuicSentPacketManagerPeer::GetReorderingShift(&manager_));
1128
1129 QuicConfig config;
1130 QuicTagVector options;
1131 options.push_back(kILD1);
1132 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1133 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1134 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1135 manager_.SetFromConfig(config);
1136
1137 EXPECT_EQ(kDefaultLossDelayShift,
1138 QuicSentPacketManagerPeer::GetReorderingShift(&manager_));
1139 EXPECT_FALSE(
1140 QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled(&manager_));
1141 }
1142
TEST_F(QuicSentPacketManagerTest,NegotiateIetfLossDetectionAdaptiveReorderingThreshold)1143 TEST_F(QuicSentPacketManagerTest,
1144 NegotiateIetfLossDetectionAdaptiveReorderingThreshold) {
1145 EXPECT_TRUE(
1146 QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled(&manager_));
1147 EXPECT_FALSE(
1148 QuicSentPacketManagerPeer::AdaptiveTimeThresholdEnabled(&manager_));
1149 EXPECT_EQ(kDefaultLossDelayShift,
1150 QuicSentPacketManagerPeer::GetReorderingShift(&manager_));
1151
1152 QuicConfig config;
1153 QuicTagVector options;
1154 options.push_back(kILD2);
1155 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1156 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1157 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1158 manager_.SetFromConfig(config);
1159
1160 EXPECT_EQ(3, QuicSentPacketManagerPeer::GetReorderingShift(&manager_));
1161 EXPECT_TRUE(
1162 QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled(&manager_));
1163 }
1164
TEST_F(QuicSentPacketManagerTest,NegotiateIetfLossDetectionAdaptiveReorderingThreshold2)1165 TEST_F(QuicSentPacketManagerTest,
1166 NegotiateIetfLossDetectionAdaptiveReorderingThreshold2) {
1167 EXPECT_TRUE(
1168 QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled(&manager_));
1169 EXPECT_FALSE(
1170 QuicSentPacketManagerPeer::AdaptiveTimeThresholdEnabled(&manager_));
1171 EXPECT_EQ(kDefaultLossDelayShift,
1172 QuicSentPacketManagerPeer::GetReorderingShift(&manager_));
1173
1174 QuicConfig config;
1175 QuicTagVector options;
1176 options.push_back(kILD3);
1177 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1178 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1179 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1180 manager_.SetFromConfig(config);
1181 EXPECT_EQ(kDefaultLossDelayShift,
1182 QuicSentPacketManagerPeer::GetReorderingShift(&manager_));
1183 EXPECT_TRUE(
1184 QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled(&manager_));
1185 }
1186
TEST_F(QuicSentPacketManagerTest,NegotiateIetfLossDetectionAdaptiveReorderingAndTimeThreshold)1187 TEST_F(QuicSentPacketManagerTest,
1188 NegotiateIetfLossDetectionAdaptiveReorderingAndTimeThreshold) {
1189 EXPECT_TRUE(
1190 QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled(&manager_));
1191 EXPECT_FALSE(
1192 QuicSentPacketManagerPeer::AdaptiveTimeThresholdEnabled(&manager_));
1193 EXPECT_EQ(kDefaultLossDelayShift,
1194 QuicSentPacketManagerPeer::GetReorderingShift(&manager_));
1195
1196 QuicConfig config;
1197 QuicTagVector options;
1198 options.push_back(kILD4);
1199 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1200 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1201 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1202 manager_.SetFromConfig(config);
1203
1204 EXPECT_EQ(kDefaultLossDelayShift,
1205 QuicSentPacketManagerPeer::GetReorderingShift(&manager_));
1206 EXPECT_TRUE(
1207 QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled(&manager_));
1208 EXPECT_TRUE(
1209 QuicSentPacketManagerPeer::AdaptiveTimeThresholdEnabled(&manager_));
1210 }
1211
TEST_F(QuicSentPacketManagerTest,NegotiateCongestionControlFromOptions)1212 TEST_F(QuicSentPacketManagerTest, NegotiateCongestionControlFromOptions) {
1213 QuicConfig config;
1214 QuicTagVector options;
1215
1216 options.push_back(kRENO);
1217 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1218 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1219 manager_.SetFromConfig(config);
1220 EXPECT_EQ(kRenoBytes, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
1221 ->GetCongestionControlType());
1222
1223 options.clear();
1224 options.push_back(kTBBR);
1225 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1226 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1227 manager_.SetFromConfig(config);
1228 EXPECT_EQ(kBBR, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
1229 ->GetCongestionControlType());
1230
1231 options.clear();
1232 options.push_back(kBYTE);
1233 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1234 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1235 manager_.SetFromConfig(config);
1236 EXPECT_EQ(kCubicBytes, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
1237 ->GetCongestionControlType());
1238 options.clear();
1239 options.push_back(kRENO);
1240 options.push_back(kBYTE);
1241 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
1242 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1243 manager_.SetFromConfig(config);
1244 EXPECT_EQ(kRenoBytes, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
1245 ->GetCongestionControlType());
1246 }
1247
TEST_F(QuicSentPacketManagerTest,NegotiateClientCongestionControlFromOptions)1248 TEST_F(QuicSentPacketManagerTest, NegotiateClientCongestionControlFromOptions) {
1249 QuicConfig config;
1250 QuicTagVector options;
1251
1252 // No change if the server receives client options.
1253 const SendAlgorithmInterface* mock_sender =
1254 QuicSentPacketManagerPeer::GetSendAlgorithm(manager_);
1255 options.push_back(kRENO);
1256 config.SetClientConnectionOptions(options);
1257 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1258 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1259 manager_.SetFromConfig(config);
1260 EXPECT_EQ(mock_sender, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_));
1261
1262 // Change the congestion control on the client with client options.
1263 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
1264 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1265 manager_.SetFromConfig(config);
1266 EXPECT_EQ(kRenoBytes, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
1267 ->GetCongestionControlType());
1268
1269 options.clear();
1270 options.push_back(kTBBR);
1271 config.SetClientConnectionOptions(options);
1272 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1273 manager_.SetFromConfig(config);
1274 EXPECT_EQ(kBBR, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
1275 ->GetCongestionControlType());
1276
1277 options.clear();
1278 options.push_back(kBYTE);
1279 config.SetClientConnectionOptions(options);
1280 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1281 manager_.SetFromConfig(config);
1282 EXPECT_EQ(kCubicBytes, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
1283 ->GetCongestionControlType());
1284
1285 options.clear();
1286 options.push_back(kRENO);
1287 options.push_back(kBYTE);
1288 config.SetClientConnectionOptions(options);
1289 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1290 manager_.SetFromConfig(config);
1291 EXPECT_EQ(kRenoBytes, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
1292 ->GetCongestionControlType());
1293 }
1294
TEST_F(QuicSentPacketManagerTest,UseInitialRoundTripTimeToSend)1295 TEST_F(QuicSentPacketManagerTest, UseInitialRoundTripTimeToSend) {
1296 QuicTime::Delta initial_rtt = QuicTime::Delta::FromMilliseconds(325);
1297 EXPECT_NE(initial_rtt, manager_.GetRttStats()->smoothed_rtt());
1298
1299 QuicConfig config;
1300 config.SetInitialRoundTripTimeUsToSend(initial_rtt.ToMicroseconds());
1301 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
1302 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1303 manager_.SetFromConfig(config);
1304
1305 EXPECT_EQ(QuicTime::Delta::Zero(), manager_.GetRttStats()->smoothed_rtt());
1306 EXPECT_EQ(initial_rtt, manager_.GetRttStats()->initial_rtt());
1307 }
1308
TEST_F(QuicSentPacketManagerTest,ResumeConnectionState)1309 TEST_F(QuicSentPacketManagerTest, ResumeConnectionState) {
1310 // The sent packet manager should use the RTT from CachedNetworkParameters if
1311 // it is provided.
1312 const QuicTime::Delta kRtt = QuicTime::Delta::FromMilliseconds(123);
1313 CachedNetworkParameters cached_network_params;
1314 cached_network_params.set_min_rtt_ms(kRtt.ToMilliseconds());
1315
1316 SendAlgorithmInterface::NetworkParams params;
1317 params.bandwidth = QuicBandwidth::Zero();
1318 params.allow_cwnd_to_decrease = false;
1319 params.rtt = kRtt;
1320 params.is_rtt_trusted = true;
1321
1322 EXPECT_CALL(*send_algorithm_, AdjustNetworkParameters(params));
1323 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
1324 .Times(testing::AnyNumber());
1325 manager_.ResumeConnectionState(cached_network_params, false);
1326 EXPECT_EQ(kRtt, manager_.GetRttStats()->initial_rtt());
1327 }
1328
TEST_F(QuicSentPacketManagerTest,ConnectionMigrationUnspecifiedChange)1329 TEST_F(QuicSentPacketManagerTest, ConnectionMigrationUnspecifiedChange) {
1330 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
1331 QuicTime::Delta default_init_rtt = rtt_stats->initial_rtt();
1332 rtt_stats->set_initial_rtt(default_init_rtt * 2);
1333 EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt());
1334
1335 QuicSentPacketManagerPeer::SetConsecutivePtoCount(&manager_, 1);
1336 EXPECT_EQ(1u, manager_.GetConsecutivePtoCount());
1337
1338 EXPECT_CALL(*send_algorithm_, OnConnectionMigration());
1339 EXPECT_EQ(nullptr,
1340 manager_.OnConnectionMigration(/*reset_send_algorithm=*/false));
1341
1342 EXPECT_EQ(default_init_rtt, rtt_stats->initial_rtt());
1343 EXPECT_EQ(0u, manager_.GetConsecutivePtoCount());
1344 }
1345
1346 // Tests that ResetCongestionControlUponPeerAddressChange() resets send
1347 // algorithm and RTT. And unACK'ed packets are handled correctly.
TEST_F(QuicSentPacketManagerTest,ConnectionMigrationUnspecifiedChangeResetSendAlgorithm)1348 TEST_F(QuicSentPacketManagerTest,
1349 ConnectionMigrationUnspecifiedChangeResetSendAlgorithm) {
1350 auto loss_algorithm = std::make_unique<MockLossAlgorithm>();
1351 QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm.get());
1352
1353 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
1354 QuicTime::Delta default_init_rtt = rtt_stats->initial_rtt();
1355 rtt_stats->set_initial_rtt(default_init_rtt * 2);
1356 EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt());
1357
1358 QuicSentPacketManagerPeer::SetConsecutivePtoCount(&manager_, 1);
1359 EXPECT_EQ(1u, manager_.GetConsecutivePtoCount());
1360
1361 SendDataPacket(1, ENCRYPTION_FORWARD_SECURE);
1362
1363 RttStats old_rtt_stats;
1364 old_rtt_stats.CloneFrom(*manager_.GetRttStats());
1365
1366 // Packet1 will be mark for retransmission upon migration.
1367 EXPECT_CALL(notifier_, OnFrameLost(_));
1368 std::unique_ptr<SendAlgorithmInterface> old_send_algorithm =
1369 manager_.OnConnectionMigration(/*reset_send_algorithm=*/true);
1370
1371 EXPECT_NE(old_send_algorithm.get(), manager_.GetSendAlgorithm());
1372 EXPECT_EQ(old_send_algorithm->GetCongestionControlType(),
1373 manager_.GetSendAlgorithm()->GetCongestionControlType());
1374 EXPECT_EQ(default_init_rtt, rtt_stats->initial_rtt());
1375 EXPECT_EQ(0u, manager_.GetConsecutivePtoCount());
1376 // Packets sent earlier shouldn't be regarded as in flight.
1377 EXPECT_EQ(0u, BytesInFlight());
1378
1379 // Replace the new send algorithm with the mock object.
1380 manager_.SetSendAlgorithm(old_send_algorithm.release());
1381
1382 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
1383 // Application retransmit the data as LOSS_RETRANSMISSION.
1384 RetransmitDataPacket(2, LOSS_RETRANSMISSION, ENCRYPTION_FORWARD_SECURE);
1385 EXPECT_EQ(kDefaultLength, BytesInFlight());
1386
1387 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
1388 // Receiving an ACK for packet1 20s later shouldn't update the RTT, and
1389 // shouldn't be treated as spurious retransmission.
1390 EXPECT_CALL(
1391 *send_algorithm_,
1392 OnCongestionEvent(/*rtt_updated=*/false, kDefaultLength, _, _, _, _, _))
1393 .WillOnce(testing::WithArg<3>(
1394 Invoke([](const AckedPacketVector& acked_packets) {
1395 EXPECT_EQ(1u, acked_packets.size());
1396 EXPECT_EQ(QuicPacketNumber(1), acked_packets[0].packet_number);
1397 // The bytes in packet1 shouldn't contribute to congestion control.
1398 EXPECT_EQ(0u, acked_packets[0].bytes_acked);
1399 })));
1400 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1401 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
1402 clock_.Now());
1403 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
1404 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
1405 EXPECT_CALL(*loss_algorithm, SpuriousLossDetected(_, _, _, _, _)).Times(0u);
1406 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1407 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
1408 ENCRYPTION_FORWARD_SECURE, kEmptyCounts));
1409 EXPECT_TRUE(manager_.GetRttStats()->latest_rtt().IsZero());
1410
1411 // Receiving an ACK for packet2 should update RTT and congestion control.
1412 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
1413 clock_.Now());
1414 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(3));
1415 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
1416 EXPECT_CALL(
1417 *send_algorithm_,
1418 OnCongestionEvent(/*rtt_updated=*/true, kDefaultLength, _, _, _, _, _))
1419 .WillOnce(testing::WithArg<3>(
1420 Invoke([](const AckedPacketVector& acked_packets) {
1421 EXPECT_EQ(1u, acked_packets.size());
1422 EXPECT_EQ(QuicPacketNumber(2), acked_packets[0].packet_number);
1423 // The bytes in packet2 should contribute to congestion control.
1424 EXPECT_EQ(kDefaultLength, acked_packets[0].bytes_acked);
1425 })));
1426 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1427 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1428 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
1429 ENCRYPTION_FORWARD_SECURE, kEmptyCounts));
1430 EXPECT_EQ(0u, BytesInFlight());
1431 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10),
1432 manager_.GetRttStats()->latest_rtt());
1433
1434 SendDataPacket(3, ENCRYPTION_FORWARD_SECURE);
1435 // Trigger loss timeout and mark packet3 for retransmission.
1436 EXPECT_CALL(*loss_algorithm, GetLossTimeout())
1437 .WillOnce(Return(clock_.Now() + QuicTime::Delta::FromMilliseconds(10)));
1438 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _))
1439 .WillOnce(WithArgs<5>(Invoke([](LostPacketVector* packet_lost) {
1440 packet_lost->emplace_back(QuicPacketNumber(3u), kDefaultLength);
1441 return LossDetectionInterface::DetectionStats();
1442 })));
1443 EXPECT_CALL(notifier_, OnFrameLost(_));
1444 EXPECT_CALL(*send_algorithm_,
1445 OnCongestionEvent(false, kDefaultLength, _, _, _, _, _));
1446 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1447 manager_.OnRetransmissionTimeout();
1448 EXPECT_EQ(0u, BytesInFlight());
1449
1450 // Migrate again with unACK'ed but not in-flight packet.
1451 // Packet3 shouldn't be marked for retransmission again as it is not in
1452 // flight.
1453 old_send_algorithm =
1454 manager_.OnConnectionMigration(/*reset_send_algorithm=*/true);
1455
1456 EXPECT_NE(old_send_algorithm.get(), manager_.GetSendAlgorithm());
1457 EXPECT_EQ(old_send_algorithm->GetCongestionControlType(),
1458 manager_.GetSendAlgorithm()->GetCongestionControlType());
1459 EXPECT_EQ(default_init_rtt, rtt_stats->initial_rtt());
1460 EXPECT_EQ(0u, manager_.GetConsecutivePtoCount());
1461 EXPECT_EQ(0u, BytesInFlight());
1462 EXPECT_TRUE(manager_.GetRttStats()->latest_rtt().IsZero());
1463
1464 manager_.SetSendAlgorithm(old_send_algorithm.release());
1465
1466 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(30));
1467 // Receiving an ACK for packet3 shouldn't update RTT. Though packet 3 was
1468 // marked lost, this spurious retransmission shouldn't be reported to the loss
1469 // algorithm.
1470 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
1471 clock_.Now());
1472 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(4));
1473 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
1474 EXPECT_CALL(*loss_algorithm, SpuriousLossDetected(_, _, _, _, _)).Times(0u);
1475 EXPECT_CALL(*send_algorithm_,
1476 OnCongestionEvent(/*rtt_updated=*/false, 0, _, _, _, _, _));
1477 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1478 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1479 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(3),
1480 ENCRYPTION_FORWARD_SECURE, kEmptyCounts));
1481 EXPECT_EQ(0u, BytesInFlight());
1482 EXPECT_TRUE(manager_.GetRttStats()->latest_rtt().IsZero());
1483
1484 SendDataPacket(4, ENCRYPTION_FORWARD_SECURE);
1485 // Trigger loss timeout and mark packet4 for retransmission.
1486 EXPECT_CALL(*loss_algorithm, GetLossTimeout())
1487 .WillOnce(Return(clock_.Now() + QuicTime::Delta::FromMilliseconds(10)));
1488 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _))
1489 .WillOnce(WithArgs<5>(Invoke([](LostPacketVector* packet_lost) {
1490 packet_lost->emplace_back(QuicPacketNumber(4u), kDefaultLength);
1491 return LossDetectionInterface::DetectionStats();
1492 })));
1493 EXPECT_CALL(notifier_, OnFrameLost(_));
1494 EXPECT_CALL(*send_algorithm_,
1495 OnCongestionEvent(false, kDefaultLength, _, _, _, _, _));
1496 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1497 manager_.OnRetransmissionTimeout();
1498 EXPECT_EQ(0u, BytesInFlight());
1499
1500 // Application retransmit the data as LOSS_RETRANSMISSION.
1501 RetransmitDataPacket(5, LOSS_RETRANSMISSION, ENCRYPTION_FORWARD_SECURE);
1502 EXPECT_EQ(kDefaultLength, BytesInFlight());
1503
1504 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(30));
1505 // Receiving an ACK for packet4 should update RTT, but not bytes in flight.
1506 // This spurious retransmission should be reported to the loss algorithm.
1507 manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
1508 clock_.Now());
1509 manager_.OnAckRange(QuicPacketNumber(4), QuicPacketNumber(5));
1510 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
1511 EXPECT_CALL(*loss_algorithm, SpuriousLossDetected(_, _, _, _, _));
1512 EXPECT_CALL(
1513 *send_algorithm_,
1514 OnCongestionEvent(/*rtt_updated=*/true, kDefaultLength, _, _, _, _, _));
1515 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1516 EXPECT_CALL(notifier_, OnFrameAcked(_, _, _));
1517 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1518 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(3),
1519 ENCRYPTION_FORWARD_SECURE, kEmptyCounts));
1520 EXPECT_EQ(kDefaultLength, BytesInFlight());
1521 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(30),
1522 manager_.GetRttStats()->latest_rtt());
1523
1524 // Migrate again with in-flight packet5 whose retransmittable frames are all
1525 // ACKed. Packet5 should be marked for retransmission but nothing to
1526 // retransmit.
1527 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillOnce(Return(false));
1528 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(0u);
1529 old_send_algorithm =
1530 manager_.OnConnectionMigration(/*reset_send_algorithm=*/true);
1531 EXPECT_EQ(default_init_rtt, rtt_stats->initial_rtt());
1532 EXPECT_EQ(0u, manager_.GetConsecutivePtoCount());
1533 EXPECT_EQ(0u, BytesInFlight());
1534 EXPECT_TRUE(manager_.GetRttStats()->latest_rtt().IsZero());
1535
1536 manager_.SetSendAlgorithm(old_send_algorithm.release());
1537
1538 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
1539 // Receiving an ACK for packet5 shouldn't update RTT. Though packet 5 was
1540 // marked for retransmission, this spurious retransmission shouldn't be
1541 // reported to the loss algorithm.
1542 manager_.OnAckFrameStart(QuicPacketNumber(5), QuicTime::Delta::Infinite(),
1543 clock_.Now());
1544 manager_.OnAckRange(QuicPacketNumber(5), QuicPacketNumber(6));
1545 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
1546 EXPECT_CALL(*loss_algorithm, SpuriousLossDetected(_, _, _, _, _)).Times(0u);
1547 EXPECT_CALL(*send_algorithm_,
1548 OnCongestionEvent(/*rtt_updated=*/false, 0, _, _, _, _, _));
1549 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
1550 EXPECT_CALL(notifier_, OnFrameAcked(_, _, _));
1551 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1552 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(3),
1553 ENCRYPTION_FORWARD_SECURE, kEmptyCounts));
1554 EXPECT_EQ(0u, BytesInFlight());
1555 EXPECT_TRUE(manager_.GetRttStats()->latest_rtt().IsZero());
1556 }
1557
TEST_F(QuicSentPacketManagerTest,PathMtuIncreased)1558 TEST_F(QuicSentPacketManagerTest, PathMtuIncreased) {
1559 EXPECT_CALL(*send_algorithm_,
1560 OnPacketSent(_, BytesInFlight(), QuicPacketNumber(1), _, _));
1561 SerializedPacket packet(QuicPacketNumber(1), PACKET_4BYTE_PACKET_NUMBER,
1562 nullptr, kDefaultLength + 100, false, false);
1563 manager_.OnPacketSent(&packet, clock_.Now(), NOT_RETRANSMISSION,
1564 HAS_RETRANSMITTABLE_DATA, true, ECN_NOT_ECT);
1565
1566 // Ack the large packet and expect the path MTU to increase.
1567 ExpectAck(1);
1568 EXPECT_CALL(*network_change_visitor_,
1569 OnPathMtuIncreased(kDefaultLength + 100));
1570 QuicAckFrame ack_frame = InitAckFrame(1);
1571 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
1572 clock_.Now());
1573 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
1574 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1575 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
1576 ENCRYPTION_INITIAL, kEmptyCounts));
1577 }
1578
TEST_F(QuicSentPacketManagerTest,OnAckRangeSlowPath)1579 TEST_F(QuicSentPacketManagerTest, OnAckRangeSlowPath) {
1580 // Send packets 1 - 20.
1581 for (size_t i = 1; i <= 20; ++i) {
1582 SendDataPacket(i);
1583 }
1584 // Ack [5, 7), [10, 12), [15, 17).
1585 uint64_t acked1[] = {5, 6, 10, 11, 15, 16};
1586 uint64_t lost1[] = {1, 2, 3, 4, 7, 8, 9, 12, 13};
1587 ExpectAcksAndLosses(true, acked1, ABSL_ARRAYSIZE(acked1), lost1,
1588 ABSL_ARRAYSIZE(lost1));
1589 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(AnyNumber());
1590 manager_.OnAckFrameStart(QuicPacketNumber(16), QuicTime::Delta::Infinite(),
1591 clock_.Now());
1592 manager_.OnAckRange(QuicPacketNumber(15), QuicPacketNumber(17));
1593 manager_.OnAckRange(QuicPacketNumber(10), QuicPacketNumber(12));
1594 manager_.OnAckRange(QuicPacketNumber(5), QuicPacketNumber(7));
1595 // Make sure empty range does not harm.
1596 manager_.OnAckRange(QuicPacketNumber(4), QuicPacketNumber(4));
1597 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1598 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
1599 ENCRYPTION_INITIAL, kEmptyCounts));
1600
1601 // Ack [4, 8), [9, 13), [14, 21).
1602 uint64_t acked2[] = {4, 7, 9, 12, 14, 17, 18, 19, 20};
1603 ExpectAcksAndLosses(true, acked2, ABSL_ARRAYSIZE(acked2), nullptr, 0);
1604 manager_.OnAckFrameStart(QuicPacketNumber(20), QuicTime::Delta::Infinite(),
1605 clock_.Now());
1606 manager_.OnAckRange(QuicPacketNumber(14), QuicPacketNumber(21));
1607 manager_.OnAckRange(QuicPacketNumber(9), QuicPacketNumber(13));
1608 manager_.OnAckRange(QuicPacketNumber(4), QuicPacketNumber(8));
1609 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1610 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
1611 ENCRYPTION_INITIAL, kEmptyCounts));
1612 }
1613
TEST_F(QuicSentPacketManagerTest,TolerateReneging)1614 TEST_F(QuicSentPacketManagerTest, TolerateReneging) {
1615 // Send packets 1 - 20.
1616 for (size_t i = 1; i <= 20; ++i) {
1617 SendDataPacket(i);
1618 }
1619 // Ack [5, 7), [10, 12), [15, 17).
1620 uint64_t acked1[] = {5, 6, 10, 11, 15, 16};
1621 uint64_t lost1[] = {1, 2, 3, 4, 7, 8, 9, 12, 13};
1622 ExpectAcksAndLosses(true, acked1, ABSL_ARRAYSIZE(acked1), lost1,
1623 ABSL_ARRAYSIZE(lost1));
1624 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(AnyNumber());
1625 manager_.OnAckFrameStart(QuicPacketNumber(16), QuicTime::Delta::Infinite(),
1626 clock_.Now());
1627 manager_.OnAckRange(QuicPacketNumber(15), QuicPacketNumber(17));
1628 manager_.OnAckRange(QuicPacketNumber(10), QuicPacketNumber(12));
1629 manager_.OnAckRange(QuicPacketNumber(5), QuicPacketNumber(7));
1630 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1631 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
1632 ENCRYPTION_INITIAL, kEmptyCounts));
1633
1634 // Making sure reneged ACK does not harm. Ack [4, 8), [9, 13).
1635 uint64_t acked2[] = {4, 7, 9, 12};
1636 ExpectAcksAndLosses(true, acked2, ABSL_ARRAYSIZE(acked2), nullptr, 0);
1637 manager_.OnAckFrameStart(QuicPacketNumber(12), QuicTime::Delta::Infinite(),
1638 clock_.Now());
1639 manager_.OnAckRange(QuicPacketNumber(9), QuicPacketNumber(13));
1640 manager_.OnAckRange(QuicPacketNumber(4), QuicPacketNumber(8));
1641 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1642 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
1643 ENCRYPTION_INITIAL, kEmptyCounts));
1644 EXPECT_EQ(QuicPacketNumber(16), manager_.GetLargestObserved());
1645 }
1646
TEST_F(QuicSentPacketManagerTest,MultiplePacketNumberSpaces)1647 TEST_F(QuicSentPacketManagerTest, MultiplePacketNumberSpaces) {
1648 manager_.EnableMultiplePacketNumberSpacesSupport();
1649 const QuicUnackedPacketMap* unacked_packets =
1650 QuicSentPacketManagerPeer::GetUnackedPacketMap(&manager_);
1651 EXPECT_FALSE(
1652 unacked_packets
1653 ->GetLargestSentRetransmittableOfPacketNumberSpace(INITIAL_DATA)
1654 .IsInitialized());
1655 EXPECT_FALSE(
1656 manager_.GetLargestAckedPacket(ENCRYPTION_INITIAL).IsInitialized());
1657 // Send packet 1.
1658 SendDataPacket(1, ENCRYPTION_INITIAL);
1659 EXPECT_EQ(QuicPacketNumber(1),
1660 unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
1661 INITIAL_DATA));
1662 EXPECT_FALSE(
1663 unacked_packets
1664 ->GetLargestSentRetransmittableOfPacketNumberSpace(HANDSHAKE_DATA)
1665 .IsInitialized());
1666 // Ack packet 1.
1667 ExpectAck(1);
1668 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
1669 clock_.Now());
1670 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
1671 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1672 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
1673 ENCRYPTION_INITIAL, kEmptyCounts));
1674 EXPECT_EQ(QuicPacketNumber(1),
1675 manager_.GetLargestAckedPacket(ENCRYPTION_INITIAL));
1676 EXPECT_FALSE(
1677 manager_.GetLargestAckedPacket(ENCRYPTION_HANDSHAKE).IsInitialized());
1678 // Send packets 2 and 3.
1679 SendDataPacket(2, ENCRYPTION_HANDSHAKE);
1680 SendDataPacket(3, ENCRYPTION_HANDSHAKE);
1681 EXPECT_EQ(QuicPacketNumber(1),
1682 unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
1683 INITIAL_DATA));
1684 EXPECT_EQ(QuicPacketNumber(3),
1685 unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
1686 HANDSHAKE_DATA));
1687 EXPECT_FALSE(
1688 unacked_packets
1689 ->GetLargestSentRetransmittableOfPacketNumberSpace(APPLICATION_DATA)
1690 .IsInitialized());
1691 // Ack packet 2.
1692 ExpectAck(2);
1693 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
1694 clock_.Now());
1695 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(3));
1696 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1697 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
1698 ENCRYPTION_HANDSHAKE, kEmptyCounts));
1699 EXPECT_EQ(QuicPacketNumber(2),
1700 manager_.GetLargestAckedPacket(ENCRYPTION_HANDSHAKE));
1701 EXPECT_FALSE(
1702 manager_.GetLargestAckedPacket(ENCRYPTION_ZERO_RTT).IsInitialized());
1703 // Ack packet 3.
1704 ExpectAck(3);
1705 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
1706 clock_.Now());
1707 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(4));
1708 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1709 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(3),
1710 ENCRYPTION_HANDSHAKE, kEmptyCounts));
1711 EXPECT_EQ(QuicPacketNumber(3),
1712 manager_.GetLargestAckedPacket(ENCRYPTION_HANDSHAKE));
1713 EXPECT_FALSE(
1714 manager_.GetLargestAckedPacket(ENCRYPTION_ZERO_RTT).IsInitialized());
1715 // Send packets 4 and 5.
1716 SendDataPacket(4, ENCRYPTION_ZERO_RTT);
1717 SendDataPacket(5, ENCRYPTION_ZERO_RTT);
1718 EXPECT_EQ(QuicPacketNumber(1),
1719 unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
1720 INITIAL_DATA));
1721 EXPECT_EQ(QuicPacketNumber(3),
1722 unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
1723 HANDSHAKE_DATA));
1724 EXPECT_EQ(QuicPacketNumber(5),
1725 unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
1726 APPLICATION_DATA));
1727 // Ack packet 5.
1728 ExpectAck(5);
1729 manager_.OnAckFrameStart(QuicPacketNumber(5), QuicTime::Delta::Infinite(),
1730 clock_.Now());
1731 manager_.OnAckRange(QuicPacketNumber(5), QuicPacketNumber(6));
1732 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1733 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(4),
1734 ENCRYPTION_FORWARD_SECURE, kEmptyCounts));
1735 EXPECT_EQ(QuicPacketNumber(3),
1736 manager_.GetLargestAckedPacket(ENCRYPTION_HANDSHAKE));
1737 EXPECT_EQ(QuicPacketNumber(5),
1738 manager_.GetLargestAckedPacket(ENCRYPTION_ZERO_RTT));
1739 EXPECT_EQ(QuicPacketNumber(5),
1740 manager_.GetLargestAckedPacket(ENCRYPTION_FORWARD_SECURE));
1741
1742 // Send packets 6 - 8.
1743 SendDataPacket(6, ENCRYPTION_FORWARD_SECURE);
1744 SendDataPacket(7, ENCRYPTION_FORWARD_SECURE);
1745 SendDataPacket(8, ENCRYPTION_FORWARD_SECURE);
1746 EXPECT_EQ(QuicPacketNumber(1),
1747 unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
1748 INITIAL_DATA));
1749 EXPECT_EQ(QuicPacketNumber(3),
1750 unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
1751 HANDSHAKE_DATA));
1752 EXPECT_EQ(QuicPacketNumber(8),
1753 unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
1754 APPLICATION_DATA));
1755 // Ack all packets.
1756 uint64_t acked[] = {4, 6, 7, 8};
1757 ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
1758 manager_.OnAckFrameStart(QuicPacketNumber(8), QuicTime::Delta::Infinite(),
1759 clock_.Now());
1760 manager_.OnAckRange(QuicPacketNumber(4), QuicPacketNumber(9));
1761 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1762 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(5),
1763 ENCRYPTION_FORWARD_SECURE, kEmptyCounts));
1764 EXPECT_EQ(QuicPacketNumber(3),
1765 manager_.GetLargestAckedPacket(ENCRYPTION_HANDSHAKE));
1766 EXPECT_EQ(QuicPacketNumber(8),
1767 manager_.GetLargestAckedPacket(ENCRYPTION_ZERO_RTT));
1768 EXPECT_EQ(QuicPacketNumber(8),
1769 manager_.GetLargestAckedPacket(ENCRYPTION_FORWARD_SECURE));
1770 }
1771
TEST_F(QuicSentPacketManagerTest,PacketsGetAckedInWrongPacketNumberSpace)1772 TEST_F(QuicSentPacketManagerTest, PacketsGetAckedInWrongPacketNumberSpace) {
1773 manager_.EnableMultiplePacketNumberSpacesSupport();
1774 // Send packet 1.
1775 SendDataPacket(1, ENCRYPTION_INITIAL);
1776 // Send packets 2 and 3.
1777 SendDataPacket(2, ENCRYPTION_HANDSHAKE);
1778 SendDataPacket(3, ENCRYPTION_HANDSHAKE);
1779
1780 // ACK packets 2 and 3 in the wrong packet number space.
1781 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
1782 clock_.Now());
1783 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(4));
1784 EXPECT_EQ(PACKETS_ACKED_IN_WRONG_PACKET_NUMBER_SPACE,
1785 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
1786 ENCRYPTION_INITIAL, kEmptyCounts));
1787 }
1788
TEST_F(QuicSentPacketManagerTest,PacketsGetAckedInWrongPacketNumberSpace2)1789 TEST_F(QuicSentPacketManagerTest, PacketsGetAckedInWrongPacketNumberSpace2) {
1790 manager_.EnableMultiplePacketNumberSpacesSupport();
1791 // Send packet 1.
1792 SendDataPacket(1, ENCRYPTION_INITIAL);
1793 // Send packets 2 and 3.
1794 SendDataPacket(2, ENCRYPTION_HANDSHAKE);
1795 SendDataPacket(3, ENCRYPTION_HANDSHAKE);
1796
1797 // ACK packet 1 in the wrong packet number space.
1798 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
1799 clock_.Now());
1800 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(4));
1801 EXPECT_EQ(PACKETS_ACKED_IN_WRONG_PACKET_NUMBER_SPACE,
1802 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
1803 ENCRYPTION_HANDSHAKE, kEmptyCounts));
1804 }
1805
TEST_F(QuicSentPacketManagerTest,ToleratePacketsGetAckedInWrongPacketNumberSpace)1806 TEST_F(QuicSentPacketManagerTest,
1807 ToleratePacketsGetAckedInWrongPacketNumberSpace) {
1808 manager_.EnableMultiplePacketNumberSpacesSupport();
1809 // Send packet 1.
1810 SendDataPacket(1, ENCRYPTION_INITIAL);
1811 // Ack packet 1.
1812 ExpectAck(1);
1813 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
1814 clock_.Now());
1815 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
1816 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1817 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
1818 ENCRYPTION_INITIAL, kEmptyCounts));
1819
1820 // Send packets 2 and 3.
1821 SendDataPacket(2, ENCRYPTION_HANDSHAKE);
1822 SendDataPacket(3, ENCRYPTION_HANDSHAKE);
1823
1824 // Packet 1 gets acked in the wrong packet number space. Since packet 1 has
1825 // been acked in the correct packet number space, tolerate it.
1826 uint64_t acked[] = {2, 3};
1827 ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
1828 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
1829 clock_.Now());
1830 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(4));
1831 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1832 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
1833 ENCRYPTION_HANDSHAKE, kEmptyCounts));
1834 }
1835
TEST_F(QuicSentPacketManagerTest,ComputingProbeTimeout)1836 TEST_F(QuicSentPacketManagerTest, ComputingProbeTimeout) {
1837 EXPECT_CALL(*send_algorithm_, PacingRate(_))
1838 .WillRepeatedly(Return(QuicBandwidth::Zero()));
1839 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
1840 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
1841 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
1842 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
1843 QuicTime::Delta::Zero(), QuicTime::Zero());
1844 QuicTime::Delta srtt = rtt_stats->smoothed_rtt();
1845
1846 SendDataPacket(1, ENCRYPTION_FORWARD_SECURE);
1847 // Verify PTO is correctly set.
1848 QuicTime::Delta expected_pto_delay =
1849 srtt + kPtoRttvarMultiplier * rtt_stats->mean_deviation() +
1850 QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
1851 QuicTime packet1_sent_time = clock_.Now();
1852 EXPECT_EQ(clock_.Now() + expected_pto_delay,
1853 manager_.GetRetransmissionTime());
1854
1855 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
1856 SendDataPacket(2, ENCRYPTION_FORWARD_SECURE);
1857 // Verify PTO is set based on left edge.
1858 QuicTime deadline = packet1_sent_time + expected_pto_delay;
1859 EXPECT_EQ(deadline, manager_.GetRetransmissionTime());
1860 EXPECT_EQ(0u, stats_.pto_count);
1861
1862 // Invoke PTO.
1863 clock_.AdvanceTime(deadline - clock_.Now());
1864 manager_.OnRetransmissionTimeout();
1865 EXPECT_EQ(QuicTime::Delta::Zero(), manager_.TimeUntilSend(clock_.Now()));
1866 EXPECT_EQ(1u, stats_.pto_count);
1867 EXPECT_EQ(0u, stats_.max_consecutive_rto_with_forward_progress);
1868
1869 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1870 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
1871 return RetransmitDataPacket(3, type, ENCRYPTION_FORWARD_SECURE);
1872 })));
1873 manager_.MaybeSendProbePacket();
1874 // Verify PTO period gets set to twice the current value.
1875 QuicTime sent_time = clock_.Now();
1876 EXPECT_EQ(sent_time + expected_pto_delay * 2,
1877 manager_.GetRetransmissionTime());
1878
1879 // Received ACK for packets 1 and 2.
1880 uint64_t acked[] = {1, 2};
1881 ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
1882 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
1883 clock_.Now());
1884 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
1885 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1886 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
1887 ENCRYPTION_FORWARD_SECURE, kEmptyCounts));
1888 expected_pto_delay =
1889 rtt_stats->SmoothedOrInitialRtt() +
1890 std::max(kPtoRttvarMultiplier * rtt_stats->mean_deviation(),
1891 QuicTime::Delta::FromMilliseconds(1)) +
1892 QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
1893
1894 // Verify PTO is correctly re-armed based on sent time of packet 4.
1895 EXPECT_EQ(sent_time + expected_pto_delay, manager_.GetRetransmissionTime());
1896 EXPECT_EQ(1u, stats_.max_consecutive_rto_with_forward_progress);
1897 }
1898
TEST_F(QuicSentPacketManagerTest,SendOneProbePacket)1899 TEST_F(QuicSentPacketManagerTest, SendOneProbePacket) {
1900 EXPECT_CALL(*send_algorithm_, PacingRate(_))
1901 .WillRepeatedly(Return(QuicBandwidth::Zero()));
1902 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
1903 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
1904
1905 SendDataPacket(1, ENCRYPTION_FORWARD_SECURE);
1906 QuicTime packet1_sent_time = clock_.Now();
1907 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
1908 SendDataPacket(2, ENCRYPTION_FORWARD_SECURE);
1909
1910 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
1911 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
1912 QuicTime::Delta::Zero(), QuicTime::Zero());
1913 QuicTime::Delta srtt = rtt_stats->smoothed_rtt();
1914 // Verify PTO period is correctly set.
1915 QuicTime::Delta expected_pto_delay =
1916 srtt + kPtoRttvarMultiplier * rtt_stats->mean_deviation() +
1917 QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
1918 // Verify PTO is set based on left edge.
1919 QuicTime deadline = packet1_sent_time + expected_pto_delay;
1920 EXPECT_EQ(deadline, manager_.GetRetransmissionTime());
1921
1922 // Invoke PTO.
1923 clock_.AdvanceTime(deadline - clock_.Now());
1924 manager_.OnRetransmissionTimeout();
1925 EXPECT_EQ(QuicTime::Delta::Zero(), manager_.TimeUntilSend(clock_.Now()));
1926
1927 // Verify one probe packet gets sent.
1928 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
1929 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
1930 return RetransmitDataPacket(3, type, ENCRYPTION_FORWARD_SECURE);
1931 })));
1932 manager_.MaybeSendProbePacket();
1933 }
1934
TEST_F(QuicSentPacketManagerTest,DisableHandshakeModeClient)1935 TEST_F(QuicSentPacketManagerTest, DisableHandshakeModeClient) {
1936 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
1937 manager_.EnableMultiplePacketNumberSpacesSupport();
1938 // Send CHLO.
1939 SendCryptoPacket(1);
1940 EXPECT_NE(QuicTime::Zero(), manager_.GetRetransmissionTime());
1941 // Ack packet 1.
1942 ExpectAck(1);
1943 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
1944 clock_.Now());
1945 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
1946 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1947 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
1948 ENCRYPTION_INITIAL, kEmptyCounts));
1949 EXPECT_EQ(0u, manager_.GetBytesInFlight());
1950 // Verify retransmission timeout is not zero because handshake is not
1951 // confirmed although there is no in flight packet.
1952 EXPECT_NE(QuicTime::Zero(), manager_.GetRetransmissionTime());
1953 // Fire PTO.
1954 EXPECT_EQ(QuicSentPacketManager::PTO_MODE,
1955 manager_.OnRetransmissionTimeout());
1956 // Send handshake packet.
1957 SendDataPacket(2, ENCRYPTION_HANDSHAKE);
1958 // Ack packet 2.
1959 ExpectAck(2);
1960 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
1961 clock_.Now());
1962 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(3));
1963 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1964 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
1965 ENCRYPTION_HANDSHAKE, kEmptyCounts));
1966 // Verify retransmission timeout is zero because server has successfully
1967 // processed HANDSHAKE packet.
1968 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
1969 }
1970
TEST_F(QuicSentPacketManagerTest,DisableHandshakeModeServer)1971 TEST_F(QuicSentPacketManagerTest, DisableHandshakeModeServer) {
1972 manager_.EnableIetfPtoAndLossDetection();
1973 // Send SHLO.
1974 SendCryptoPacket(1);
1975 EXPECT_NE(QuicTime::Zero(), manager_.GetRetransmissionTime());
1976 // Ack packet 1.
1977 ExpectAck(1);
1978 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
1979 clock_.Now());
1980 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
1981 EXPECT_EQ(PACKETS_NEWLY_ACKED,
1982 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
1983 ENCRYPTION_INITIAL, kEmptyCounts));
1984 EXPECT_EQ(0u, manager_.GetBytesInFlight());
1985 // Verify retransmission timeout is not set on server side because there is
1986 // nothing in flight.
1987 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
1988 }
1989
TEST_F(QuicSentPacketManagerTest,PtoTimeoutRttVarMultiple)1990 TEST_F(QuicSentPacketManagerTest, PtoTimeoutRttVarMultiple) {
1991 EXPECT_CALL(*send_algorithm_, PacingRate(_))
1992 .WillRepeatedly(Return(QuicBandwidth::Zero()));
1993 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
1994 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
1995 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
1996 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
1997 QuicTime::Delta::Zero(), QuicTime::Zero());
1998 QuicTime::Delta srtt = rtt_stats->smoothed_rtt();
1999
2000 SendDataPacket(1, ENCRYPTION_FORWARD_SECURE);
2001 // Verify PTO is correctly set based on 2 times rtt var.
2002 QuicTime::Delta expected_pto_delay =
2003 srtt + kPtoRttvarMultiplier * rtt_stats->mean_deviation() +
2004 QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
2005 EXPECT_EQ(clock_.Now() + expected_pto_delay,
2006 manager_.GetRetransmissionTime());
2007 }
2008
TEST_F(QuicSentPacketManagerTest,IW10ForUpAndDown)2009 TEST_F(QuicSentPacketManagerTest, IW10ForUpAndDown) {
2010 QuicConfig config;
2011 QuicTagVector options;
2012 options.push_back(kBWS5);
2013 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
2014 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2015 EXPECT_CALL(*send_algorithm_, SetInitialCongestionWindowInPackets(10));
2016 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2017 manager_.SetFromConfig(config);
2018
2019 EXPECT_EQ(10u, manager_.initial_congestion_window());
2020 }
2021
TEST_F(QuicSentPacketManagerTest,ClientMultiplePacketNumberSpacePtoTimeout)2022 TEST_F(QuicSentPacketManagerTest, ClientMultiplePacketNumberSpacePtoTimeout) {
2023 manager_.EnableMultiplePacketNumberSpacesSupport();
2024 EXPECT_CALL(*send_algorithm_, PacingRate(_))
2025 .WillRepeatedly(Return(QuicBandwidth::Zero()));
2026 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
2027 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
2028 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2029 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
2030 QuicTime::Delta::Zero(), QuicTime::Zero());
2031 QuicTime::Delta srtt = rtt_stats->smoothed_rtt();
2032 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
2033
2034 // Send packet 1.
2035 SendDataPacket(1, ENCRYPTION_INITIAL);
2036 // Verify PTO is correctly set.
2037 QuicTime::Delta expected_pto_delay =
2038 srtt + kPtoRttvarMultiplier * rtt_stats->mean_deviation() +
2039 QuicTime::Delta::Zero();
2040 EXPECT_EQ(clock_.Now() + expected_pto_delay,
2041 manager_.GetRetransmissionTime());
2042
2043 // Discard initial key and send packet 2 in handshake.
2044 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2045 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
2046 manager_.NeuterUnencryptedPackets();
2047
2048 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(true));
2049 SendDataPacket(2, ENCRYPTION_HANDSHAKE);
2050 // Verify PTO is correctly set based on sent time of packet 2.
2051 EXPECT_EQ(clock_.Now() + expected_pto_delay,
2052 manager_.GetRetransmissionTime());
2053 // Invoke PTO.
2054 clock_.AdvanceTime(expected_pto_delay);
2055 manager_.OnRetransmissionTimeout();
2056 EXPECT_EQ(QuicTime::Delta::Zero(), manager_.TimeUntilSend(clock_.Now()));
2057 EXPECT_EQ(1u, stats_.pto_count);
2058 EXPECT_EQ(1u, stats_.crypto_retransmit_count);
2059
2060 // Verify probe packet gets sent.
2061 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
2062 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
2063 return RetransmitDataPacket(3, type, ENCRYPTION_HANDSHAKE);
2064 })));
2065 manager_.MaybeSendProbePacket();
2066 // Verify PTO period gets set to twice the current value.
2067 const QuicTime packet3_sent_time = clock_.Now();
2068 EXPECT_EQ(packet3_sent_time + expected_pto_delay * 2,
2069 manager_.GetRetransmissionTime());
2070
2071 // Send packet 4 in application data with 0-RTT.
2072 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2073 SendDataPacket(4, ENCRYPTION_ZERO_RTT);
2074 const QuicTime packet4_sent_time = clock_.Now();
2075 // Verify PTO timeout is still based on packet 3.
2076 EXPECT_EQ(packet3_sent_time + expected_pto_delay * 2,
2077 manager_.GetRetransmissionTime());
2078
2079 // Send packet 5 in handshake.
2080 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2081 SendDataPacket(5, ENCRYPTION_HANDSHAKE);
2082 const QuicTime packet5_sent_time = clock_.Now();
2083 // Verify PTO timeout is now based on packet 5 because packet 4 should be
2084 // ignored.
2085 EXPECT_EQ(clock_.Now() + expected_pto_delay * 2,
2086 manager_.GetRetransmissionTime());
2087
2088 // Send packet 6 in 1-RTT.
2089 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2090 SendDataPacket(6, ENCRYPTION_FORWARD_SECURE);
2091 // Verify PTO timeout is now based on packet 5.
2092 EXPECT_EQ(packet5_sent_time + expected_pto_delay * 2,
2093 manager_.GetRetransmissionTime());
2094
2095 // Send packet 7 in handshake.
2096 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2097 const QuicTime packet7_sent_time = clock_.Now();
2098 SendDataPacket(7, ENCRYPTION_HANDSHAKE);
2099
2100 expected_pto_delay =
2101 srtt + kPtoRttvarMultiplier * rtt_stats->mean_deviation();
2102 // Verify PTO timeout is now based on packet 7.
2103 EXPECT_EQ(packet7_sent_time + expected_pto_delay * 2,
2104 manager_.GetRetransmissionTime());
2105
2106 // Neuter handshake key.
2107 manager_.SetHandshakeConfirmed();
2108 // Forward progress has been made, verify PTO counter gets reset. PTO timeout
2109 // is armed by left edge.
2110 expected_pto_delay =
2111 srtt + kPtoRttvarMultiplier * rtt_stats->mean_deviation() +
2112 QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
2113 EXPECT_EQ(packet4_sent_time + expected_pto_delay,
2114 manager_.GetRetransmissionTime());
2115 }
2116
TEST_F(QuicSentPacketManagerTest,ServerMultiplePacketNumberSpacePtoTimeout)2117 TEST_F(QuicSentPacketManagerTest, ServerMultiplePacketNumberSpacePtoTimeout) {
2118 manager_.EnableMultiplePacketNumberSpacesSupport();
2119 EXPECT_CALL(*send_algorithm_, PacingRate(_))
2120 .WillRepeatedly(Return(QuicBandwidth::Zero()));
2121 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
2122 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
2123 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2124 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
2125 QuicTime::Delta::Zero(), QuicTime::Zero());
2126 QuicTime::Delta srtt = rtt_stats->smoothed_rtt();
2127
2128 // Send packet 1.
2129 SendDataPacket(1, ENCRYPTION_INITIAL);
2130 const QuicTime packet1_sent_time = clock_.Now();
2131 // Verify PTO is correctly set.
2132 QuicTime::Delta expected_pto_delay =
2133 srtt + kPtoRttvarMultiplier * rtt_stats->mean_deviation() +
2134 QuicTime::Delta::Zero();
2135 EXPECT_EQ(packet1_sent_time + expected_pto_delay,
2136 manager_.GetRetransmissionTime());
2137
2138 // Send packet 2 in handshake.
2139 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2140 SendDataPacket(2, ENCRYPTION_HANDSHAKE);
2141 const QuicTime packet2_sent_time = clock_.Now();
2142 // Verify PTO timeout is still based on packet 1.
2143 EXPECT_EQ(packet1_sent_time + expected_pto_delay,
2144 manager_.GetRetransmissionTime());
2145
2146 // Discard initial keys.
2147 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
2148 manager_.NeuterUnencryptedPackets();
2149
2150 // Send packet 3 in 1-RTT.
2151 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2152 SendDataPacket(3, ENCRYPTION_FORWARD_SECURE);
2153 // Verify PTO timeout is based on packet 2.
2154 const QuicTime packet3_sent_time = clock_.Now();
2155 EXPECT_EQ(packet2_sent_time + expected_pto_delay,
2156 manager_.GetRetransmissionTime());
2157
2158 // Send packet 4 in handshake.
2159 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2160 SendDataPacket(4, ENCRYPTION_HANDSHAKE);
2161 // Verify PTO timeout is based on packet 4 as application data is ignored.
2162 EXPECT_EQ(clock_.Now() + expected_pto_delay,
2163 manager_.GetRetransmissionTime());
2164
2165 // Discard handshake keys.
2166 manager_.SetHandshakeConfirmed();
2167 expected_pto_delay =
2168 srtt + kPtoRttvarMultiplier * rtt_stats->mean_deviation() +
2169 QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
2170 // Verify PTO timeout is now based on packet 3 as handshake is
2171 // complete/confirmed.
2172 EXPECT_EQ(packet3_sent_time + expected_pto_delay,
2173 manager_.GetRetransmissionTime());
2174 }
2175
TEST_F(QuicSentPacketManagerTest,ComputingProbeTimeoutByLeftEdge)2176 TEST_F(QuicSentPacketManagerTest, ComputingProbeTimeoutByLeftEdge) {
2177 EXPECT_CALL(*send_algorithm_, CanSend(_)).WillRepeatedly(Return(true));
2178 EXPECT_CALL(*send_algorithm_, PacingRate(_))
2179 .WillRepeatedly(Return(QuicBandwidth::Zero()));
2180 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
2181 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
2182 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2183 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
2184 QuicTime::Delta::Zero(), QuicTime::Zero());
2185 QuicTime::Delta srtt = rtt_stats->smoothed_rtt();
2186
2187 SendDataPacket(1, ENCRYPTION_FORWARD_SECURE);
2188 // Verify PTO is correctly set.
2189 QuicTime::Delta expected_pto_delay =
2190 srtt + kPtoRttvarMultiplier * rtt_stats->mean_deviation() +
2191 QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
2192 const QuicTime packet1_sent_time = clock_.Now();
2193 EXPECT_EQ(packet1_sent_time + expected_pto_delay,
2194 manager_.GetRetransmissionTime());
2195
2196 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2197 SendDataPacket(2, ENCRYPTION_FORWARD_SECURE);
2198 // Verify PTO is still based on packet 1.
2199 EXPECT_EQ(packet1_sent_time + expected_pto_delay,
2200 manager_.GetRetransmissionTime());
2201 EXPECT_EQ(0u, stats_.pto_count);
2202
2203 // Invoke PTO.
2204 clock_.AdvanceTime(expected_pto_delay);
2205 manager_.OnRetransmissionTimeout();
2206 EXPECT_EQ(QuicTime::Delta::Zero(), manager_.TimeUntilSend(clock_.Now()));
2207 EXPECT_EQ(1u, stats_.pto_count);
2208
2209 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
2210 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
2211 return RetransmitDataPacket(3, type, ENCRYPTION_FORWARD_SECURE);
2212 })));
2213 manager_.MaybeSendProbePacket();
2214 // Verify PTO period gets set to twice the current value and based on packet3.
2215 QuicTime packet3_sent_time = clock_.Now();
2216 EXPECT_EQ(packet3_sent_time + expected_pto_delay * 2,
2217 manager_.GetRetransmissionTime());
2218
2219 // Received ACK for packets 1 and 2.
2220 uint64_t acked[] = {1, 2};
2221 ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
2222 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
2223 clock_.Now());
2224 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
2225 EXPECT_EQ(PACKETS_NEWLY_ACKED,
2226 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
2227 ENCRYPTION_FORWARD_SECURE, kEmptyCounts));
2228 expected_pto_delay =
2229 rtt_stats->SmoothedOrInitialRtt() +
2230 std::max(kPtoRttvarMultiplier * rtt_stats->mean_deviation(),
2231 QuicTime::Delta::FromMilliseconds(1)) +
2232 QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
2233
2234 // Verify PTO is correctly re-armed based on sent time of packet 4.
2235 EXPECT_EQ(packet3_sent_time + expected_pto_delay,
2236 manager_.GetRetransmissionTime());
2237 }
2238
TEST_F(QuicSentPacketManagerTest,ComputingProbeTimeoutByLeftEdge2)2239 TEST_F(QuicSentPacketManagerTest, ComputingProbeTimeoutByLeftEdge2) {
2240 EXPECT_CALL(*send_algorithm_, CanSend(_)).WillRepeatedly(Return(true));
2241 EXPECT_CALL(*send_algorithm_, PacingRate(_))
2242 .WillRepeatedly(Return(QuicBandwidth::Zero()));
2243 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
2244 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
2245 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2246 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
2247 QuicTime::Delta::Zero(), QuicTime::Zero());
2248 QuicTime::Delta srtt = rtt_stats->smoothed_rtt();
2249
2250 SendDataPacket(1, ENCRYPTION_FORWARD_SECURE);
2251 // Verify PTO is correctly set.
2252 QuicTime::Delta expected_pto_delay =
2253 srtt + kPtoRttvarMultiplier * rtt_stats->mean_deviation() +
2254 QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
2255 const QuicTime packet1_sent_time = clock_.Now();
2256 EXPECT_EQ(packet1_sent_time + expected_pto_delay,
2257 manager_.GetRetransmissionTime());
2258
2259 // Sent a packet 10ms before PTO expiring.
2260 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(
2261 expected_pto_delay.ToMilliseconds() - 10));
2262 SendDataPacket(2, ENCRYPTION_FORWARD_SECURE);
2263 // Verify PTO expands to packet 2 sent time + 1.5 * srtt.
2264 expected_pto_delay = kFirstPtoSrttMultiplier * rtt_stats->smoothed_rtt();
2265 EXPECT_EQ(clock_.Now() + expected_pto_delay,
2266 manager_.GetRetransmissionTime());
2267 EXPECT_EQ(0u, stats_.pto_count);
2268
2269 // Invoke PTO.
2270 clock_.AdvanceTime(expected_pto_delay);
2271 manager_.OnRetransmissionTimeout();
2272 EXPECT_EQ(QuicTime::Delta::Zero(), manager_.TimeUntilSend(clock_.Now()));
2273 EXPECT_EQ(1u, stats_.pto_count);
2274
2275 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
2276 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
2277 return RetransmitDataPacket(3, type, ENCRYPTION_FORWARD_SECURE);
2278 })));
2279 manager_.MaybeSendProbePacket();
2280 // Verify PTO period gets set to twice the expected value and based on
2281 // packet3 (right edge).
2282 expected_pto_delay =
2283 srtt + kPtoRttvarMultiplier * rtt_stats->mean_deviation() +
2284 QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
2285 QuicTime packet3_sent_time = clock_.Now();
2286 EXPECT_EQ(packet3_sent_time + expected_pto_delay * 2,
2287 manager_.GetRetransmissionTime());
2288
2289 // Received ACK for packets 1 and 2.
2290 uint64_t acked[] = {1, 2};
2291 ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
2292 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
2293 clock_.Now());
2294 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
2295 EXPECT_EQ(PACKETS_NEWLY_ACKED,
2296 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
2297 ENCRYPTION_FORWARD_SECURE, kEmptyCounts));
2298 expected_pto_delay =
2299 rtt_stats->SmoothedOrInitialRtt() +
2300 std::max(kPtoRttvarMultiplier * rtt_stats->mean_deviation(),
2301 QuicTime::Delta::FromMilliseconds(1)) +
2302 QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
2303
2304 // Verify PTO is correctly re-armed based on sent time of packet 3 (left
2305 // edge).
2306 EXPECT_EQ(packet3_sent_time + expected_pto_delay,
2307 manager_.GetRetransmissionTime());
2308 }
2309
TEST_F(QuicSentPacketManagerTest,ComputingProbeTimeoutByLeftEdgeMultiplePacketNumberSpaces)2310 TEST_F(QuicSentPacketManagerTest,
2311 ComputingProbeTimeoutByLeftEdgeMultiplePacketNumberSpaces) {
2312 manager_.EnableMultiplePacketNumberSpacesSupport();
2313 EXPECT_CALL(*send_algorithm_, CanSend(_)).WillRepeatedly(Return(true));
2314 EXPECT_CALL(*send_algorithm_, PacingRate(_))
2315 .WillRepeatedly(Return(QuicBandwidth::Zero()));
2316 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
2317 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
2318 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2319 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
2320 QuicTime::Delta::Zero(), QuicTime::Zero());
2321 QuicTime::Delta srtt = rtt_stats->smoothed_rtt();
2322
2323 // Send packet 1.
2324 SendDataPacket(1, ENCRYPTION_INITIAL);
2325 const QuicTime packet1_sent_time = clock_.Now();
2326 // Verify PTO is correctly set.
2327 QuicTime::Delta expected_pto_delay =
2328 srtt + kPtoRttvarMultiplier * rtt_stats->mean_deviation() +
2329 QuicTime::Delta::Zero();
2330 EXPECT_EQ(packet1_sent_time + expected_pto_delay,
2331 manager_.GetRetransmissionTime());
2332
2333 // Send packet 2 in handshake.
2334 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2335 SendDataPacket(2, ENCRYPTION_HANDSHAKE);
2336 const QuicTime packet2_sent_time = clock_.Now();
2337 // Verify PTO timeout is still based on packet 1.
2338 EXPECT_EQ(packet1_sent_time + expected_pto_delay,
2339 manager_.GetRetransmissionTime());
2340
2341 // Discard initial keys.
2342 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
2343 manager_.NeuterUnencryptedPackets();
2344
2345 // Send packet 3 in 1-RTT.
2346 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2347 SendDataPacket(3, ENCRYPTION_FORWARD_SECURE);
2348 // Verify PTO timeout is based on packet 2.
2349 const QuicTime packet3_sent_time = clock_.Now();
2350 EXPECT_EQ(packet2_sent_time + expected_pto_delay,
2351 manager_.GetRetransmissionTime());
2352
2353 // Send packet 4 in handshake.
2354 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2355 SendDataPacket(4, ENCRYPTION_HANDSHAKE);
2356 // Verify PTO timeout is based on packet 4 as application data is ignored.
2357 EXPECT_EQ(clock_.Now() + expected_pto_delay,
2358 manager_.GetRetransmissionTime());
2359
2360 // Discard handshake keys.
2361 manager_.SetHandshakeConfirmed();
2362 // Verify PTO timeout is now based on packet 3 as handshake is
2363 // complete/confirmed.
2364 expected_pto_delay =
2365 srtt + kPtoRttvarMultiplier * rtt_stats->mean_deviation() +
2366 QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
2367 EXPECT_EQ(packet3_sent_time + expected_pto_delay,
2368 manager_.GetRetransmissionTime());
2369
2370 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2371 SendDataPacket(5, ENCRYPTION_FORWARD_SECURE);
2372 // Verify PTO timeout is still based on packet 3.
2373 EXPECT_EQ(packet3_sent_time + expected_pto_delay,
2374 manager_.GetRetransmissionTime());
2375 }
2376
TEST_F(QuicSentPacketManagerTest,ComputingProbeTimeoutByLeftEdge2MultiplePacketNumberSpaces)2377 TEST_F(QuicSentPacketManagerTest,
2378 ComputingProbeTimeoutByLeftEdge2MultiplePacketNumberSpaces) {
2379 manager_.EnableMultiplePacketNumberSpacesSupport();
2380 EXPECT_CALL(*send_algorithm_, CanSend(_)).WillRepeatedly(Return(true));
2381 EXPECT_CALL(*send_algorithm_, PacingRate(_))
2382 .WillRepeatedly(Return(QuicBandwidth::Zero()));
2383 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
2384 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
2385 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2386 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
2387 QuicTime::Delta::Zero(), QuicTime::Zero());
2388 QuicTime::Delta srtt = rtt_stats->smoothed_rtt();
2389
2390 // Send packet 1.
2391 SendDataPacket(1, ENCRYPTION_INITIAL);
2392 const QuicTime packet1_sent_time = clock_.Now();
2393 // Verify PTO is correctly set.
2394 QuicTime::Delta expected_pto_delay =
2395 srtt + kPtoRttvarMultiplier * rtt_stats->mean_deviation() +
2396 QuicTime::Delta::Zero();
2397 EXPECT_EQ(packet1_sent_time + expected_pto_delay,
2398 manager_.GetRetransmissionTime());
2399
2400 // Send packet 2 in handshake.
2401 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2402 SendDataPacket(2, ENCRYPTION_HANDSHAKE);
2403 const QuicTime packet2_sent_time = clock_.Now();
2404 // Verify PTO timeout is still based on packet 1.
2405 EXPECT_EQ(packet1_sent_time + expected_pto_delay,
2406 manager_.GetRetransmissionTime());
2407
2408 // Discard initial keys.
2409 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
2410 manager_.NeuterUnencryptedPackets();
2411
2412 // Send packet 3 in 1-RTT.
2413 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2414 SendDataPacket(3, ENCRYPTION_FORWARD_SECURE);
2415 // Verify PTO timeout is based on packet 2.
2416 const QuicTime packet3_sent_time = clock_.Now();
2417 EXPECT_EQ(packet2_sent_time + expected_pto_delay,
2418 manager_.GetRetransmissionTime());
2419
2420 // Send packet 4 in handshake.
2421 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2422 SendDataPacket(4, ENCRYPTION_HANDSHAKE);
2423 // Verify PTO timeout is based on packet 4 as application data is ignored.
2424 EXPECT_EQ(clock_.Now() + expected_pto_delay,
2425 manager_.GetRetransmissionTime());
2426
2427 // Discard handshake keys.
2428 manager_.SetHandshakeConfirmed();
2429 // Verify PTO timeout is now based on packet 3 as handshake is
2430 // complete/confirmed.
2431 expected_pto_delay =
2432 srtt + kPtoRttvarMultiplier * rtt_stats->mean_deviation() +
2433 QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
2434 EXPECT_EQ(packet3_sent_time + expected_pto_delay,
2435 manager_.GetRetransmissionTime());
2436
2437 // Send packet 5 10ms before PTO expiring.
2438 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(
2439 expected_pto_delay.ToMilliseconds() - 10));
2440 SendDataPacket(5, ENCRYPTION_FORWARD_SECURE);
2441 // Verify PTO timeout expands to packet 5 sent time + 1.5 * srtt.
2442 EXPECT_EQ(clock_.Now() + kFirstPtoSrttMultiplier * rtt_stats->smoothed_rtt(),
2443 manager_.GetRetransmissionTime());
2444 }
2445
TEST_F(QuicSentPacketManagerTest,SetHandshakeConfirmed)2446 TEST_F(QuicSentPacketManagerTest, SetHandshakeConfirmed) {
2447 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
2448 manager_.EnableMultiplePacketNumberSpacesSupport();
2449
2450 SendDataPacket(1, ENCRYPTION_INITIAL);
2451
2452 SendDataPacket(2, ENCRYPTION_HANDSHAKE);
2453
2454 EXPECT_CALL(notifier_, OnFrameAcked(_, _, _))
2455 .WillOnce(
2456 Invoke([](const QuicFrame& /*frame*/, QuicTime::Delta ack_delay_time,
2457 QuicTime receive_timestamp) {
2458 EXPECT_TRUE(ack_delay_time.IsZero());
2459 EXPECT_EQ(receive_timestamp, QuicTime::Zero());
2460 return true;
2461 }));
2462
2463 EXPECT_CALL(*send_algorithm_, OnPacketNeutered(QuicPacketNumber(2))).Times(1);
2464 manager_.SetHandshakeConfirmed();
2465 }
2466
2467 // Regresstion test for b/148841700.
TEST_F(QuicSentPacketManagerTest,NeuterUnencryptedPackets)2468 TEST_F(QuicSentPacketManagerTest, NeuterUnencryptedPackets) {
2469 SendCryptoPacket(1);
2470 SendPingPacket(2, ENCRYPTION_INITIAL);
2471 // Crypto data has been discarded but ping does not.
2472 EXPECT_CALL(notifier_, OnFrameAcked(_, _, _))
2473 .Times(2)
2474 .WillOnce(Return(false))
2475 .WillOnce(Return(true));
2476 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
2477
2478 EXPECT_CALL(*send_algorithm_, OnPacketNeutered(QuicPacketNumber(1))).Times(1);
2479 manager_.NeuterUnencryptedPackets();
2480 }
2481
TEST_F(QuicSentPacketManagerTest,MarkInitialPacketsForRetransmission)2482 TEST_F(QuicSentPacketManagerTest, MarkInitialPacketsForRetransmission) {
2483 SendCryptoPacket(1);
2484 SendPingPacket(2, ENCRYPTION_HANDSHAKE);
2485 // Only the INITIAL packet will be retransmitted.
2486 EXPECT_CALL(notifier_, OnFrameLost(_)).Times(1);
2487 manager_.MarkInitialPacketsForRetransmission();
2488 }
2489
TEST_F(QuicSentPacketManagerTest,NoPacketThresholdDetectionForRuntPackets)2490 TEST_F(QuicSentPacketManagerTest, NoPacketThresholdDetectionForRuntPackets) {
2491 EXPECT_TRUE(
2492 QuicSentPacketManagerPeer::UsePacketThresholdForRuntPackets(&manager_));
2493
2494 QuicConfig config;
2495 QuicTagVector options;
2496 options.push_back(kRUNT);
2497 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
2498 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2499 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2500 manager_.SetFromConfig(config);
2501
2502 EXPECT_FALSE(
2503 QuicSentPacketManagerPeer::UsePacketThresholdForRuntPackets(&manager_));
2504 }
2505
TEST_F(QuicSentPacketManagerTest,GetPathDegradingDelayDefaultPTO)2506 TEST_F(QuicSentPacketManagerTest, GetPathDegradingDelayDefaultPTO) {
2507 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
2508 QuicTime::Delta expected_delay = 4 * manager_.GetPtoDelay();
2509 EXPECT_EQ(expected_delay, manager_.GetPathDegradingDelay());
2510 }
2511
TEST_F(QuicSentPacketManagerTest,ClientsIgnorePings)2512 TEST_F(QuicSentPacketManagerTest, ClientsIgnorePings) {
2513 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
2514 QuicConfig client_config;
2515 QuicTagVector options;
2516 QuicTagVector client_options;
2517 client_options.push_back(kIGNP);
2518 client_config.SetConnectionOptionsToSend(options);
2519 client_config.SetClientConnectionOptions(client_options);
2520 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2521 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2522 manager_.SetFromConfig(client_config);
2523
2524 EXPECT_CALL(*send_algorithm_, PacingRate(_))
2525 .WillRepeatedly(Return(QuicBandwidth::Zero()));
2526 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
2527 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
2528 EXPECT_CALL(*send_algorithm_, CanSend(_)).WillRepeatedly(Return(true));
2529
2530 SendPingPacket(1, ENCRYPTION_INITIAL);
2531 // Verify PING only packet is not considered in flight.
2532 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
2533 SendDataPacket(2, ENCRYPTION_INITIAL);
2534 EXPECT_NE(QuicTime::Zero(), manager_.GetRetransmissionTime());
2535
2536 uint64_t acked[] = {1};
2537 ExpectAcksAndLosses(/*rtt_updated=*/false, acked, ABSL_ARRAYSIZE(acked),
2538 nullptr, 0);
2539 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(90));
2540 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
2541 clock_.Now());
2542 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
2543 EXPECT_EQ(PACKETS_NEWLY_ACKED,
2544 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
2545 ENCRYPTION_INITIAL, kEmptyCounts));
2546 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2547 // Verify no RTT samples for PING only packet.
2548 EXPECT_TRUE(rtt_stats->smoothed_rtt().IsZero());
2549
2550 ExpectAck(2);
2551 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2552 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
2553 clock_.Now());
2554 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
2555 EXPECT_EQ(PACKETS_NEWLY_ACKED,
2556 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
2557 ENCRYPTION_INITIAL, kEmptyCounts));
2558 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100), rtt_stats->smoothed_rtt());
2559 }
2560
2561 // Regression test for b/154050235.
TEST_F(QuicSentPacketManagerTest,ExponentialBackoffWithNoRttMeasurement)2562 TEST_F(QuicSentPacketManagerTest, ExponentialBackoffWithNoRttMeasurement) {
2563 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
2564 manager_.EnableMultiplePacketNumberSpacesSupport();
2565 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2566 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(kInitialRttMs),
2567 rtt_stats->initial_rtt());
2568 EXPECT_TRUE(rtt_stats->smoothed_rtt().IsZero());
2569
2570 SendCryptoPacket(1);
2571 QuicTime::Delta expected_pto_delay =
2572 QuicTime::Delta::FromMilliseconds(3 * kInitialRttMs);
2573 EXPECT_EQ(clock_.Now() + expected_pto_delay,
2574 manager_.GetRetransmissionTime());
2575
2576 // Invoke PTO.
2577 clock_.AdvanceTime(expected_pto_delay);
2578 manager_.OnRetransmissionTimeout();
2579
2580 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
2581 .WillOnce(
2582 WithArgs<1>(Invoke([this]() { return RetransmitCryptoPacket(3); })));
2583 manager_.MaybeSendProbePacket();
2584 // Verify exponential backoff of the PTO timeout.
2585 EXPECT_EQ(clock_.Now() + 2 * expected_pto_delay,
2586 manager_.GetRetransmissionTime());
2587 }
2588
TEST_F(QuicSentPacketManagerTest,PtoDelayWithTinyInitialRtt)2589 TEST_F(QuicSentPacketManagerTest, PtoDelayWithTinyInitialRtt) {
2590 manager_.EnableMultiplePacketNumberSpacesSupport();
2591 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2592 // Assume client provided a tiny initial RTT.
2593 rtt_stats->set_initial_rtt(QuicTime::Delta::FromMicroseconds(1));
2594 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(1), rtt_stats->initial_rtt());
2595 EXPECT_TRUE(rtt_stats->smoothed_rtt().IsZero());
2596
2597 SendCryptoPacket(1);
2598 QuicTime::Delta expected_pto_delay = QuicTime::Delta::FromMilliseconds(10);
2599 // Verify kMinHandshakeTimeoutMs is respected.
2600 EXPECT_EQ(clock_.Now() + expected_pto_delay,
2601 manager_.GetRetransmissionTime());
2602
2603 // Invoke PTO.
2604 clock_.AdvanceTime(expected_pto_delay);
2605 manager_.OnRetransmissionTimeout();
2606
2607 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
2608 .WillOnce(
2609 WithArgs<1>(Invoke([this]() { return RetransmitCryptoPacket(3); })));
2610 manager_.MaybeSendProbePacket();
2611 // Verify exponential backoff of the PTO timeout.
2612 EXPECT_EQ(clock_.Now() + 2 * expected_pto_delay,
2613 manager_.GetRetransmissionTime());
2614 }
2615
TEST_F(QuicSentPacketManagerTest,HandshakeAckCausesInitialKeyDropping)2616 TEST_F(QuicSentPacketManagerTest, HandshakeAckCausesInitialKeyDropping) {
2617 manager_.EnableMultiplePacketNumberSpacesSupport();
2618 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
2619 // Send INITIAL packet 1.
2620 SendDataPacket(1, ENCRYPTION_INITIAL);
2621 QuicTime::Delta expected_pto_delay =
2622 QuicTime::Delta::FromMilliseconds(3 * kInitialRttMs);
2623 EXPECT_EQ(clock_.Now() + expected_pto_delay,
2624 manager_.GetRetransmissionTime());
2625 // Send HANDSHAKE ack.
2626 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2627 SendAckPacket(2, /*largest_acked=*/1, ENCRYPTION_HANDSHAKE);
2628 // Sending HANDSHAKE packet causes dropping of INITIAL key.
2629 EXPECT_CALL(notifier_, HasUnackedCryptoData()).WillRepeatedly(Return(false));
2630 EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
2631 manager_.NeuterUnencryptedPackets();
2632 // There is no in flight packets.
2633 EXPECT_FALSE(manager_.HasInFlightPackets());
2634 // Verify PTO timer gets rearmed from now because of anti-amplification.
2635 EXPECT_EQ(clock_.Now() + expected_pto_delay,
2636 manager_.GetRetransmissionTime());
2637
2638 // Invoke PTO.
2639 clock_.AdvanceTime(expected_pto_delay);
2640 manager_.OnRetransmissionTimeout();
2641 // Verify nothing to probe (and connection will send PING for current
2642 // encryption level).
2643 EXPECT_CALL(notifier_, RetransmitFrames(_, _)).Times(0);
2644 manager_.MaybeSendProbePacket();
2645 }
2646
2647 // Regression test for b/156487311
TEST_F(QuicSentPacketManagerTest,ClearLastInflightPacketsSentTime)2648 TEST_F(QuicSentPacketManagerTest, ClearLastInflightPacketsSentTime) {
2649 manager_.EnableMultiplePacketNumberSpacesSupport();
2650 EXPECT_CALL(*send_algorithm_, PacingRate(_))
2651 .WillRepeatedly(Return(QuicBandwidth::Zero()));
2652 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
2653 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
2654
2655 // Send INITIAL 1.
2656 SendDataPacket(1, ENCRYPTION_INITIAL);
2657 // Send HANDSHAKE 2.
2658 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2659 SendDataPacket(2, ENCRYPTION_HANDSHAKE);
2660 SendDataPacket(3, ENCRYPTION_HANDSHAKE);
2661 SendDataPacket(4, ENCRYPTION_HANDSHAKE);
2662 const QuicTime packet2_sent_time = clock_.Now();
2663
2664 // Send half RTT 5.
2665 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2666 SendDataPacket(5, ENCRYPTION_FORWARD_SECURE);
2667
2668 // Received ACK for INITIAL 1.
2669 ExpectAck(1);
2670 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(90));
2671 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
2672 clock_.Now());
2673 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
2674 EXPECT_EQ(PACKETS_NEWLY_ACKED,
2675 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
2676 ENCRYPTION_INITIAL, kEmptyCounts));
2677 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2678 const QuicTime::Delta pto_delay =
2679 rtt_stats->smoothed_rtt() +
2680 kPtoRttvarMultiplier * rtt_stats->mean_deviation() +
2681 QuicTime::Delta::Zero();
2682 // Verify PTO is armed based on handshake data.
2683 EXPECT_EQ(packet2_sent_time + pto_delay, manager_.GetRetransmissionTime());
2684 }
2685
TEST_F(QuicSentPacketManagerTest,MaybeRetransmitInitialData)2686 TEST_F(QuicSentPacketManagerTest, MaybeRetransmitInitialData) {
2687 manager_.EnableMultiplePacketNumberSpacesSupport();
2688 EXPECT_CALL(*send_algorithm_, PacingRate(_))
2689 .WillRepeatedly(Return(QuicBandwidth::Zero()));
2690 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
2691 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
2692 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2693 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
2694 QuicTime::Delta::Zero(), QuicTime::Zero());
2695 QuicTime::Delta srtt = rtt_stats->smoothed_rtt();
2696
2697 // Send packet 1.
2698 SendDataPacket(1, ENCRYPTION_INITIAL);
2699 QuicTime packet1_sent_time = clock_.Now();
2700
2701 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2702 // Send packets 2 and 3.
2703 SendDataPacket(2, ENCRYPTION_HANDSHAKE);
2704 QuicTime packet2_sent_time = clock_.Now();
2705 SendDataPacket(3, ENCRYPTION_HANDSHAKE);
2706 // Verify PTO is correctly set based on packet 1.
2707 QuicTime::Delta expected_pto_delay =
2708 srtt + kPtoRttvarMultiplier * rtt_stats->mean_deviation() +
2709 QuicTime::Delta::Zero();
2710 EXPECT_EQ(packet1_sent_time + expected_pto_delay,
2711 manager_.GetRetransmissionTime());
2712
2713 // Assume connection is going to send INITIAL ACK.
2714 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2715 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
2716 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
2717 return RetransmitDataPacket(4, type, ENCRYPTION_INITIAL);
2718 })));
2719 manager_.RetransmitDataOfSpaceIfAny(INITIAL_DATA);
2720 // Verify PTO is re-armed based on packet 2.
2721 EXPECT_EQ(packet2_sent_time + expected_pto_delay,
2722 manager_.GetRetransmissionTime());
2723
2724 // Connection is going to send another INITIAL ACK.
2725 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2726 EXPECT_CALL(notifier_, RetransmitFrames(_, _))
2727 .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
2728 return RetransmitDataPacket(5, type, ENCRYPTION_INITIAL);
2729 })));
2730 manager_.RetransmitDataOfSpaceIfAny(INITIAL_DATA);
2731 // Verify PTO does not change.
2732 EXPECT_EQ(packet2_sent_time + expected_pto_delay,
2733 manager_.GetRetransmissionTime());
2734 }
2735
TEST_F(QuicSentPacketManagerTest,SendPathChallengeAndGetAck)2736 TEST_F(QuicSentPacketManagerTest, SendPathChallengeAndGetAck) {
2737 QuicPacketNumber packet_number(1);
2738 EXPECT_CALL(*send_algorithm_,
2739 OnPacketSent(_, BytesInFlight(), packet_number, _, _));
2740 SerializedPacket packet(packet_number, PACKET_4BYTE_PACKET_NUMBER, nullptr,
2741 kDefaultLength, false, false);
2742 QuicPathFrameBuffer path_frame_buffer{0, 1, 2, 3, 4, 5, 6, 7};
2743 packet.nonretransmittable_frames.push_back(
2744 QuicFrame(QuicPathChallengeFrame(0, path_frame_buffer)));
2745 packet.encryption_level = ENCRYPTION_FORWARD_SECURE;
2746 manager_.OnPacketSent(&packet, clock_.Now(), NOT_RETRANSMISSION,
2747 NO_RETRANSMITTABLE_DATA, false, ECN_NOT_ECT);
2748 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
2749 EXPECT_CALL(
2750 *send_algorithm_,
2751 OnCongestionEvent(/*rtt_updated=*/false, _, _,
2752 Pointwise(PacketNumberEq(), {1}), IsEmpty(), _, _));
2753 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2754
2755 // Get ACK for the packet.
2756 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
2757 clock_.Now());
2758 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
2759 EXPECT_EQ(PACKETS_NEWLY_ACKED,
2760 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
2761 ENCRYPTION_FORWARD_SECURE, kEmptyCounts));
2762 }
2763
MakePacketWithAckFrequencyFrame(int packet_number,int ack_frequency_sequence_number,QuicTime::Delta max_ack_delay)2764 SerializedPacket MakePacketWithAckFrequencyFrame(
2765 int packet_number, int ack_frequency_sequence_number,
2766 QuicTime::Delta max_ack_delay) {
2767 auto* ack_frequency_frame = new QuicAckFrequencyFrame();
2768 ack_frequency_frame->max_ack_delay = max_ack_delay;
2769 ack_frequency_frame->sequence_number = ack_frequency_sequence_number;
2770 SerializedPacket packet(QuicPacketNumber(packet_number),
2771 PACKET_4BYTE_PACKET_NUMBER, nullptr, kDefaultLength,
2772 /*has_ack=*/false,
2773 /*has_stop_waiting=*/false);
2774 packet.retransmittable_frames.push_back(QuicFrame(ack_frequency_frame));
2775 packet.has_ack_frequency = true;
2776 packet.encryption_level = ENCRYPTION_FORWARD_SECURE;
2777 return packet;
2778 }
2779
TEST_F(QuicSentPacketManagerTest,PeerMaxAckDelayUpdatedFromAckFrequencyFrameOneAtATime)2780 TEST_F(QuicSentPacketManagerTest,
2781 PeerMaxAckDelayUpdatedFromAckFrequencyFrameOneAtATime) {
2782 EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(AnyNumber());
2783 EXPECT_CALL(*send_algorithm_, OnCongestionEvent(_, _, _, _, _, _, _))
2784 .Times(AnyNumber());
2785 EXPECT_CALL(*network_change_visitor_, OnCongestionChange())
2786 .Times(AnyNumber());
2787
2788 auto initial_peer_max_ack_delay = manager_.peer_max_ack_delay();
2789 auto one_ms = QuicTime::Delta::FromMilliseconds(1);
2790 auto plus_1_ms_delay = initial_peer_max_ack_delay + one_ms;
2791 auto minus_1_ms_delay = initial_peer_max_ack_delay - one_ms;
2792
2793 // Send and Ack frame1.
2794 SerializedPacket packet1 = MakePacketWithAckFrequencyFrame(
2795 /*packet_number=*/1, /*ack_frequency_sequence_number=*/1,
2796 plus_1_ms_delay);
2797 // Higher on the fly max_ack_delay changes peer_max_ack_delay.
2798 manager_.OnPacketSent(&packet1, clock_.Now(), NOT_RETRANSMISSION,
2799 HAS_RETRANSMITTABLE_DATA, /*measure_rtt=*/true,
2800 ECN_NOT_ECT);
2801 EXPECT_EQ(manager_.peer_max_ack_delay(), plus_1_ms_delay);
2802 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
2803 clock_.Now());
2804 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
2805 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
2806 ENCRYPTION_FORWARD_SECURE, kEmptyCounts);
2807 EXPECT_EQ(manager_.peer_max_ack_delay(), plus_1_ms_delay);
2808
2809 // Send and Ack frame2.
2810 SerializedPacket packet2 = MakePacketWithAckFrequencyFrame(
2811 /*packet_number=*/2, /*ack_frequency_sequence_number=*/2,
2812 minus_1_ms_delay);
2813 // Lower on the fly max_ack_delay does not change peer_max_ack_delay.
2814 manager_.OnPacketSent(&packet2, clock_.Now(), NOT_RETRANSMISSION,
2815 HAS_RETRANSMITTABLE_DATA, /*measure_rtt=*/true,
2816 ECN_NOT_ECT);
2817 EXPECT_EQ(manager_.peer_max_ack_delay(), plus_1_ms_delay);
2818 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
2819 clock_.Now());
2820 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(3));
2821 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
2822 ENCRYPTION_FORWARD_SECURE, kEmptyCounts);
2823 EXPECT_EQ(manager_.peer_max_ack_delay(), minus_1_ms_delay);
2824 }
2825
TEST_F(QuicSentPacketManagerTest,PeerMaxAckDelayUpdatedFromInOrderAckFrequencyFrames)2826 TEST_F(QuicSentPacketManagerTest,
2827 PeerMaxAckDelayUpdatedFromInOrderAckFrequencyFrames) {
2828 EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(AnyNumber());
2829 EXPECT_CALL(*send_algorithm_, OnCongestionEvent(_, _, _, _, _, _, _))
2830 .Times(AnyNumber());
2831 EXPECT_CALL(*network_change_visitor_, OnCongestionChange())
2832 .Times(AnyNumber());
2833
2834 auto initial_peer_max_ack_delay = manager_.peer_max_ack_delay();
2835 auto one_ms = QuicTime::Delta::FromMilliseconds(1);
2836 auto extra_1_ms = initial_peer_max_ack_delay + one_ms;
2837 auto extra_2_ms = initial_peer_max_ack_delay + 2 * one_ms;
2838 auto extra_3_ms = initial_peer_max_ack_delay + 3 * one_ms;
2839 SerializedPacket packet1 = MakePacketWithAckFrequencyFrame(
2840 /*packet_number=*/1, /*ack_frequency_sequence_number=*/1, extra_1_ms);
2841 SerializedPacket packet2 = MakePacketWithAckFrequencyFrame(
2842 /*packet_number=*/2, /*ack_frequency_sequence_number=*/2, extra_3_ms);
2843 SerializedPacket packet3 = MakePacketWithAckFrequencyFrame(
2844 /*packet_number=*/3, /*ack_frequency_sequence_number=*/3, extra_2_ms);
2845
2846 // Send frame1, farme2, frame3.
2847 manager_.OnPacketSent(&packet1, clock_.Now(), NOT_RETRANSMISSION,
2848 HAS_RETRANSMITTABLE_DATA, /*measure_rtt=*/true,
2849 ECN_NOT_ECT);
2850 EXPECT_EQ(manager_.peer_max_ack_delay(), extra_1_ms);
2851 manager_.OnPacketSent(&packet2, clock_.Now(), NOT_RETRANSMISSION,
2852 HAS_RETRANSMITTABLE_DATA, /*measure_rtt=*/true,
2853 ECN_NOT_ECT);
2854 EXPECT_EQ(manager_.peer_max_ack_delay(), extra_3_ms);
2855 manager_.OnPacketSent(&packet3, clock_.Now(), NOT_RETRANSMISSION,
2856 HAS_RETRANSMITTABLE_DATA, /*measure_rtt=*/true,
2857 ECN_NOT_ECT);
2858 EXPECT_EQ(manager_.peer_max_ack_delay(), extra_3_ms);
2859
2860 // Ack frame1, farme2, frame3.
2861 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
2862 clock_.Now());
2863 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
2864 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
2865 ENCRYPTION_FORWARD_SECURE, kEmptyCounts);
2866 EXPECT_EQ(manager_.peer_max_ack_delay(), extra_3_ms);
2867 manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
2868 clock_.Now());
2869 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
2870 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
2871 ENCRYPTION_FORWARD_SECURE, kEmptyCounts);
2872 EXPECT_EQ(manager_.peer_max_ack_delay(), extra_3_ms);
2873 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
2874 clock_.Now());
2875 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(4));
2876 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
2877 ENCRYPTION_FORWARD_SECURE, kEmptyCounts);
2878 EXPECT_EQ(manager_.peer_max_ack_delay(), extra_2_ms);
2879 }
2880
TEST_F(QuicSentPacketManagerTest,PeerMaxAckDelayUpdatedFromOutOfOrderAckedAckFrequencyFrames)2881 TEST_F(QuicSentPacketManagerTest,
2882 PeerMaxAckDelayUpdatedFromOutOfOrderAckedAckFrequencyFrames) {
2883 EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(AnyNumber());
2884 EXPECT_CALL(*send_algorithm_, OnCongestionEvent(_, _, _, _, _, _, _))
2885 .Times(AnyNumber());
2886 EXPECT_CALL(*network_change_visitor_, OnCongestionChange())
2887 .Times(AnyNumber());
2888
2889 auto initial_peer_max_ack_delay = manager_.peer_max_ack_delay();
2890 auto one_ms = QuicTime::Delta::FromMilliseconds(1);
2891 auto extra_1_ms = initial_peer_max_ack_delay + one_ms;
2892 auto extra_2_ms = initial_peer_max_ack_delay + 2 * one_ms;
2893 auto extra_3_ms = initial_peer_max_ack_delay + 3 * one_ms;
2894 auto extra_4_ms = initial_peer_max_ack_delay + 4 * one_ms;
2895 SerializedPacket packet1 = MakePacketWithAckFrequencyFrame(
2896 /*packet_number=*/1, /*ack_frequency_sequence_number=*/1, extra_4_ms);
2897 SerializedPacket packet2 = MakePacketWithAckFrequencyFrame(
2898 /*packet_number=*/2, /*ack_frequency_sequence_number=*/2, extra_3_ms);
2899 SerializedPacket packet3 = MakePacketWithAckFrequencyFrame(
2900 /*packet_number=*/3, /*ack_frequency_sequence_number=*/3, extra_2_ms);
2901 SerializedPacket packet4 = MakePacketWithAckFrequencyFrame(
2902 /*packet_number=*/4, /*ack_frequency_sequence_number=*/4, extra_1_ms);
2903
2904 // Send frame1, farme2, frame3, frame4.
2905 manager_.OnPacketSent(&packet1, clock_.Now(), NOT_RETRANSMISSION,
2906 HAS_RETRANSMITTABLE_DATA, /*measure_rtt=*/true,
2907 ECN_NOT_ECT);
2908 manager_.OnPacketSent(&packet2, clock_.Now(), NOT_RETRANSMISSION,
2909 HAS_RETRANSMITTABLE_DATA, /*measure_rtt=*/true,
2910 ECN_NOT_ECT);
2911 manager_.OnPacketSent(&packet3, clock_.Now(), NOT_RETRANSMISSION,
2912 HAS_RETRANSMITTABLE_DATA, /*measure_rtt=*/true,
2913 ECN_NOT_ECT);
2914 manager_.OnPacketSent(&packet4, clock_.Now(), NOT_RETRANSMISSION,
2915 NO_RETRANSMITTABLE_DATA, /*measure_rtt=*/true,
2916 ECN_NOT_ECT);
2917 EXPECT_EQ(manager_.peer_max_ack_delay(), extra_4_ms);
2918
2919 // Ack frame3.
2920 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
2921 clock_.Now());
2922 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(4));
2923 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
2924 ENCRYPTION_FORWARD_SECURE, kEmptyCounts);
2925 EXPECT_EQ(manager_.peer_max_ack_delay(), extra_2_ms);
2926 // Acking frame1 do not affect peer_max_ack_delay after frame3 is acked.
2927 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
2928 clock_.Now());
2929 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(4));
2930 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
2931 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
2932 ENCRYPTION_FORWARD_SECURE, kEmptyCounts);
2933 EXPECT_EQ(manager_.peer_max_ack_delay(), extra_2_ms);
2934 // Acking frame2 do not affect peer_max_ack_delay after frame3 is acked.
2935 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
2936 clock_.Now());
2937 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(4));
2938 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
2939 ENCRYPTION_FORWARD_SECURE, kEmptyCounts);
2940 EXPECT_EQ(manager_.peer_max_ack_delay(), extra_2_ms);
2941 // Acking frame4 updates peer_max_ack_delay.
2942 manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
2943 clock_.Now());
2944 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(5));
2945 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
2946 ENCRYPTION_FORWARD_SECURE, kEmptyCounts);
2947 EXPECT_EQ(manager_.peer_max_ack_delay(), extra_1_ms);
2948 }
2949
TEST_F(QuicSentPacketManagerTest,ClearDataInMessageFrameAfterPacketSent)2950 TEST_F(QuicSentPacketManagerTest, ClearDataInMessageFrameAfterPacketSent) {
2951 EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
2952
2953 QuicMessageFrame* message_frame = nullptr;
2954 {
2955 quiche::QuicheMemSlice slice(quiche::QuicheBuffer(&allocator_, 1024));
2956 message_frame = new QuicMessageFrame(/*message_id=*/1, std::move(slice));
2957 EXPECT_FALSE(message_frame->message_data.empty());
2958 EXPECT_EQ(message_frame->message_length, 1024);
2959
2960 SerializedPacket packet(QuicPacketNumber(1), PACKET_4BYTE_PACKET_NUMBER,
2961 /*encrypted_buffer=*/nullptr, kDefaultLength,
2962 /*has_ack=*/false,
2963 /*has_stop_waiting*/ false);
2964 packet.encryption_level = ENCRYPTION_FORWARD_SECURE;
2965 packet.retransmittable_frames.push_back(QuicFrame(message_frame));
2966 packet.has_message = true;
2967 manager_.OnPacketSent(&packet, clock_.Now(), NOT_RETRANSMISSION,
2968 HAS_RETRANSMITTABLE_DATA, /*measure_rtt=*/true,
2969 ECN_NOT_ECT);
2970 }
2971
2972 EXPECT_TRUE(message_frame->message_data.empty());
2973 EXPECT_EQ(message_frame->message_length, 0);
2974 }
2975
TEST_F(QuicSentPacketManagerTest,BuildAckFrequencyFrame)2976 TEST_F(QuicSentPacketManagerTest, BuildAckFrequencyFrame) {
2977 SetQuicReloadableFlag(quic_can_send_ack_frequency, true);
2978 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
2979 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
2980 QuicConfig config;
2981 QuicConfigPeer::SetReceivedMinAckDelayMs(&config, /*min_ack_delay_ms=*/1);
2982 manager_.SetFromConfig(config);
2983 manager_.SetHandshakeConfirmed();
2984
2985 // Set up RTTs.
2986 auto* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
2987 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(80),
2988 /*ack_delay=*/QuicTime::Delta::Zero(),
2989 /*now=*/QuicTime::Zero());
2990 // Make sure srtt and min_rtt are different.
2991 rtt_stats->UpdateRtt(
2992 QuicTime::Delta::FromMilliseconds(160),
2993 /*ack_delay=*/QuicTime::Delta::Zero(),
2994 /*now=*/QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(24));
2995
2996 auto frame = manager_.GetUpdatedAckFrequencyFrame();
2997 EXPECT_EQ(frame.max_ack_delay,
2998 std::max(rtt_stats->min_rtt() * 0.25,
2999 QuicTime::Delta::FromMilliseconds(1u)));
3000 EXPECT_EQ(frame.packet_tolerance, 10u);
3001 }
3002
TEST_F(QuicSentPacketManagerTest,SmoothedRttIgnoreAckDelay)3003 TEST_F(QuicSentPacketManagerTest, SmoothedRttIgnoreAckDelay) {
3004 QuicConfig config;
3005 QuicTagVector options;
3006 options.push_back(kMAD0);
3007 QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
3008 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
3009 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
3010 EXPECT_CALL(*send_algorithm_, CanSend(_)).WillRepeatedly(Return(true));
3011 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
3012 .WillRepeatedly(Return(10 * kDefaultTCPMSS));
3013 manager_.SetFromConfig(config);
3014
3015 SendDataPacket(1);
3016 // Ack 1.
3017 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(300));
3018 ExpectAck(1);
3019 manager_.OnAckFrameStart(QuicPacketNumber(1),
3020 QuicTime::Delta::FromMilliseconds(100),
3021 clock_.Now());
3022 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
3023 EXPECT_EQ(PACKETS_NEWLY_ACKED,
3024 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
3025 ENCRYPTION_INITIAL, kEmptyCounts));
3026 // Verify that ack_delay is ignored in the first measurement.
3027 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(300),
3028 manager_.GetRttStats()->latest_rtt());
3029 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(300),
3030 manager_.GetRttStats()->smoothed_rtt());
3031
3032 SendDataPacket(2);
3033 // Ack 2.
3034 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(300));
3035 ExpectAck(2);
3036 manager_.OnAckFrameStart(QuicPacketNumber(2),
3037 QuicTime::Delta::FromMilliseconds(100),
3038 clock_.Now());
3039 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(3));
3040 EXPECT_EQ(PACKETS_NEWLY_ACKED,
3041 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
3042 ENCRYPTION_INITIAL, kEmptyCounts));
3043 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(300),
3044 manager_.GetRttStats()->latest_rtt());
3045 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(300),
3046 manager_.GetRttStats()->smoothed_rtt());
3047
3048 SendDataPacket(3);
3049 // Ack 3.
3050 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(300));
3051 ExpectAck(3);
3052 manager_.OnAckFrameStart(QuicPacketNumber(3),
3053 QuicTime::Delta::FromMilliseconds(50), clock_.Now());
3054 manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(4));
3055 EXPECT_EQ(PACKETS_NEWLY_ACKED,
3056 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(3),
3057 ENCRYPTION_INITIAL, kEmptyCounts));
3058 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(300),
3059 manager_.GetRttStats()->latest_rtt());
3060 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(300),
3061 manager_.GetRttStats()->smoothed_rtt());
3062
3063 SendDataPacket(4);
3064 // Ack 4.
3065 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(200));
3066 ExpectAck(4);
3067 manager_.OnAckFrameStart(QuicPacketNumber(4),
3068 QuicTime::Delta::FromMilliseconds(300),
3069 clock_.Now());
3070 manager_.OnAckRange(QuicPacketNumber(4), QuicPacketNumber(5));
3071 EXPECT_EQ(PACKETS_NEWLY_ACKED,
3072 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(4),
3073 ENCRYPTION_INITIAL, kEmptyCounts));
3074 // Verify that large erroneous ack_delay does not change Smoothed RTT.
3075 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200),
3076 manager_.GetRttStats()->latest_rtt());
3077 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(287500),
3078 manager_.GetRttStats()->smoothed_rtt());
3079 }
3080
TEST_F(QuicSentPacketManagerTest,IgnorePeerMaxAckDelayDuringHandshake)3081 TEST_F(QuicSentPacketManagerTest, IgnorePeerMaxAckDelayDuringHandshake) {
3082 manager_.EnableMultiplePacketNumberSpacesSupport();
3083 // 100ms RTT.
3084 const QuicTime::Delta kTestRTT = QuicTime::Delta::FromMilliseconds(100);
3085
3086 // Server sends INITIAL 1 and HANDSHAKE 2.
3087 SendDataPacket(1, ENCRYPTION_INITIAL);
3088 SendDataPacket(2, ENCRYPTION_HANDSHAKE);
3089
3090 // Receive client ACK for INITIAL 1 after one RTT.
3091 clock_.AdvanceTime(kTestRTT);
3092 ExpectAck(1);
3093 manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
3094 clock_.Now());
3095 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
3096 EXPECT_EQ(PACKETS_NEWLY_ACKED,
3097 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
3098 ENCRYPTION_INITIAL, kEmptyCounts));
3099 EXPECT_EQ(kTestRTT, manager_.GetRttStats()->latest_rtt());
3100
3101 // Assume the cert verification on client takes 50ms, such that the HANDSHAKE
3102 // packet is queued for 50ms.
3103 const QuicTime::Delta queuing_delay = QuicTime::Delta::FromMilliseconds(50);
3104 clock_.AdvanceTime(queuing_delay);
3105 // Ack 2.
3106 ExpectAck(2);
3107 manager_.OnAckFrameStart(QuicPacketNumber(2), queuing_delay, clock_.Now());
3108 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(3));
3109 EXPECT_EQ(PACKETS_NEWLY_ACKED,
3110 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
3111 ENCRYPTION_HANDSHAKE, kEmptyCounts));
3112 EXPECT_EQ(kTestRTT, manager_.GetRttStats()->latest_rtt());
3113 }
3114
TEST_F(QuicSentPacketManagerTest,BuildAckFrequencyFrameWithSRTT)3115 TEST_F(QuicSentPacketManagerTest, BuildAckFrequencyFrameWithSRTT) {
3116 SetQuicReloadableFlag(quic_can_send_ack_frequency, true);
3117 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
3118 EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
3119 QuicConfig config;
3120 QuicConfigPeer::SetReceivedMinAckDelayMs(&config, /*min_ack_delay_ms=*/1);
3121 QuicTagVector quic_tag_vector;
3122 quic_tag_vector.push_back(kAFF1); // SRTT enabling tag.
3123 QuicConfigPeer::SetReceivedConnectionOptions(&config, quic_tag_vector);
3124 manager_.SetFromConfig(config);
3125 manager_.SetHandshakeConfirmed();
3126
3127 // Set up RTTs.
3128 auto* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
3129 rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(80),
3130 /*ack_delay=*/QuicTime::Delta::Zero(),
3131 /*now=*/QuicTime::Zero());
3132 // Make sure srtt and min_rtt are different.
3133 rtt_stats->UpdateRtt(
3134 QuicTime::Delta::FromMilliseconds(160),
3135 /*ack_delay=*/QuicTime::Delta::Zero(),
3136 /*now=*/QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(24));
3137
3138 auto frame = manager_.GetUpdatedAckFrequencyFrame();
3139 EXPECT_EQ(frame.max_ack_delay,
3140 std::max(rtt_stats->SmoothedOrInitialRtt() * 0.25,
3141 QuicTime::Delta::FromMilliseconds(1u)));
3142 }
3143
TEST_F(QuicSentPacketManagerTest,SetInitialRtt)3144 TEST_F(QuicSentPacketManagerTest, SetInitialRtt) {
3145 // Upper bounds.
3146 manager_.SetInitialRtt(
3147 QuicTime::Delta::FromMicroseconds(kMaxInitialRoundTripTimeUs + 1), false);
3148 EXPECT_EQ(manager_.GetRttStats()->initial_rtt().ToMicroseconds(),
3149 kMaxInitialRoundTripTimeUs);
3150
3151 manager_.SetInitialRtt(
3152 QuicTime::Delta::FromMicroseconds(kMaxInitialRoundTripTimeUs + 1), true);
3153 EXPECT_EQ(manager_.GetRttStats()->initial_rtt().ToMicroseconds(),
3154 kMaxInitialRoundTripTimeUs);
3155
3156 EXPECT_GT(kMinUntrustedInitialRoundTripTimeUs,
3157 kMinTrustedInitialRoundTripTimeUs);
3158
3159 // Lower bounds for untrusted rtt.
3160 manager_.SetInitialRtt(QuicTime::Delta::FromMicroseconds(
3161 kMinUntrustedInitialRoundTripTimeUs - 1),
3162 false);
3163 EXPECT_EQ(manager_.GetRttStats()->initial_rtt().ToMicroseconds(),
3164 kMinUntrustedInitialRoundTripTimeUs);
3165
3166 // Lower bounds for trusted rtt.
3167 manager_.SetInitialRtt(QuicTime::Delta::FromMicroseconds(
3168 kMinUntrustedInitialRoundTripTimeUs - 1),
3169 true);
3170 EXPECT_EQ(manager_.GetRttStats()->initial_rtt().ToMicroseconds(),
3171 kMinUntrustedInitialRoundTripTimeUs - 1);
3172
3173 manager_.SetInitialRtt(
3174 QuicTime::Delta::FromMicroseconds(kMinTrustedInitialRoundTripTimeUs - 1),
3175 true);
3176 EXPECT_EQ(manager_.GetRttStats()->initial_rtt().ToMicroseconds(),
3177 kMinTrustedInitialRoundTripTimeUs);
3178 }
3179
TEST_F(QuicSentPacketManagerTest,GetAvailableCongestionWindow)3180 TEST_F(QuicSentPacketManagerTest, GetAvailableCongestionWindow) {
3181 SendDataPacket(1);
3182 EXPECT_EQ(kDefaultLength, manager_.GetBytesInFlight());
3183
3184 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
3185 .WillOnce(Return(kDefaultLength + 10));
3186 EXPECT_EQ(10u, manager_.GetAvailableCongestionWindowInBytes());
3187
3188 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
3189 .WillOnce(Return(kDefaultLength));
3190 EXPECT_EQ(0u, manager_.GetAvailableCongestionWindowInBytes());
3191
3192 EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
3193 .WillOnce(Return(kDefaultLength - 10));
3194 EXPECT_EQ(0u, manager_.GetAvailableCongestionWindowInBytes());
3195 }
3196
TEST_F(QuicSentPacketManagerTest,EcnCountsAreStored)3197 TEST_F(QuicSentPacketManagerTest, EcnCountsAreStored) {
3198 if (!GetQuicRestartFlag(quic_support_ect1)) {
3199 return;
3200 }
3201 std::optional<QuicEcnCounts> ecn_counts1, ecn_counts2, ecn_counts3;
3202 ecn_counts1 = {1, 0, 3};
3203 ecn_counts2 = {0, 3, 1};
3204 ecn_counts3 = {0, 2, 0};
3205 SendDataPacket(1, ENCRYPTION_INITIAL, ECN_ECT0);
3206 SendDataPacket(2, ENCRYPTION_INITIAL, ECN_ECT0);
3207 SendDataPacket(3, ENCRYPTION_INITIAL, ECN_ECT0);
3208 SendDataPacket(4, ENCRYPTION_INITIAL, ECN_ECT0);
3209 SendDataPacket(5, ENCRYPTION_HANDSHAKE, ECN_ECT1);
3210 SendDataPacket(6, ENCRYPTION_HANDSHAKE, ECN_ECT1);
3211 SendDataPacket(7, ENCRYPTION_HANDSHAKE, ECN_ECT1);
3212 SendDataPacket(8, ENCRYPTION_HANDSHAKE, ECN_ECT1);
3213 SendDataPacket(9, ENCRYPTION_FORWARD_SECURE, ECN_ECT1);
3214 SendDataPacket(10, ENCRYPTION_FORWARD_SECURE, ECN_ECT1);
3215 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1), ENCRYPTION_INITIAL,
3216 ecn_counts1);
3217 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
3218 ENCRYPTION_HANDSHAKE, ecn_counts2);
3219
3220 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(3),
3221 ENCRYPTION_FORWARD_SECURE, ecn_counts3);
3222 EXPECT_EQ(
3223 *QuicSentPacketManagerPeer::GetPeerEcnCounts(&manager_, INITIAL_DATA),
3224 ecn_counts1);
3225 EXPECT_EQ(
3226 *QuicSentPacketManagerPeer::GetPeerEcnCounts(&manager_, HANDSHAKE_DATA),
3227 ecn_counts2);
3228 EXPECT_EQ(
3229 *QuicSentPacketManagerPeer::GetPeerEcnCounts(&manager_, APPLICATION_DATA),
3230 ecn_counts3);
3231 }
3232
TEST_F(QuicSentPacketManagerTest,EcnCountsReceived)3233 TEST_F(QuicSentPacketManagerTest, EcnCountsReceived) {
3234 if (!GetQuicRestartFlag(quic_support_ect1)) {
3235 return;
3236 }
3237 // Basic ECN reporting test. The reported counts are equal to the total sent,
3238 // but more than the total acked. This is legal per the spec.
3239 for (uint64_t i = 1; i <= 3; ++i) {
3240 SendDataPacket(i, ENCRYPTION_FORWARD_SECURE, ECN_ECT1);
3241 }
3242 // Ack the last two packets, but report 3 counts (ack of 1 was lost).
3243 EXPECT_CALL(*network_change_visitor_, OnInFlightEcnPacketAcked()).Times(2);
3244 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
3245 clock_.Now());
3246 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(4));
3247 EXPECT_CALL(*send_algorithm_,
3248 OnCongestionEvent(_, _, _, Pointwise(PacketNumberEq(), {2, 3}),
3249 IsEmpty(), 2, 1))
3250 .Times(1);
3251 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()).Times(1);
3252 std::optional<QuicEcnCounts> ecn_counts = QuicEcnCounts();
3253 ecn_counts->ect1 = QuicPacketCount(2);
3254 ecn_counts->ce = QuicPacketCount(1);
3255 EXPECT_EQ(PACKETS_NEWLY_ACKED,
3256 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
3257 ENCRYPTION_FORWARD_SECURE, ecn_counts));
3258 }
3259
TEST_F(QuicSentPacketManagerTest,PeerDecrementsEcnCounts)3260 TEST_F(QuicSentPacketManagerTest, PeerDecrementsEcnCounts) {
3261 if (!GetQuicRestartFlag(quic_support_ect1)) {
3262 return;
3263 }
3264 for (uint64_t i = 1; i <= 5; ++i) {
3265 SendDataPacket(i, ENCRYPTION_FORWARD_SECURE, ECN_ECT1);
3266 }
3267 // Ack all three packets).
3268 EXPECT_CALL(*network_change_visitor_, OnInFlightEcnPacketAcked()).Times(3);
3269 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
3270 clock_.Now());
3271 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(4));
3272 EXPECT_CALL(*send_algorithm_,
3273 OnCongestionEvent(_, _, _, Pointwise(PacketNumberEq(), {1, 2, 3}),
3274 IsEmpty(), 2, 1))
3275 .Times(1);
3276 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()).Times(1);
3277 std::optional<QuicEcnCounts> ecn_counts = QuicEcnCounts();
3278 ecn_counts->ect1 = QuicPacketCount(2);
3279 ecn_counts->ce = QuicPacketCount(1);
3280 EXPECT_EQ(PACKETS_NEWLY_ACKED,
3281 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
3282 ENCRYPTION_FORWARD_SECURE, ecn_counts));
3283 // New ack, counts decline
3284 EXPECT_CALL(*network_change_visitor_, OnInFlightEcnPacketAcked()).Times(1);
3285 manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
3286 clock_.Now());
3287 manager_.OnAckRange(QuicPacketNumber(4), QuicPacketNumber(5));
3288 EXPECT_CALL(*network_change_visitor_, OnInvalidEcnFeedback());
3289 EXPECT_CALL(*send_algorithm_,
3290 OnCongestionEvent(_, _, _, Pointwise(PacketNumberEq(), {4}),
3291 IsEmpty(), 0, 0))
3292 .Times(1);
3293 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()).Times(1);
3294 ecn_counts = QuicEcnCounts();
3295 ecn_counts->ect1 = QuicPacketCount(3);
3296 ecn_counts->ce = QuicPacketCount(0); // Reduced CE count
3297 EXPECT_EQ(PACKETS_NEWLY_ACKED,
3298 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
3299 ENCRYPTION_FORWARD_SECURE, ecn_counts));
3300 }
3301
TEST_F(QuicSentPacketManagerTest,TooManyEcnCountsReported)3302 TEST_F(QuicSentPacketManagerTest, TooManyEcnCountsReported) {
3303 if (!GetQuicRestartFlag(quic_support_ect1)) {
3304 return;
3305 }
3306 for (uint64_t i = 1; i <= 3; ++i) {
3307 SendDataPacket(i, ENCRYPTION_FORWARD_SECURE, ECN_ECT1);
3308 }
3309 // Ack the last two packets, but report 3 counts (ack of 1 was lost).
3310 EXPECT_CALL(*network_change_visitor_, OnInFlightEcnPacketAcked()).Times(2);
3311 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
3312 clock_.Now());
3313 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(4));
3314 std::optional<QuicEcnCounts> ecn_counts = QuicEcnCounts();
3315 // Report 4 counts, but only 3 packets were sent.
3316 ecn_counts->ect1 = QuicPacketCount(3);
3317 ecn_counts->ce = QuicPacketCount(1);
3318 EXPECT_CALL(*network_change_visitor_, OnInvalidEcnFeedback());
3319 EXPECT_CALL(*send_algorithm_,
3320 OnCongestionEvent(_, _, _, Pointwise(PacketNumberEq(), {2, 3}),
3321 IsEmpty(), 0, 0))
3322 .Times(1);
3323 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()).Times(1);
3324
3325 EXPECT_EQ(PACKETS_NEWLY_ACKED,
3326 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
3327 ENCRYPTION_FORWARD_SECURE, ecn_counts));
3328 }
3329
TEST_F(QuicSentPacketManagerTest,PeerReportsWrongCodepoint)3330 TEST_F(QuicSentPacketManagerTest, PeerReportsWrongCodepoint) {
3331 if (!GetQuicRestartFlag(quic_support_ect1)) {
3332 return;
3333 }
3334 for (uint64_t i = 1; i <= 3; ++i) {
3335 SendDataPacket(i, ENCRYPTION_FORWARD_SECURE, ECN_ECT1);
3336 }
3337 // Ack the last two packets, but report 3 counts (ack of 1 was lost).
3338 EXPECT_CALL(*network_change_visitor_, OnInFlightEcnPacketAcked()).Times(2);
3339 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
3340 clock_.Now());
3341 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(4));
3342 std::optional<QuicEcnCounts> ecn_counts = QuicEcnCounts();
3343 // Report the wrong codepoint.
3344 ecn_counts->ect0 = QuicPacketCount(2);
3345 ecn_counts->ce = QuicPacketCount(1);
3346 EXPECT_CALL(*network_change_visitor_, OnInvalidEcnFeedback());
3347 EXPECT_CALL(*send_algorithm_,
3348 OnCongestionEvent(_, _, _, Pointwise(PacketNumberEq(), {2, 3}),
3349 IsEmpty(), 0, 0))
3350 .Times(1);
3351 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()).Times(1);
3352
3353 EXPECT_EQ(PACKETS_NEWLY_ACKED,
3354 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
3355 ENCRYPTION_FORWARD_SECURE, ecn_counts));
3356 }
3357
TEST_F(QuicSentPacketManagerTest,TooFewEcnCountsReported)3358 TEST_F(QuicSentPacketManagerTest, TooFewEcnCountsReported) {
3359 if (!GetQuicRestartFlag(quic_support_ect1)) {
3360 return;
3361 }
3362 for (uint64_t i = 1; i <= 3; ++i) {
3363 SendDataPacket(i, ENCRYPTION_FORWARD_SECURE, ECN_ECT1);
3364 }
3365 // Ack the last two packets, but report 3 counts (ack of 1 was lost).
3366 EXPECT_CALL(*network_change_visitor_, OnInFlightEcnPacketAcked()).Times(2);
3367 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
3368 clock_.Now());
3369 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(4));
3370 EXPECT_CALL(*network_change_visitor_, OnInvalidEcnFeedback());
3371 EXPECT_CALL(*send_algorithm_,
3372 OnCongestionEvent(_, _, _, Pointwise(PacketNumberEq(), {2, 3}),
3373 IsEmpty(), 0, 0))
3374 .Times(1);
3375 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()).Times(1);
3376 std::optional<QuicEcnCounts> ecn_counts = QuicEcnCounts();
3377 // 2 ECN packets were newly acked, but only one count was reported.
3378 ecn_counts->ect1 = QuicPacketCount(1);
3379 ecn_counts->ce = QuicPacketCount(0);
3380 EXPECT_EQ(PACKETS_NEWLY_ACKED,
3381 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
3382 ENCRYPTION_FORWARD_SECURE, ecn_counts));
3383 }
3384
TEST_F(QuicSentPacketManagerTest,EcnCountsNotValidatedIfLargestAckedUnchanged)3385 TEST_F(QuicSentPacketManagerTest,
3386 EcnCountsNotValidatedIfLargestAckedUnchanged) {
3387 if (!GetQuicRestartFlag(quic_support_ect1)) {
3388 return;
3389 }
3390 for (uint64_t i = 1; i <= 3; ++i) {
3391 SendDataPacket(i, ENCRYPTION_FORWARD_SECURE, ECN_ECT1);
3392 }
3393 // Ack two packets.
3394 EXPECT_CALL(*network_change_visitor_, OnInFlightEcnPacketAcked()).Times(2);
3395 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
3396 clock_.Now());
3397 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(4));
3398 EXPECT_CALL(*send_algorithm_,
3399 OnCongestionEvent(_, _, _, Pointwise(PacketNumberEq(), {2, 3}),
3400 IsEmpty(), 2, 1))
3401 .Times(1);
3402 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()).Times(1);
3403 std::optional<QuicEcnCounts> ecn_counts = QuicEcnCounts();
3404 ecn_counts->ect1 = QuicPacketCount(2);
3405 ecn_counts->ce = QuicPacketCount(1);
3406 EXPECT_EQ(PACKETS_NEWLY_ACKED,
3407 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
3408 ENCRYPTION_FORWARD_SECURE, ecn_counts));
3409 // Ack the first packet, which will not update largest_acked.
3410 EXPECT_CALL(*network_change_visitor_, OnInFlightEcnPacketAcked()).Times(1);
3411 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
3412 clock_.Now());
3413 manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(4));
3414 EXPECT_CALL(*send_algorithm_,
3415 OnCongestionEvent(_, _, _, Pointwise(PacketNumberEq(), {1}),
3416 IsEmpty(), 0, 0))
3417 .Times(1);
3418 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()).Times(1);
3419 ecn_counts = QuicEcnCounts();
3420 // Counts decline, but there's no validation because largest_acked didn't
3421 // change.
3422 ecn_counts->ect1 = QuicPacketCount(2);
3423 ecn_counts->ce = QuicPacketCount(0); // Reduced CE count
3424 EXPECT_EQ(PACKETS_NEWLY_ACKED,
3425 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
3426 ENCRYPTION_FORWARD_SECURE, ecn_counts));
3427 }
3428
TEST_F(QuicSentPacketManagerTest,EcnAckedButNoMarksReported)3429 TEST_F(QuicSentPacketManagerTest, EcnAckedButNoMarksReported) {
3430 if (!GetQuicRestartFlag(quic_support_ect1)) {
3431 return;
3432 }
3433 for (uint64_t i = 1; i <= 3; ++i) {
3434 SendDataPacket(i, ENCRYPTION_FORWARD_SECURE, ECN_ECT1);
3435 }
3436 // Ack the last two packets, but report 3 counts (ack of 1 was lost).
3437 EXPECT_CALL(*network_change_visitor_, OnInFlightEcnPacketAcked()).Times(2);
3438 manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
3439 clock_.Now());
3440 manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(4));
3441 EXPECT_CALL(*network_change_visitor_, OnInvalidEcnFeedback());
3442 EXPECT_CALL(*send_algorithm_,
3443 OnCongestionEvent(_, _, _, Pointwise(PacketNumberEq(), {2, 3}),
3444 IsEmpty(), 0, 0))
3445 .Times(1);
3446 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()).Times(1);
3447 std::optional<QuicEcnCounts> ecn_counts = std::nullopt;
3448 EXPECT_EQ(PACKETS_NEWLY_ACKED,
3449 manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1),
3450 ENCRYPTION_FORWARD_SECURE, ecn_counts));
3451 }
3452
3453 } // namespace
3454 } // namespace test
3455 } // namespace quic
3456