| OLD | NEW |
|---|
| (Empty) |
| 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 "net/quic/quic_sent_packet_manager.h" | |
| 6 | |
| 7 #include <memory> | |
| 8 | |
| 9 #include "base/stl_util.h" | |
| 10 #include "net/quic/quic_flags.h" | |
| 11 #include "net/quic/test_tools/quic_config_peer.h" | |
| 12 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h" | |
| 13 #include "net/quic/test_tools/quic_test_utils.h" | |
| 14 #include "testing/gmock/include/gmock/gmock.h" | |
| 15 #include "testing/gtest/include/gtest/gtest.h" | |
| 16 | |
| 17 using std::vector; | |
| 18 using testing::AnyNumber; | |
| 19 using testing::ElementsAre; | |
| 20 using testing::IsEmpty; | |
| 21 using testing::Not; | |
| 22 using testing::Pair; | |
| 23 using testing::Pointwise; | |
| 24 using testing::Return; | |
| 25 using testing::SetArgPointee; | |
| 26 using testing::StrictMock; | |
| 27 using testing::_; | |
| 28 | |
| 29 namespace net { | |
| 30 namespace test { | |
| 31 namespace { | |
| 32 | |
| 33 // Default packet length. | |
| 34 const uint32_t kDefaultLength = 1000; | |
| 35 | |
| 36 // Stream ID for data sent in CreatePacket(). | |
| 37 const QuicStreamId kStreamId = 7; | |
| 38 | |
| 39 // Minimum number of consecutive RTOs before path is considered to be degrading. | |
| 40 const size_t kMinTimeoutsBeforePathDegrading = 2; | |
| 41 | |
| 42 // Matcher to check the key of the key-value pair it receives as first argument | |
| 43 // equals its second argument. | |
| 44 MATCHER(KeyEq, "") { | |
| 45 return std::tr1::get<0>(arg).first == std::tr1::get<1>(arg); | |
| 46 } | |
| 47 | |
| 48 class MockDebugDelegate : public QuicSentPacketManagerInterface::DebugDelegate { | |
| 49 public: | |
| 50 MOCK_METHOD2(OnSpuriousPacketRetransmission, | |
| 51 void(TransmissionType transmission_type, | |
| 52 QuicByteCount byte_size)); | |
| 53 MOCK_METHOD3(OnPacketLoss, | |
| 54 void(QuicPacketNumber lost_packet_number, | |
| 55 TransmissionType transmission_type, | |
| 56 QuicTime detection_time)); | |
| 57 }; | |
| 58 | |
| 59 // Run tests with different ack frame packets set mode. | |
| 60 struct TestParams { | |
| 61 explicit TestParams(bool missing) : missing(missing) {} | |
| 62 | |
| 63 friend std::ostream& operator<<(std::ostream& os, const TestParams& p) { | |
| 64 os << "{ ack frame packets set mode: " << p.missing << " }"; | |
| 65 return os; | |
| 66 } | |
| 67 | |
| 68 bool missing; | |
| 69 }; | |
| 70 | |
| 71 vector<TestParams> GetTestParams() { | |
| 72 vector<TestParams> params; | |
| 73 for (bool missing : {true, false}) { | |
| 74 params.push_back(TestParams(missing)); | |
| 75 } | |
| 76 return params; | |
| 77 } | |
| 78 | |
| 79 class QuicSentPacketManagerTest : public ::testing::TestWithParam<TestParams> { | |
| 80 protected: | |
| 81 QuicSentPacketManagerTest() | |
| 82 : manager_(Perspective::IS_SERVER, | |
| 83 kDefaultPathId, | |
| 84 &clock_, | |
| 85 &stats_, | |
| 86 kCubic, | |
| 87 kNack, | |
| 88 /*delegate=*/nullptr), | |
| 89 send_algorithm_(new StrictMock<MockSendAlgorithm>), | |
| 90 network_change_visitor_(new StrictMock<MockNetworkChangeVisitor>) { | |
| 91 QuicSentPacketManagerPeer::SetSendAlgorithm(&manager_, send_algorithm_); | |
| 92 // Disable tail loss probes for most tests. | |
| 93 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 0); | |
| 94 // Advance the time 1s so the send times are never QuicTime::Zero. | |
| 95 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000)); | |
| 96 manager_.SetNetworkChangeVisitor(network_change_visitor_.get()); | |
| 97 | |
| 98 EXPECT_CALL(*send_algorithm_, HasReliableBandwidthEstimate()) | |
| 99 .Times(AnyNumber()); | |
| 100 EXPECT_CALL(*send_algorithm_, BandwidthEstimate()) | |
| 101 .Times(AnyNumber()) | |
| 102 .WillRepeatedly(Return(QuicBandwidth::Zero())); | |
| 103 EXPECT_CALL(*send_algorithm_, InSlowStart()).Times(AnyNumber()); | |
| 104 EXPECT_CALL(*send_algorithm_, InRecovery()).Times(AnyNumber()); | |
| 105 EXPECT_CALL(*network_change_visitor_, OnPathMtuIncreased(1000)) | |
| 106 .Times(AnyNumber()); | |
| 107 } | |
| 108 | |
| 109 ~QuicSentPacketManagerTest() override { | |
| 110 STLDeleteElements(&packets_); | |
| 111 } | |
| 112 | |
| 113 QuicByteCount BytesInFlight() { | |
| 114 return QuicSentPacketManagerPeer::GetBytesInFlight(&manager_); | |
| 115 } | |
| 116 void VerifyUnackedPackets(QuicPacketNumber* packets, size_t num_packets) { | |
| 117 if (num_packets == 0) { | |
| 118 EXPECT_FALSE(manager_.HasUnackedPackets()); | |
| 119 EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetNumRetransmittablePackets( | |
| 120 &manager_)); | |
| 121 return; | |
| 122 } | |
| 123 | |
| 124 EXPECT_TRUE(manager_.HasUnackedPackets()); | |
| 125 EXPECT_EQ(packets[0], manager_.GetLeastUnacked(kDefaultPathId)); | |
| 126 for (size_t i = 0; i < num_packets; ++i) { | |
| 127 EXPECT_TRUE(QuicSentPacketManagerPeer::IsUnacked(&manager_, packets[i])) | |
| 128 << packets[i]; | |
| 129 } | |
| 130 } | |
| 131 | |
| 132 void VerifyRetransmittablePackets(QuicPacketNumber* packets, | |
| 133 size_t num_packets) { | |
| 134 EXPECT_EQ( | |
| 135 num_packets, | |
| 136 QuicSentPacketManagerPeer::GetNumRetransmittablePackets(&manager_)); | |
| 137 for (size_t i = 0; i < num_packets; ++i) { | |
| 138 EXPECT_TRUE(QuicSentPacketManagerPeer::HasRetransmittableFrames( | |
| 139 &manager_, packets[i])) | |
| 140 << " packets[" << i << "]:" << packets[i]; | |
| 141 } | |
| 142 } | |
| 143 | |
| 144 void ExpectAck(QuicPacketNumber largest_observed) { | |
| 145 EXPECT_CALL( | |
| 146 *send_algorithm_, | |
| 147 OnCongestionEvent(true, _, ElementsAre(Pair(largest_observed, _)), | |
| 148 IsEmpty())); | |
| 149 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 150 } | |
| 151 | |
| 152 void ExpectUpdatedRtt(QuicPacketNumber largest_observed) { | |
| 153 EXPECT_CALL(*send_algorithm_, | |
| 154 OnCongestionEvent(true, _, IsEmpty(), IsEmpty())); | |
| 155 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 156 } | |
| 157 | |
| 158 void ExpectAckAndLoss(bool rtt_updated, | |
| 159 QuicPacketNumber largest_observed, | |
| 160 QuicPacketNumber lost_packet) { | |
| 161 EXPECT_CALL(*send_algorithm_, | |
| 162 OnCongestionEvent(rtt_updated, _, | |
| 163 ElementsAre(Pair(largest_observed, _)), | |
| 164 ElementsAre(Pair(lost_packet, _)))); | |
| 165 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 166 } | |
| 167 | |
| 168 // |packets_acked| and |packets_lost| should be in packet number order. | |
| 169 void ExpectAcksAndLosses(bool rtt_updated, | |
| 170 QuicPacketNumber* packets_acked, | |
| 171 size_t num_packets_acked, | |
| 172 QuicPacketNumber* packets_lost, | |
| 173 size_t num_packets_lost) { | |
| 174 vector<QuicPacketNumber> ack_vector; | |
| 175 for (size_t i = 0; i < num_packets_acked; ++i) { | |
| 176 ack_vector.push_back(packets_acked[i]); | |
| 177 } | |
| 178 vector<QuicPacketNumber> lost_vector; | |
| 179 for (size_t i = 0; i < num_packets_lost; ++i) { | |
| 180 lost_vector.push_back(packets_lost[i]); | |
| 181 } | |
| 182 EXPECT_CALL( | |
| 183 *send_algorithm_, | |
| 184 OnCongestionEvent(rtt_updated, _, Pointwise(KeyEq(), ack_vector), | |
| 185 Pointwise(KeyEq(), lost_vector))); | |
| 186 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()) | |
| 187 .Times(AnyNumber()); | |
| 188 } | |
| 189 | |
| 190 void RetransmitAndSendPacket(QuicPacketNumber old_packet_number, | |
| 191 QuicPacketNumber new_packet_number) { | |
| 192 RetransmitAndSendPacket(old_packet_number, new_packet_number, | |
| 193 TLP_RETRANSMISSION); | |
| 194 } | |
| 195 | |
| 196 void RetransmitAndSendPacket(QuicPacketNumber old_packet_number, | |
| 197 QuicPacketNumber new_packet_number, | |
| 198 TransmissionType transmission_type) { | |
| 199 QuicSentPacketManagerPeer::MarkForRetransmission( | |
| 200 &manager_, kDefaultPathId, old_packet_number, transmission_type); | |
| 201 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 202 PendingRetransmission next_retransmission = | |
| 203 manager_.NextPendingRetransmission(); | |
| 204 EXPECT_EQ(old_packet_number, next_retransmission.packet_number); | |
| 205 EXPECT_EQ(transmission_type, next_retransmission.transmission_type); | |
| 206 | |
| 207 EXPECT_CALL(*send_algorithm_, | |
| 208 OnPacketSent(_, BytesInFlight(), new_packet_number, | |
| 209 kDefaultLength, HAS_RETRANSMITTABLE_DATA)) | |
| 210 .WillOnce(Return(true)); | |
| 211 SerializedPacket packet(CreatePacket(new_packet_number, false)); | |
| 212 manager_.OnPacketSent(&packet, packet.path_id, old_packet_number, | |
| 213 clock_.Now(), transmission_type, | |
| 214 HAS_RETRANSMITTABLE_DATA); | |
| 215 EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission( | |
| 216 &manager_, packet.path_id, new_packet_number)); | |
| 217 } | |
| 218 | |
| 219 SerializedPacket CreateDataPacket(QuicPacketNumber packet_number) { | |
| 220 return CreatePacket(packet_number, true); | |
| 221 } | |
| 222 | |
| 223 SerializedPacket CreatePacket(QuicPacketNumber packet_number, | |
| 224 bool retransmittable) { | |
| 225 SerializedPacket packet(kDefaultPathId, packet_number, | |
| 226 PACKET_6BYTE_PACKET_NUMBER, nullptr, kDefaultLength, | |
| 227 0u, false, false); | |
| 228 if (retransmittable) { | |
| 229 packet.retransmittable_frames.push_back( | |
| 230 QuicFrame(new QuicStreamFrame(kStreamId, false, 0, StringPiece()))); | |
| 231 } | |
| 232 return packet; | |
| 233 } | |
| 234 | |
| 235 void SendDataPacket(QuicPacketNumber packet_number) { | |
| 236 EXPECT_CALL(*send_algorithm_, | |
| 237 OnPacketSent(_, BytesInFlight(), packet_number, _, _)) | |
| 238 .Times(1) | |
| 239 .WillOnce(Return(true)); | |
| 240 SerializedPacket packet(CreateDataPacket(packet_number)); | |
| 241 manager_.OnPacketSent(&packet, kInvalidPathId, 0, clock_.Now(), | |
| 242 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA); | |
| 243 } | |
| 244 | |
| 245 void SendCryptoPacket(QuicPacketNumber packet_number) { | |
| 246 EXPECT_CALL(*send_algorithm_, | |
| 247 OnPacketSent(_, BytesInFlight(), packet_number, kDefaultLength, | |
| 248 HAS_RETRANSMITTABLE_DATA)) | |
| 249 .Times(1) | |
| 250 .WillOnce(Return(true)); | |
| 251 SerializedPacket packet(CreateDataPacket(packet_number)); | |
| 252 packet.retransmittable_frames.push_back( | |
| 253 QuicFrame(new QuicStreamFrame(1, false, 0, StringPiece()))); | |
| 254 packet.has_crypto_handshake = IS_HANDSHAKE; | |
| 255 manager_.OnPacketSent(&packet, kInvalidPathId, 0, clock_.Now(), | |
| 256 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA); | |
| 257 } | |
| 258 | |
| 259 void SendAckPacket(QuicPacketNumber packet_number) { | |
| 260 EXPECT_CALL(*send_algorithm_, | |
| 261 OnPacketSent(_, BytesInFlight(), packet_number, kDefaultLength, | |
| 262 NO_RETRANSMITTABLE_DATA)) | |
| 263 .Times(1) | |
| 264 .WillOnce(Return(false)); | |
| 265 SerializedPacket packet(CreatePacket(packet_number, false)); | |
| 266 manager_.OnPacketSent(&packet, kInvalidPathId, 0, clock_.Now(), | |
| 267 NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA); | |
| 268 } | |
| 269 | |
| 270 // Based on QuicConnection's WritePendingRetransmissions. | |
| 271 void RetransmitNextPacket(QuicPacketNumber retransmission_packet_number) { | |
| 272 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 273 EXPECT_CALL(*send_algorithm_, | |
| 274 OnPacketSent(_, _, retransmission_packet_number, kDefaultLength, | |
| 275 HAS_RETRANSMITTABLE_DATA)) | |
| 276 .Times(1) | |
| 277 .WillOnce(Return(true)); | |
| 278 const PendingRetransmission pending = manager_.NextPendingRetransmission(); | |
| 279 SerializedPacket packet(CreatePacket(retransmission_packet_number, false)); | |
| 280 manager_.OnPacketSent(&packet, pending.path_id, pending.packet_number, | |
| 281 clock_.Now(), pending.transmission_type, | |
| 282 HAS_RETRANSMITTABLE_DATA); | |
| 283 } | |
| 284 | |
| 285 // Initialize a frame acknowledging all packets up to largest_observed. | |
| 286 const QuicAckFrame InitAckFrame(QuicPacketNumber largest_observed) { | |
| 287 QuicAckFrame frame(MakeAckFrame(largest_observed)); | |
| 288 frame.missing = GetParam().missing; | |
| 289 if (!GetParam().missing) { | |
| 290 if (largest_observed > 0) { | |
| 291 frame.packets.Add(1, largest_observed + 1); | |
| 292 } | |
| 293 } | |
| 294 return frame; | |
| 295 } | |
| 296 | |
| 297 // Explicitly nack packet [lower, higher). | |
| 298 void NackPackets(QuicPacketNumber lower, | |
| 299 QuicPacketNumber higher, | |
| 300 QuicAckFrame* frame) { | |
| 301 if (frame->missing) { | |
| 302 frame->packets.Add(lower, higher); | |
| 303 } else { | |
| 304 frame->packets.Remove(lower, higher); | |
| 305 } | |
| 306 } | |
| 307 | |
| 308 QuicSentPacketManager manager_; | |
| 309 vector<QuicEncryptedPacket*> packets_; | |
| 310 MockClock clock_; | |
| 311 QuicConnectionStats stats_; | |
| 312 MockSendAlgorithm* send_algorithm_; | |
| 313 std::unique_ptr<MockNetworkChangeVisitor> network_change_visitor_; | |
| 314 }; | |
| 315 | |
| 316 INSTANTIATE_TEST_CASE_P(QuicSentPacketManagerTest, | |
| 317 QuicSentPacketManagerTest, | |
| 318 ::testing::ValuesIn(GetTestParams())); | |
| 319 | |
| 320 TEST_P(QuicSentPacketManagerTest, IsUnacked) { | |
| 321 VerifyUnackedPackets(nullptr, 0); | |
| 322 SendDataPacket(1); | |
| 323 | |
| 324 QuicPacketNumber unacked[] = {1}; | |
| 325 VerifyUnackedPackets(unacked, arraysize(unacked)); | |
| 326 QuicPacketNumber retransmittable[] = {1}; | |
| 327 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable)); | |
| 328 } | |
| 329 | |
| 330 TEST_P(QuicSentPacketManagerTest, IsUnAckedRetransmit) { | |
| 331 SendDataPacket(1); | |
| 332 RetransmitAndSendPacket(1, 2); | |
| 333 | |
| 334 EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(&manager_, | |
| 335 kDefaultPathId, 2)); | |
| 336 QuicPacketNumber unacked[] = {1, 2}; | |
| 337 VerifyUnackedPackets(unacked, arraysize(unacked)); | |
| 338 QuicPacketNumber retransmittable[] = {2}; | |
| 339 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable)); | |
| 340 } | |
| 341 | |
| 342 TEST_P(QuicSentPacketManagerTest, RetransmitThenAck) { | |
| 343 SendDataPacket(1); | |
| 344 RetransmitAndSendPacket(1, 2); | |
| 345 | |
| 346 // Ack 2 but not 1. | |
| 347 QuicAckFrame ack_frame = InitAckFrame(2); | |
| 348 NackPackets(1, 2, &ack_frame); | |
| 349 ExpectAck(2); | |
| 350 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 351 | |
| 352 // Packet 1 is unacked, pending, but not retransmittable. | |
| 353 QuicPacketNumber unacked[] = {1}; | |
| 354 VerifyUnackedPackets(unacked, arraysize(unacked)); | |
| 355 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | |
| 356 VerifyRetransmittablePackets(nullptr, 0); | |
| 357 } | |
| 358 | |
| 359 TEST_P(QuicSentPacketManagerTest, RetransmitThenAckBeforeSend) { | |
| 360 SendDataPacket(1); | |
| 361 QuicSentPacketManagerPeer::MarkForRetransmission(&manager_, kDefaultPathId, 1, | |
| 362 TLP_RETRANSMISSION); | |
| 363 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 364 | |
| 365 // Ack 1. | |
| 366 QuicAckFrame ack_frame = InitAckFrame(1); | |
| 367 ExpectAck(1); | |
| 368 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 369 | |
| 370 // There should no longer be a pending retransmission. | |
| 371 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 372 | |
| 373 // No unacked packets remain. | |
| 374 VerifyUnackedPackets(nullptr, 0); | |
| 375 VerifyRetransmittablePackets(nullptr, 0); | |
| 376 EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted); | |
| 377 } | |
| 378 | |
| 379 TEST_P(QuicSentPacketManagerTest, RetransmitThenStopRetransmittingBeforeSend) { | |
| 380 SendDataPacket(1); | |
| 381 QuicSentPacketManagerPeer::MarkForRetransmission(&manager_, kDefaultPathId, 1, | |
| 382 TLP_RETRANSMISSION); | |
| 383 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 384 | |
| 385 manager_.CancelRetransmissionsForStream(kStreamId); | |
| 386 | |
| 387 // There should no longer be a pending retransmission. | |
| 388 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 389 | |
| 390 QuicPacketNumber unacked[] = {1}; | |
| 391 VerifyUnackedPackets(unacked, arraysize(unacked)); | |
| 392 VerifyRetransmittablePackets(nullptr, 0); | |
| 393 EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted); | |
| 394 } | |
| 395 | |
| 396 TEST_P(QuicSentPacketManagerTest, RetransmitThenAckPrevious) { | |
| 397 SendDataPacket(1); | |
| 398 RetransmitAndSendPacket(1, 2); | |
| 399 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15); | |
| 400 clock_.AdvanceTime(rtt); | |
| 401 | |
| 402 // Ack 1 but not 2. | |
| 403 ExpectAck(1); | |
| 404 QuicAckFrame ack_frame = InitAckFrame(1); | |
| 405 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 406 | |
| 407 // 2 remains unacked, but no packets have retransmittable data. | |
| 408 QuicPacketNumber unacked[] = {2}; | |
| 409 VerifyUnackedPackets(unacked, arraysize(unacked)); | |
| 410 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | |
| 411 VerifyRetransmittablePackets(nullptr, 0); | |
| 412 | |
| 413 EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted); | |
| 414 } | |
| 415 | |
| 416 TEST_P(QuicSentPacketManagerTest, RetransmitThenAckPreviousThenNackRetransmit) { | |
| 417 SendDataPacket(1); | |
| 418 RetransmitAndSendPacket(1, 2); | |
| 419 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15); | |
| 420 clock_.AdvanceTime(rtt); | |
| 421 | |
| 422 // First, ACK packet 1 which makes packet 2 non-retransmittable. | |
| 423 ExpectAck(1); | |
| 424 QuicAckFrame ack_frame = InitAckFrame(1); | |
| 425 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 426 | |
| 427 SendDataPacket(3); | |
| 428 SendDataPacket(4); | |
| 429 SendDataPacket(5); | |
| 430 clock_.AdvanceTime(rtt); | |
| 431 | |
| 432 // Next, NACK packet 2 three times. | |
| 433 ack_frame = InitAckFrame(3); | |
| 434 NackPackets(2, 3, &ack_frame); | |
| 435 ExpectAck(3); | |
| 436 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 437 | |
| 438 ack_frame = InitAckFrame(4); | |
| 439 NackPackets(2, 3, &ack_frame); | |
| 440 ExpectAck(4); | |
| 441 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 442 | |
| 443 ack_frame = InitAckFrame(5); | |
| 444 NackPackets(2, 3, &ack_frame); | |
| 445 ExpectAckAndLoss(true, 5, 2); | |
| 446 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 447 | |
| 448 // No packets remain unacked. | |
| 449 VerifyUnackedPackets(nullptr, 0); | |
| 450 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | |
| 451 VerifyRetransmittablePackets(nullptr, 0); | |
| 452 | |
| 453 // Verify that the retransmission alarm would not fire, | |
| 454 // since there is no retransmittable data outstanding. | |
| 455 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime()); | |
| 456 } | |
| 457 | |
| 458 TEST_P(QuicSentPacketManagerTest, | |
| 459 DISABLED_RetransmitTwiceThenAckPreviousBeforeSend) { | |
| 460 SendDataPacket(1); | |
| 461 RetransmitAndSendPacket(1, 2); | |
| 462 | |
| 463 // Fire the RTO, which will mark 2 for retransmission (but will not send it). | |
| 464 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true)); | |
| 465 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 466 manager_.OnRetransmissionTimeout(); | |
| 467 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 468 | |
| 469 // Ack 1 but not 2, before 2 is able to be sent. | |
| 470 // Since 1 has been retransmitted, it has already been lost, and so the | |
| 471 // send algorithm is not informed that it has been ACK'd. | |
| 472 QuicAckFrame ack_frame = InitAckFrame(1); | |
| 473 ExpectUpdatedRtt(1); | |
| 474 EXPECT_CALL(*send_algorithm_, RevertRetransmissionTimeout()); | |
| 475 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 476 | |
| 477 // Since 2 was marked for retransmit, when 1 is acked, 2 is kept for RTT. | |
| 478 QuicPacketNumber unacked[] = {2}; | |
| 479 VerifyUnackedPackets(unacked, arraysize(unacked)); | |
| 480 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | |
| 481 VerifyRetransmittablePackets(nullptr, 0); | |
| 482 | |
| 483 // Verify that the retransmission alarm would not fire, | |
| 484 // since there is no retransmittable data outstanding. | |
| 485 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime()); | |
| 486 } | |
| 487 | |
| 488 TEST_P(QuicSentPacketManagerTest, RetransmitTwiceThenAckFirst) { | |
| 489 StrictMock<MockDebugDelegate> debug_delegate; | |
| 490 EXPECT_CALL(debug_delegate, OnSpuriousPacketRetransmission(TLP_RETRANSMISSION, | |
| 491 kDefaultLength)) | |
| 492 .Times(2); | |
| 493 manager_.SetDebugDelegate(&debug_delegate); | |
| 494 | |
| 495 SendDataPacket(1); | |
| 496 RetransmitAndSendPacket(1, 2); | |
| 497 RetransmitAndSendPacket(2, 3); | |
| 498 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15); | |
| 499 clock_.AdvanceTime(rtt); | |
| 500 | |
| 501 // Ack 1 but not 2 or 3. | |
| 502 ExpectAck(1); | |
| 503 QuicAckFrame ack_frame = InitAckFrame(1); | |
| 504 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 505 | |
| 506 // 2 and 3 remain unacked, but no packets have retransmittable data. | |
| 507 QuicPacketNumber unacked[] = {2, 3}; | |
| 508 VerifyUnackedPackets(unacked, arraysize(unacked)); | |
| 509 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | |
| 510 VerifyRetransmittablePackets(nullptr, 0); | |
| 511 | |
| 512 // Ensure packet 2 is lost when 4 is sent and 3 and 4 are acked. | |
| 513 SendDataPacket(4); | |
| 514 ack_frame = InitAckFrame(4); | |
| 515 NackPackets(2, 3, &ack_frame); | |
| 516 QuicPacketNumber acked[] = {3, 4}; | |
| 517 ExpectAcksAndLosses(true, acked, arraysize(acked), nullptr, 0); | |
| 518 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 519 | |
| 520 QuicPacketNumber unacked2[] = {2}; | |
| 521 VerifyUnackedPackets(unacked2, arraysize(unacked2)); | |
| 522 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | |
| 523 | |
| 524 SendDataPacket(5); | |
| 525 ack_frame = InitAckFrame(5); | |
| 526 NackPackets(2, 3, &ack_frame); | |
| 527 ExpectAckAndLoss(true, 5, 2); | |
| 528 EXPECT_CALL(debug_delegate, OnPacketLoss(2, LOSS_RETRANSMISSION, _)); | |
| 529 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 530 | |
| 531 VerifyUnackedPackets(nullptr, 0); | |
| 532 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | |
| 533 EXPECT_EQ(2u, stats_.packets_spuriously_retransmitted); | |
| 534 } | |
| 535 | |
| 536 TEST_P(QuicSentPacketManagerTest, AckOriginalTransmission) { | |
| 537 MockLossAlgorithm* loss_algorithm = new MockLossAlgorithm(); | |
| 538 QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm); | |
| 539 | |
| 540 SendDataPacket(1); | |
| 541 RetransmitAndSendPacket(1, 2); | |
| 542 | |
| 543 // Ack original transmission, but that wasn't lost via fast retransmit, | |
| 544 // so no call on OnSpuriousRetransmission is expected. | |
| 545 { | |
| 546 QuicAckFrame ack_frame = InitAckFrame(1); | |
| 547 ExpectAck(1); | |
| 548 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _)); | |
| 549 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 550 } | |
| 551 | |
| 552 SendDataPacket(3); | |
| 553 SendDataPacket(4); | |
| 554 // Ack 4, which causes 3 to be retransmitted. | |
| 555 { | |
| 556 QuicAckFrame ack_frame = InitAckFrame(4); | |
| 557 NackPackets(2, 4, &ack_frame); | |
| 558 ExpectAck(4); | |
| 559 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _)); | |
| 560 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 561 RetransmitAndSendPacket(3, 5, LOSS_RETRANSMISSION); | |
| 562 } | |
| 563 | |
| 564 // Ack 3, which causes SpuriousRetransmitDetected to be called. | |
| 565 { | |
| 566 QuicAckFrame ack_frame = InitAckFrame(4); | |
| 567 NackPackets(2, 3, &ack_frame); | |
| 568 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _)); | |
| 569 EXPECT_CALL(*loss_algorithm, SpuriousRetransmitDetected(_, _, _, 5)); | |
| 570 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 571 } | |
| 572 } | |
| 573 | |
| 574 TEST_P(QuicSentPacketManagerTest, AckPreviousTransmissionThenTruncatedAck) { | |
| 575 FLAGS_quic_loss_recovery_use_largest_acked = false; | |
| 576 if (!GetParam().missing) { | |
| 577 return; | |
| 578 } | |
| 579 SendDataPacket(1); | |
| 580 RetransmitAndSendPacket(1, 2); | |
| 581 RetransmitAndSendPacket(2, 3); | |
| 582 RetransmitAndSendPacket(3, 4); | |
| 583 SendDataPacket(5); | |
| 584 SendDataPacket(6); | |
| 585 SendDataPacket(7); | |
| 586 SendDataPacket(8); | |
| 587 SendDataPacket(9); | |
| 588 | |
| 589 // Ack previous transmission | |
| 590 { | |
| 591 QuicAckFrame ack_frame = InitAckFrame(2); | |
| 592 NackPackets(1, 2, &ack_frame); | |
| 593 ExpectAck(2); | |
| 594 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 595 EXPECT_TRUE(QuicSentPacketManagerPeer::IsUnacked(&manager_, 4)); | |
| 596 } | |
| 597 | |
| 598 // Truncated ack with 4 NACKs | |
| 599 { | |
| 600 QuicAckFrame ack_frame = InitAckFrame(6); | |
| 601 NackPackets(3, 7, &ack_frame); | |
| 602 ack_frame.is_truncated = true; | |
| 603 ExpectAckAndLoss(true, 1, 3); | |
| 604 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 605 } | |
| 606 | |
| 607 // High water mark will be raised. | |
| 608 QuicPacketNumber unacked[] = {4, 5, 6, 7, 8, 9}; | |
| 609 VerifyUnackedPackets(unacked, arraysize(unacked)); | |
| 610 QuicPacketNumber retransmittable[] = {5, 6, 7, 8, 9}; | |
| 611 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable)); | |
| 612 } | |
| 613 | |
| 614 TEST_P(QuicSentPacketManagerTest, GetLeastUnacked) { | |
| 615 EXPECT_EQ(1u, manager_.GetLeastUnacked(kDefaultPathId)); | |
| 616 } | |
| 617 | |
| 618 TEST_P(QuicSentPacketManagerTest, GetLeastUnackedUnacked) { | |
| 619 SendDataPacket(1); | |
| 620 EXPECT_EQ(1u, manager_.GetLeastUnacked(kDefaultPathId)); | |
| 621 } | |
| 622 | |
| 623 TEST_P(QuicSentPacketManagerTest, AckAckAndUpdateRtt) { | |
| 624 SendDataPacket(1); | |
| 625 SendAckPacket(2); | |
| 626 | |
| 627 // Now ack the ack and expect an RTT update. | |
| 628 QuicAckFrame ack_frame = InitAckFrame(2); | |
| 629 ack_frame.ack_delay_time = QuicTime::Delta::FromMilliseconds(5); | |
| 630 | |
| 631 ExpectAck(1); | |
| 632 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 633 | |
| 634 SendAckPacket(3); | |
| 635 | |
| 636 // Now ack the ack and expect only an RTT update. | |
| 637 ack_frame = InitAckFrame(3); | |
| 638 ExpectUpdatedRtt(3); | |
| 639 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 640 } | |
| 641 | |
| 642 TEST_P(QuicSentPacketManagerTest, Rtt) { | |
| 643 QuicPacketNumber packet_number = 1; | |
| 644 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(15); | |
| 645 SendDataPacket(packet_number); | |
| 646 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(20)); | |
| 647 | |
| 648 ExpectAck(packet_number); | |
| 649 QuicAckFrame ack_frame = InitAckFrame(packet_number); | |
| 650 ack_frame.ack_delay_time = QuicTime::Delta::FromMilliseconds(5); | |
| 651 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 652 EXPECT_EQ(expected_rtt, manager_.GetRttStats()->latest_rtt()); | |
| 653 } | |
| 654 | |
| 655 TEST_P(QuicSentPacketManagerTest, RttWithInvalidDelta) { | |
| 656 // Expect that the RTT is equal to the local time elapsed, since the | |
| 657 // ack_delay_time is larger than the local time elapsed | |
| 658 // and is hence invalid. | |
| 659 QuicPacketNumber packet_number = 1; | |
| 660 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10); | |
| 661 SendDataPacket(packet_number); | |
| 662 clock_.AdvanceTime(expected_rtt); | |
| 663 | |
| 664 ExpectAck(packet_number); | |
| 665 QuicAckFrame ack_frame = InitAckFrame(packet_number); | |
| 666 ack_frame.ack_delay_time = QuicTime::Delta::FromMilliseconds(11); | |
| 667 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 668 EXPECT_EQ(expected_rtt, manager_.GetRttStats()->latest_rtt()); | |
| 669 } | |
| 670 | |
| 671 TEST_P(QuicSentPacketManagerTest, RttWithInfiniteDelta) { | |
| 672 // Expect that the RTT is equal to the local time elapsed, since the | |
| 673 // ack_delay_time is infinite, and is hence invalid. | |
| 674 QuicPacketNumber packet_number = 1; | |
| 675 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10); | |
| 676 SendDataPacket(packet_number); | |
| 677 clock_.AdvanceTime(expected_rtt); | |
| 678 | |
| 679 ExpectAck(packet_number); | |
| 680 QuicAckFrame ack_frame = InitAckFrame(packet_number); | |
| 681 ack_frame.ack_delay_time = QuicTime::Delta::Infinite(); | |
| 682 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 683 EXPECT_EQ(expected_rtt, manager_.GetRttStats()->latest_rtt()); | |
| 684 } | |
| 685 | |
| 686 TEST_P(QuicSentPacketManagerTest, RttZeroDelta) { | |
| 687 // Expect that the RTT is the time between send and receive since the | |
| 688 // ack_delay_time is zero. | |
| 689 QuicPacketNumber packet_number = 1; | |
| 690 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10); | |
| 691 SendDataPacket(packet_number); | |
| 692 clock_.AdvanceTime(expected_rtt); | |
| 693 | |
| 694 ExpectAck(packet_number); | |
| 695 QuicAckFrame ack_frame = InitAckFrame(packet_number); | |
| 696 ack_frame.ack_delay_time = QuicTime::Delta::Zero(); | |
| 697 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 698 EXPECT_EQ(expected_rtt, manager_.GetRttStats()->latest_rtt()); | |
| 699 } | |
| 700 | |
| 701 TEST_P(QuicSentPacketManagerTest, TailLossProbeTimeout) { | |
| 702 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2); | |
| 703 | |
| 704 // Send 1 packet. | |
| 705 QuicPacketNumber packet_number = 1; | |
| 706 SendDataPacket(packet_number); | |
| 707 | |
| 708 QuicPathId path_id = kInvalidPathId; | |
| 709 // The first tail loss probe retransmits 1 packet. | |
| 710 manager_.OnRetransmissionTimeout(); | |
| 711 EXPECT_EQ( | |
| 712 QuicTime::Delta::Zero(), | |
| 713 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA, &path_id)); | |
| 714 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 715 manager_.MaybeRetransmitTailLossProbe(); | |
| 716 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 717 RetransmitNextPacket(2); | |
| 718 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 719 | |
| 720 // The second tail loss probe retransmits 1 packet. | |
| 721 manager_.OnRetransmissionTimeout(); | |
| 722 EXPECT_EQ( | |
| 723 QuicTime::Delta::Zero(), | |
| 724 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA, &path_id)); | |
| 725 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 726 manager_.MaybeRetransmitTailLossProbe(); | |
| 727 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 728 RetransmitNextPacket(3); | |
| 729 EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _)) | |
| 730 .WillOnce(Return(QuicTime::Delta::Infinite())); | |
| 731 EXPECT_EQ( | |
| 732 QuicTime::Delta::Infinite(), | |
| 733 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA, &path_id)); | |
| 734 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 735 | |
| 736 // Ack the third and ensure the first two are still pending. | |
| 737 ExpectAck(3); | |
| 738 | |
| 739 QuicAckFrame ack_frame = InitAckFrame(3); | |
| 740 NackPackets(1, 3, &ack_frame); | |
| 741 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 742 | |
| 743 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | |
| 744 | |
| 745 // Acking two more packets will lose both of them due to nacks. | |
| 746 SendDataPacket(4); | |
| 747 SendDataPacket(5); | |
| 748 ack_frame = InitAckFrame(5); | |
| 749 NackPackets(1, 3, &ack_frame); | |
| 750 QuicPacketNumber acked[] = {4, 5}; | |
| 751 QuicPacketNumber lost[] = {1, 2}; | |
| 752 ExpectAcksAndLosses(true, acked, arraysize(acked), lost, arraysize(lost)); | |
| 753 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 754 | |
| 755 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 756 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | |
| 757 EXPECT_EQ(2u, stats_.tlp_count); | |
| 758 EXPECT_EQ(0u, stats_.rto_count); | |
| 759 } | |
| 760 | |
| 761 TEST_P(QuicSentPacketManagerTest, TailLossProbeThenRTO) { | |
| 762 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2); | |
| 763 | |
| 764 // Send 100 packets. | |
| 765 const size_t kNumSentPackets = 100; | |
| 766 for (size_t i = 1; i <= kNumSentPackets; ++i) { | |
| 767 SendDataPacket(i); | |
| 768 } | |
| 769 QuicTime rto_packet_time = clock_.Now(); | |
| 770 // Advance the time. | |
| 771 clock_.AdvanceTime(manager_.GetRetransmissionTime() - clock_.Now()); | |
| 772 | |
| 773 // The first tail loss probe retransmits 1 packet. | |
| 774 manager_.OnRetransmissionTimeout(); | |
| 775 QuicPathId path_id = kInvalidPathId; | |
| 776 EXPECT_EQ( | |
| 777 QuicTime::Delta::Zero(), | |
| 778 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA, &path_id)); | |
| 779 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 780 manager_.MaybeRetransmitTailLossProbe(); | |
| 781 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 782 RetransmitNextPacket(101); | |
| 783 EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _)) | |
| 784 .WillOnce(Return(QuicTime::Delta::Infinite())); | |
| 785 EXPECT_EQ( | |
| 786 QuicTime::Delta::Infinite(), | |
| 787 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA, &path_id)); | |
| 788 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 789 clock_.AdvanceTime(manager_.GetRetransmissionTime() - clock_.Now()); | |
| 790 | |
| 791 // The second tail loss probe retransmits 1 packet. | |
| 792 manager_.OnRetransmissionTimeout(); | |
| 793 EXPECT_EQ( | |
| 794 QuicTime::Delta::Zero(), | |
| 795 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA, &path_id)); | |
| 796 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 797 EXPECT_TRUE(manager_.MaybeRetransmitTailLossProbe()); | |
| 798 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 799 RetransmitNextPacket(102); | |
| 800 EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _)) | |
| 801 .WillOnce(Return(QuicTime::Delta::Infinite())); | |
| 802 EXPECT_EQ( | |
| 803 QuicTime::Delta::Infinite(), | |
| 804 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA, &path_id)); | |
| 805 | |
| 806 // Ensure the RTO is set based on the correct packet. | |
| 807 rto_packet_time = clock_.Now(); | |
| 808 EXPECT_CALL(*send_algorithm_, RetransmissionDelay()) | |
| 809 .WillOnce(Return(QuicTime::Delta::FromSeconds(1))); | |
| 810 EXPECT_EQ(rto_packet_time + QuicTime::Delta::FromSeconds(1), | |
| 811 manager_.GetRetransmissionTime()); | |
| 812 | |
| 813 // Advance the time enough to ensure all packets are RTO'd. | |
| 814 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000)); | |
| 815 | |
| 816 manager_.OnRetransmissionTimeout(); | |
| 817 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 818 EXPECT_EQ(2u, stats_.tlp_count); | |
| 819 EXPECT_EQ(1u, stats_.rto_count); | |
| 820 | |
| 821 // Send and Ack the RTO and ensure OnRetransmissionTimeout is called. | |
| 822 EXPECT_EQ(102 * kDefaultLength, | |
| 823 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); | |
| 824 | |
| 825 RetransmitNextPacket(103); | |
| 826 QuicAckFrame ack_frame = InitAckFrame(103); | |
| 827 NackPackets(0, 103, &ack_frame); | |
| 828 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true)); | |
| 829 EXPECT_CALL(*send_algorithm_, | |
| 830 OnCongestionEvent(true, _, ElementsAre(Pair(103, _)), _)); | |
| 831 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 832 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 833 // All packets before 103 should be lost. | |
| 834 EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); | |
| 835 } | |
| 836 | |
| 837 TEST_P(QuicSentPacketManagerTest, CryptoHandshakeTimeout) { | |
| 838 // Send 2 crypto packets and 3 data packets. | |
| 839 const size_t kNumSentCryptoPackets = 2; | |
| 840 for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) { | |
| 841 SendCryptoPacket(i); | |
| 842 } | |
| 843 const size_t kNumSentDataPackets = 3; | |
| 844 for (size_t i = 1; i <= kNumSentDataPackets; ++i) { | |
| 845 SendDataPacket(kNumSentCryptoPackets + i); | |
| 846 } | |
| 847 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 848 | |
| 849 // The first retransmits 2 packets. | |
| 850 QuicPathId path_id = kInvalidPathId; | |
| 851 manager_.OnRetransmissionTimeout(); | |
| 852 EXPECT_EQ( | |
| 853 QuicTime::Delta::Zero(), | |
| 854 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA, &path_id)); | |
| 855 RetransmitNextPacket(6); | |
| 856 RetransmitNextPacket(7); | |
| 857 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 858 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 859 | |
| 860 // The second retransmits 2 packets. | |
| 861 manager_.OnRetransmissionTimeout(); | |
| 862 EXPECT_EQ( | |
| 863 QuicTime::Delta::Zero(), | |
| 864 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA, &path_id)); | |
| 865 RetransmitNextPacket(8); | |
| 866 RetransmitNextPacket(9); | |
| 867 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 868 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 869 | |
| 870 // Now ack the two crypto packets and the speculatively encrypted request, | |
| 871 // and ensure the first four crypto packets get abandoned, but not lost. | |
| 872 QuicPacketNumber acked[] = {3, 4, 5, 8, 9}; | |
| 873 ExpectAcksAndLosses(true, acked, arraysize(acked), nullptr, 0); | |
| 874 QuicAckFrame ack_frame = InitAckFrame(9); | |
| 875 NackPackets(1, 3, &ack_frame); | |
| 876 NackPackets(6, 8, &ack_frame); | |
| 877 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 878 | |
| 879 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 880 } | |
| 881 | |
| 882 TEST_P(QuicSentPacketManagerTest, CryptoHandshakeTimeoutVersionNegotiation) { | |
| 883 // Send 2 crypto packets and 3 data packets. | |
| 884 const size_t kNumSentCryptoPackets = 2; | |
| 885 for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) { | |
| 886 SendCryptoPacket(i); | |
| 887 } | |
| 888 const size_t kNumSentDataPackets = 3; | |
| 889 for (size_t i = 1; i <= kNumSentDataPackets; ++i) { | |
| 890 SendDataPacket(kNumSentCryptoPackets + i); | |
| 891 } | |
| 892 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 893 | |
| 894 // The first retransmission timeout retransmits 2 crypto packets. | |
| 895 manager_.OnRetransmissionTimeout(); | |
| 896 RetransmitNextPacket(6); | |
| 897 RetransmitNextPacket(7); | |
| 898 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 899 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 900 | |
| 901 // Now act like a version negotiation packet arrived, which would cause all | |
| 902 // unacked packets to be retransmitted. | |
| 903 manager_.RetransmitUnackedPackets(ALL_UNACKED_RETRANSMISSION); | |
| 904 | |
| 905 // Ensure the first two pending packets are the crypto retransmits. | |
| 906 ASSERT_TRUE(manager_.HasPendingRetransmissions()); | |
| 907 EXPECT_EQ(6u, manager_.NextPendingRetransmission().packet_number); | |
| 908 RetransmitNextPacket(8); | |
| 909 EXPECT_EQ(7u, manager_.NextPendingRetransmission().packet_number); | |
| 910 RetransmitNextPacket(9); | |
| 911 | |
| 912 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 913 // Send 3 more data packets and ensure the least unacked is raised. | |
| 914 RetransmitNextPacket(10); | |
| 915 RetransmitNextPacket(11); | |
| 916 RetransmitNextPacket(12); | |
| 917 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 918 | |
| 919 EXPECT_EQ(1u, manager_.GetLeastUnacked(kDefaultPathId)); | |
| 920 // Least unacked isn't raised until an ack is received, so ack the | |
| 921 // crypto packets. | |
| 922 QuicPacketNumber acked[] = {8, 9}; | |
| 923 ExpectAcksAndLosses(true, acked, arraysize(acked), nullptr, 0); | |
| 924 QuicAckFrame ack_frame = InitAckFrame(9); | |
| 925 for (QuicPacketNumber i = 1; i < 8; ++i) { | |
| 926 NackPackets(i, i + 1, &ack_frame); | |
| 927 } | |
| 928 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 929 EXPECT_EQ(10u, manager_.GetLeastUnacked(kDefaultPathId)); | |
| 930 } | |
| 931 | |
| 932 TEST_P(QuicSentPacketManagerTest, CryptoHandshakeSpuriousRetransmission) { | |
| 933 // Send 1 crypto packet. | |
| 934 SendCryptoPacket(1); | |
| 935 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 936 | |
| 937 // Retransmit the crypto packet as 2. | |
| 938 manager_.OnRetransmissionTimeout(); | |
| 939 RetransmitNextPacket(2); | |
| 940 | |
| 941 // Retransmit the crypto packet as 3. | |
| 942 manager_.OnRetransmissionTimeout(); | |
| 943 RetransmitNextPacket(3); | |
| 944 | |
| 945 // Now ack the second crypto packet, and ensure the first gets removed, but | |
| 946 // the third does not. | |
| 947 ExpectUpdatedRtt(2); | |
| 948 QuicAckFrame ack_frame = InitAckFrame(2); | |
| 949 NackPackets(1, 2, &ack_frame); | |
| 950 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 951 | |
| 952 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 953 QuicPacketNumber unacked[] = {3}; | |
| 954 VerifyUnackedPackets(unacked, arraysize(unacked)); | |
| 955 } | |
| 956 | |
| 957 TEST_P(QuicSentPacketManagerTest, CryptoHandshakeTimeoutUnsentDataPacket) { | |
| 958 // Send 2 crypto packets and 1 data packet. | |
| 959 const size_t kNumSentCryptoPackets = 2; | |
| 960 for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) { | |
| 961 SendCryptoPacket(i); | |
| 962 } | |
| 963 SendDataPacket(3); | |
| 964 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 965 | |
| 966 // Retransmit 2 crypto packets, but not the serialized packet. | |
| 967 manager_.OnRetransmissionTimeout(); | |
| 968 RetransmitNextPacket(4); | |
| 969 RetransmitNextPacket(5); | |
| 970 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 971 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 972 } | |
| 973 | |
| 974 TEST_P(QuicSentPacketManagerTest, | |
| 975 CryptoHandshakeRetransmissionThenRetransmitAll) { | |
| 976 // Send 1 crypto packet. | |
| 977 SendCryptoPacket(1); | |
| 978 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 979 | |
| 980 // Retransmit the crypto packet as 2. | |
| 981 manager_.OnRetransmissionTimeout(); | |
| 982 RetransmitNextPacket(2); | |
| 983 | |
| 984 // Now retransmit all the unacked packets, which occurs when there is a | |
| 985 // version negotiation. | |
| 986 manager_.RetransmitUnackedPackets(ALL_UNACKED_RETRANSMISSION); | |
| 987 QuicPacketNumber unacked[] = {1, 2}; | |
| 988 VerifyUnackedPackets(unacked, arraysize(unacked)); | |
| 989 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 990 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 991 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | |
| 992 } | |
| 993 | |
| 994 TEST_P(QuicSentPacketManagerTest, | |
| 995 CryptoHandshakeRetransmissionThenNeuterAndAck) { | |
| 996 // Send 1 crypto packet. | |
| 997 SendCryptoPacket(1); | |
| 998 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 999 | |
| 1000 // Retransmit the crypto packet as 2. | |
| 1001 manager_.OnRetransmissionTimeout(); | |
| 1002 RetransmitNextPacket(2); | |
| 1003 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 1004 | |
| 1005 // Retransmit the crypto packet as 3. | |
| 1006 manager_.OnRetransmissionTimeout(); | |
| 1007 RetransmitNextPacket(3); | |
| 1008 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 1009 | |
| 1010 // Now neuter all unacked unencrypted packets, which occurs when the | |
| 1011 // connection goes forward secure. | |
| 1012 manager_.NeuterUnencryptedPackets(); | |
| 1013 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 1014 QuicPacketNumber unacked[] = {1, 2, 3}; | |
| 1015 VerifyUnackedPackets(unacked, arraysize(unacked)); | |
| 1016 VerifyRetransmittablePackets(nullptr, 0); | |
| 1017 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 1018 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | |
| 1019 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | |
| 1020 | |
| 1021 // Ensure both packets get discarded when packet 2 is acked. | |
| 1022 QuicAckFrame ack_frame = InitAckFrame(3); | |
| 1023 NackPackets(1, 3, &ack_frame); | |
| 1024 ExpectUpdatedRtt(3); | |
| 1025 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 1026 VerifyUnackedPackets(nullptr, 0); | |
| 1027 VerifyRetransmittablePackets(nullptr, 0); | |
| 1028 } | |
| 1029 | |
| 1030 TEST_P(QuicSentPacketManagerTest, RetransmissionTimeout) { | |
| 1031 StrictMock<MockDebugDelegate> debug_delegate; | |
| 1032 manager_.SetDebugDelegate(&debug_delegate); | |
| 1033 | |
| 1034 // Send 100 packets. | |
| 1035 const size_t kNumSentPackets = 100; | |
| 1036 for (size_t i = 1; i <= kNumSentPackets; ++i) { | |
| 1037 SendDataPacket(i); | |
| 1038 } | |
| 1039 | |
| 1040 EXPECT_FALSE(manager_.MaybeRetransmitTailLossProbe()); | |
| 1041 manager_.OnRetransmissionTimeout(); | |
| 1042 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 1043 EXPECT_EQ(100 * kDefaultLength, | |
| 1044 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); | |
| 1045 RetransmitNextPacket(101); | |
| 1046 RetransmitNextPacket(102); | |
| 1047 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 1048 | |
| 1049 // Ack a retransmission. | |
| 1050 QuicAckFrame ack_frame = InitAckFrame(102); | |
| 1051 NackPackets(0, 102, &ack_frame); | |
| 1052 ack_frame.ack_delay_time = QuicTime::Delta::Zero(); | |
| 1053 // Ensure no packets are lost. | |
| 1054 EXPECT_CALL(*send_algorithm_, | |
| 1055 OnCongestionEvent(true, _, ElementsAre(Pair(102, _)), | |
| 1056 /*lost_packets=*/IsEmpty())); | |
| 1057 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1058 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true)); | |
| 1059 // RTO's use loss detection instead of immediately declaring retransmitted | |
| 1060 // packets lost. | |
| 1061 for (int i = 1; i <= 99; ++i) { | |
| 1062 EXPECT_CALL(debug_delegate, OnPacketLoss(i, LOSS_RETRANSMISSION, _)); | |
| 1063 } | |
| 1064 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 1065 } | |
| 1066 | |
| 1067 TEST_P(QuicSentPacketManagerTest, NewRetransmissionTimeout) { | |
| 1068 QuicConfig client_config; | |
| 1069 QuicTagVector options; | |
| 1070 options.push_back(kNRTO); | |
| 1071 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT); | |
| 1072 client_config.SetConnectionOptionsToSend(options); | |
| 1073 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1074 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); | |
| 1075 EXPECT_CALL(*send_algorithm_, PacingRate(_)) | |
| 1076 .WillRepeatedly(Return(QuicBandwidth::Zero())); | |
| 1077 EXPECT_CALL(*send_algorithm_, GetCongestionWindow()) | |
| 1078 .WillOnce(Return(10 * kDefaultTCPMSS)); | |
| 1079 manager_.SetFromConfig(client_config); | |
| 1080 EXPECT_TRUE(QuicSentPacketManagerPeer::GetUseNewRto(&manager_)); | |
| 1081 | |
| 1082 // Send 100 packets. | |
| 1083 const size_t kNumSentPackets = 100; | |
| 1084 for (size_t i = 1; i <= kNumSentPackets; ++i) { | |
| 1085 SendDataPacket(i); | |
| 1086 } | |
| 1087 | |
| 1088 EXPECT_FALSE(manager_.MaybeRetransmitTailLossProbe()); | |
| 1089 manager_.OnRetransmissionTimeout(); | |
| 1090 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 1091 EXPECT_EQ(100 * kDefaultLength, | |
| 1092 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); | |
| 1093 RetransmitNextPacket(101); | |
| 1094 RetransmitNextPacket(102); | |
| 1095 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 1096 | |
| 1097 // Ack a retransmission and expect no call to OnRetransmissionTimeout. | |
| 1098 QuicAckFrame ack_frame = InitAckFrame(102); | |
| 1099 NackPackets(0, 102, &ack_frame); | |
| 1100 ack_frame.ack_delay_time = QuicTime::Delta::Zero(); | |
| 1101 // This will include packets in the lost packet map. | |
| 1102 EXPECT_CALL(*send_algorithm_, | |
| 1103 OnCongestionEvent(true, _, ElementsAre(Pair(102, _)), | |
| 1104 /*lost_packets=*/Not(IsEmpty()))); | |
| 1105 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1106 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 1107 } | |
| 1108 | |
| 1109 TEST_P(QuicSentPacketManagerTest, TwoRetransmissionTimeoutsAckSecond) { | |
| 1110 // Send 1 packet. | |
| 1111 SendDataPacket(1); | |
| 1112 | |
| 1113 manager_.OnRetransmissionTimeout(); | |
| 1114 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 1115 EXPECT_EQ(kDefaultLength, | |
| 1116 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); | |
| 1117 RetransmitNextPacket(2); | |
| 1118 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 1119 | |
| 1120 // Rto a second time. | |
| 1121 EXPECT_CALL(*network_change_visitor_, OnPathDegrading()); | |
| 1122 manager_.OnRetransmissionTimeout(); | |
| 1123 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 1124 EXPECT_EQ(2 * kDefaultLength, | |
| 1125 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); | |
| 1126 RetransmitNextPacket(3); | |
| 1127 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 1128 | |
| 1129 // Ack a retransmission and ensure OnRetransmissionTimeout is called. | |
| 1130 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true)); | |
| 1131 QuicAckFrame ack_frame = InitAckFrame(2); | |
| 1132 NackPackets(1, 2, &ack_frame); | |
| 1133 ack_frame.ack_delay_time = QuicTime::Delta::Zero(); | |
| 1134 ExpectAck(2); | |
| 1135 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 1136 | |
| 1137 // The original packet and newest should be outstanding. | |
| 1138 EXPECT_EQ(2 * kDefaultLength, | |
| 1139 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); | |
| 1140 } | |
| 1141 | |
| 1142 TEST_P(QuicSentPacketManagerTest, TwoRetransmissionTimeoutsAckFirst) { | |
| 1143 // Send 1 packet. | |
| 1144 SendDataPacket(1); | |
| 1145 | |
| 1146 manager_.OnRetransmissionTimeout(); | |
| 1147 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 1148 EXPECT_EQ(kDefaultLength, | |
| 1149 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); | |
| 1150 RetransmitNextPacket(2); | |
| 1151 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 1152 | |
| 1153 // Rto a second time. | |
| 1154 EXPECT_CALL(*network_change_visitor_, OnPathDegrading()); | |
| 1155 manager_.OnRetransmissionTimeout(); | |
| 1156 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 1157 EXPECT_EQ(2 * kDefaultLength, | |
| 1158 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); | |
| 1159 RetransmitNextPacket(3); | |
| 1160 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 1161 | |
| 1162 // Ack a retransmission and ensure OnRetransmissionTimeout is called. | |
| 1163 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true)); | |
| 1164 QuicAckFrame ack_frame = InitAckFrame(3); | |
| 1165 NackPackets(1, 3, &ack_frame); | |
| 1166 ack_frame.ack_delay_time = QuicTime::Delta::Zero(); | |
| 1167 ExpectAck(3); | |
| 1168 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 1169 | |
| 1170 // The first two packets should still be outstanding. | |
| 1171 EXPECT_EQ(2 * kDefaultLength, | |
| 1172 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); | |
| 1173 } | |
| 1174 | |
| 1175 TEST_P(QuicSentPacketManagerTest, OnPathDegrading) { | |
| 1176 SendDataPacket(1); | |
| 1177 QuicTime::Delta delay = QuicTime::Delta::FromMilliseconds(500); | |
| 1178 EXPECT_CALL(*send_algorithm_, RetransmissionDelay()) | |
| 1179 .WillRepeatedly(Return(delay)); | |
| 1180 for (size_t i = 1; i < kMinTimeoutsBeforePathDegrading; ++i) { | |
| 1181 manager_.OnRetransmissionTimeout(); | |
| 1182 RetransmitNextPacket(i + 2); | |
| 1183 } | |
| 1184 // Next RTO should cause network_change_visitor_'s OnPathDegrading method | |
| 1185 // to be called. | |
| 1186 EXPECT_CALL(*network_change_visitor_, OnPathDegrading()); | |
| 1187 manager_.OnRetransmissionTimeout(); | |
| 1188 } | |
| 1189 | |
| 1190 TEST_P(QuicSentPacketManagerTest, GetTransmissionTime) { | |
| 1191 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime()); | |
| 1192 } | |
| 1193 | |
| 1194 TEST_P(QuicSentPacketManagerTest, GetTransmissionTimeCryptoHandshake) { | |
| 1195 SendCryptoPacket(1); | |
| 1196 | |
| 1197 // Check the min. | |
| 1198 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats()); | |
| 1199 rtt_stats->set_initial_rtt_us(1 * kNumMicrosPerMilli); | |
| 1200 EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromMilliseconds(10), | |
| 1201 manager_.GetRetransmissionTime()); | |
| 1202 | |
| 1203 // Test with a standard smoothed RTT. | |
| 1204 rtt_stats->set_initial_rtt_us(100 * kNumMicrosPerMilli); | |
| 1205 | |
| 1206 QuicTime::Delta srtt = | |
| 1207 QuicTime::Delta::FromMicroseconds(rtt_stats->initial_rtt_us()); | |
| 1208 QuicTime expected_time = clock_.Now() + 1.5 * srtt; | |
| 1209 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime()); | |
| 1210 | |
| 1211 // Retransmit the packet by invoking the retransmission timeout. | |
| 1212 clock_.AdvanceTime(1.5 * srtt); | |
| 1213 manager_.OnRetransmissionTimeout(); | |
| 1214 RetransmitNextPacket(2); | |
| 1215 | |
| 1216 // The retransmission time should now be twice as far in the future. | |
| 1217 expected_time = clock_.Now() + srtt * 2 * 1.5; | |
| 1218 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime()); | |
| 1219 } | |
| 1220 | |
| 1221 TEST_P(QuicSentPacketManagerTest, GetTransmissionTimeTailLossProbe) { | |
| 1222 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2); | |
| 1223 SendDataPacket(1); | |
| 1224 SendDataPacket(2); | |
| 1225 | |
| 1226 // Check the min. | |
| 1227 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats()); | |
| 1228 rtt_stats->set_initial_rtt_us(1 * kNumMicrosPerMilli); | |
| 1229 EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromMilliseconds(10), | |
| 1230 manager_.GetRetransmissionTime()); | |
| 1231 | |
| 1232 // Test with a standard smoothed RTT. | |
| 1233 rtt_stats->set_initial_rtt_us(100 * kNumMicrosPerMilli); | |
| 1234 QuicTime::Delta srtt = | |
| 1235 QuicTime::Delta::FromMicroseconds(rtt_stats->initial_rtt_us()); | |
| 1236 QuicTime::Delta expected_tlp_delay = 2 * srtt; | |
| 1237 QuicTime expected_time = clock_.Now() + expected_tlp_delay; | |
| 1238 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime()); | |
| 1239 | |
| 1240 // Retransmit the packet by invoking the retransmission timeout. | |
| 1241 clock_.AdvanceTime(expected_tlp_delay); | |
| 1242 manager_.OnRetransmissionTimeout(); | |
| 1243 QuicPathId path_id = kInvalidPathId; | |
| 1244 EXPECT_EQ( | |
| 1245 QuicTime::Delta::Zero(), | |
| 1246 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA, &path_id)); | |
| 1247 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 1248 EXPECT_TRUE(manager_.MaybeRetransmitTailLossProbe()); | |
| 1249 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 1250 RetransmitNextPacket(3); | |
| 1251 EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _)) | |
| 1252 .WillOnce(Return(QuicTime::Delta::Infinite())); | |
| 1253 EXPECT_EQ( | |
| 1254 QuicTime::Delta::Infinite(), | |
| 1255 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA, &path_id)); | |
| 1256 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 1257 | |
| 1258 expected_time = clock_.Now() + expected_tlp_delay; | |
| 1259 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime()); | |
| 1260 } | |
| 1261 | |
| 1262 TEST_P(QuicSentPacketManagerTest, GetTransmissionTimeSpuriousRTO) { | |
| 1263 const_cast<RttStats*>(manager_.GetRttStats()) | |
| 1264 ->UpdateRtt(QuicTime::Delta::FromMilliseconds(100), | |
| 1265 QuicTime::Delta::Zero(), QuicTime::Zero()); | |
| 1266 SendDataPacket(1); | |
| 1267 SendDataPacket(2); | |
| 1268 SendDataPacket(3); | |
| 1269 SendDataPacket(4); | |
| 1270 | |
| 1271 QuicTime::Delta expected_rto_delay = QuicTime::Delta::FromMilliseconds(500); | |
| 1272 EXPECT_CALL(*send_algorithm_, RetransmissionDelay()) | |
| 1273 .WillRepeatedly(Return(expected_rto_delay)); | |
| 1274 QuicTime expected_time = clock_.Now() + expected_rto_delay; | |
| 1275 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime()); | |
| 1276 | |
| 1277 // Retransmit the packet by invoking the retransmission timeout. | |
| 1278 clock_.AdvanceTime(expected_rto_delay); | |
| 1279 manager_.OnRetransmissionTimeout(); | |
| 1280 // All packets are still considered inflight. | |
| 1281 EXPECT_EQ(4 * kDefaultLength, | |
| 1282 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); | |
| 1283 RetransmitNextPacket(5); | |
| 1284 RetransmitNextPacket(6); | |
| 1285 // All previous packets are inflight, plus two rto retransmissions. | |
| 1286 EXPECT_EQ(6 * kDefaultLength, | |
| 1287 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); | |
| 1288 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 1289 | |
| 1290 // The delay should double the second time. | |
| 1291 expected_time = clock_.Now() + expected_rto_delay + expected_rto_delay; | |
| 1292 // Once we always base the timer on the right edge, leaving the older packets | |
| 1293 // in flight doesn't change the timeout. | |
| 1294 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime()); | |
| 1295 | |
| 1296 // Ack a packet before the first RTO and ensure the RTO timeout returns to the | |
| 1297 // original value and OnRetransmissionTimeout is not called or reverted. | |
| 1298 QuicAckFrame ack_frame = InitAckFrame(2); | |
| 1299 NackPackets(1, 2, &ack_frame); | |
| 1300 ExpectAck(2); | |
| 1301 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); | |
| 1302 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 1303 EXPECT_EQ(5 * kDefaultLength, | |
| 1304 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); | |
| 1305 | |
| 1306 // Wait 2RTTs from now for the RTO, since it's the max of the RTO time | |
| 1307 // and the TLP time. In production, there would always be two TLP's first. | |
| 1308 // Since retransmission was spurious, smoothed_rtt_ is expired, and replaced | |
| 1309 // by the latest RTT sample of 500ms. | |
| 1310 expected_time = clock_.Now() + QuicTime::Delta::FromMilliseconds(1000); | |
| 1311 // Once we always base the timer on the right edge, leaving the older packets | |
| 1312 // in flight doesn't change the timeout. | |
| 1313 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime()); | |
| 1314 } | |
| 1315 | |
| 1316 TEST_P(QuicSentPacketManagerTest, GetTransmissionDelayMin) { | |
| 1317 SendDataPacket(1); | |
| 1318 EXPECT_CALL(*send_algorithm_, RetransmissionDelay()) | |
| 1319 .WillRepeatedly(Return(QuicTime::Delta::FromMilliseconds(1))); | |
| 1320 QuicTime::Delta delay = QuicTime::Delta::FromMilliseconds(200); | |
| 1321 | |
| 1322 // If the delay is smaller than the min, ensure it exponentially backs off | |
| 1323 // from the min. | |
| 1324 EXPECT_CALL(*network_change_visitor_, OnPathDegrading()); | |
| 1325 for (int i = 0; i < 5; ++i) { | |
| 1326 EXPECT_EQ(delay, | |
| 1327 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_)); | |
| 1328 delay = delay + delay; | |
| 1329 manager_.OnRetransmissionTimeout(); | |
| 1330 RetransmitNextPacket(i + 2); | |
| 1331 } | |
| 1332 } | |
| 1333 | |
| 1334 TEST_P(QuicSentPacketManagerTest, GetTransmissionDelayMax) { | |
| 1335 EXPECT_CALL(*send_algorithm_, RetransmissionDelay()) | |
| 1336 .WillOnce(Return(QuicTime::Delta::FromSeconds(500))); | |
| 1337 | |
| 1338 EXPECT_EQ(QuicTime::Delta::FromSeconds(60), | |
| 1339 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_)); | |
| 1340 } | |
| 1341 | |
| 1342 TEST_P(QuicSentPacketManagerTest, GetTransmissionDelay) { | |
| 1343 SendDataPacket(1); | |
| 1344 QuicTime::Delta delay = QuicTime::Delta::FromMilliseconds(500); | |
| 1345 EXPECT_CALL(*send_algorithm_, RetransmissionDelay()) | |
| 1346 .WillRepeatedly(Return(delay)); | |
| 1347 | |
| 1348 // Delay should back off exponentially. | |
| 1349 EXPECT_CALL(*network_change_visitor_, OnPathDegrading()); | |
| 1350 for (int i = 0; i < 5; ++i) { | |
| 1351 EXPECT_EQ(delay, | |
| 1352 QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_)); | |
| 1353 delay = delay + delay; | |
| 1354 manager_.OnRetransmissionTimeout(); | |
| 1355 RetransmitNextPacket(i + 2); | |
| 1356 } | |
| 1357 } | |
| 1358 | |
| 1359 TEST_P(QuicSentPacketManagerTest, GetLossDelay) { | |
| 1360 MockLossAlgorithm* loss_algorithm = new MockLossAlgorithm(); | |
| 1361 QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm); | |
| 1362 | |
| 1363 EXPECT_CALL(*loss_algorithm, GetLossTimeout()) | |
| 1364 .WillRepeatedly(Return(QuicTime::Zero())); | |
| 1365 SendDataPacket(1); | |
| 1366 SendDataPacket(2); | |
| 1367 | |
| 1368 // Handle an ack which causes the loss algorithm to be evaluated and | |
| 1369 // set the loss timeout. | |
| 1370 ExpectAck(2); | |
| 1371 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _)); | |
| 1372 QuicAckFrame ack_frame = InitAckFrame(2); | |
| 1373 NackPackets(1, 2, &ack_frame); | |
| 1374 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 1375 | |
| 1376 QuicTime timeout(clock_.Now() + QuicTime::Delta::FromMilliseconds(10)); | |
| 1377 EXPECT_CALL(*loss_algorithm, GetLossTimeout()) | |
| 1378 .WillRepeatedly(Return(timeout)); | |
| 1379 EXPECT_EQ(timeout, manager_.GetRetransmissionTime()); | |
| 1380 | |
| 1381 // Fire the retransmission timeout and ensure the loss detection algorithm | |
| 1382 // is invoked. | |
| 1383 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _)); | |
| 1384 manager_.OnRetransmissionTimeout(); | |
| 1385 } | |
| 1386 | |
| 1387 TEST_P(QuicSentPacketManagerTest, NegotiateTimeLossDetectionFromOptions) { | |
| 1388 EXPECT_EQ(kNack, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) | |
| 1389 ->GetLossDetectionType()); | |
| 1390 | |
| 1391 QuicConfig config; | |
| 1392 QuicTagVector options; | |
| 1393 options.push_back(kTIME); | |
| 1394 QuicConfigPeer::SetReceivedConnectionOptions(&config, options); | |
| 1395 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); | |
| 1396 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1397 manager_.SetFromConfig(config); | |
| 1398 | |
| 1399 EXPECT_EQ(kTime, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) | |
| 1400 ->GetLossDetectionType()); | |
| 1401 } | |
| 1402 | |
| 1403 TEST_P(QuicSentPacketManagerTest, NegotiateCongestionControlFromOptions) { | |
| 1404 FLAGS_quic_allow_bbr = true; | |
| 1405 QuicConfig config; | |
| 1406 QuicTagVector options; | |
| 1407 | |
| 1408 options.push_back(kRENO); | |
| 1409 QuicConfigPeer::SetReceivedConnectionOptions(&config, options); | |
| 1410 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1411 manager_.SetFromConfig(config); | |
| 1412 EXPECT_EQ(kReno, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_) | |
| 1413 ->GetCongestionControlType()); | |
| 1414 | |
| 1415 // TODO(rtenneti): Enable the following code after BBR code is checked in. | |
| 1416 #if 0 | |
| 1417 options.clear(); | |
| 1418 options.push_back(kTBBR); | |
| 1419 QuicConfigPeer::SetReceivedConnectionOptions(&config, options); | |
| 1420 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1421 manager_.SetFromConfig(config); | |
| 1422 EXPECT_EQ(kBBR, QuicSentPacketManagerPeer::GetSendAlgorithm( | |
| 1423 manager_)->GetCongestionControlType()); | |
| 1424 #endif | |
| 1425 | |
| 1426 options.clear(); | |
| 1427 options.push_back(kBYTE); | |
| 1428 QuicConfigPeer::SetReceivedConnectionOptions(&config, options); | |
| 1429 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1430 manager_.SetFromConfig(config); | |
| 1431 EXPECT_EQ(kCubicBytes, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_) | |
| 1432 ->GetCongestionControlType()); | |
| 1433 | |
| 1434 options.clear(); | |
| 1435 options.push_back(kRENO); | |
| 1436 options.push_back(kBYTE); | |
| 1437 QuicConfigPeer::SetReceivedConnectionOptions(&config, options); | |
| 1438 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1439 manager_.SetFromConfig(config); | |
| 1440 EXPECT_EQ(kRenoBytes, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_) | |
| 1441 ->GetCongestionControlType()); | |
| 1442 } | |
| 1443 | |
| 1444 TEST_P(QuicSentPacketManagerTest, NegotiateNumConnectionsFromOptions) { | |
| 1445 QuicConfig config; | |
| 1446 QuicTagVector options; | |
| 1447 | |
| 1448 options.push_back(k1CON); | |
| 1449 QuicConfigPeer::SetReceivedConnectionOptions(&config, options); | |
| 1450 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1451 EXPECT_CALL(*send_algorithm_, SetNumEmulatedConnections(1)); | |
| 1452 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); | |
| 1453 manager_.SetFromConfig(config); | |
| 1454 | |
| 1455 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT); | |
| 1456 QuicConfig client_config; | |
| 1457 client_config.SetConnectionOptionsToSend(options); | |
| 1458 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1459 EXPECT_CALL(*send_algorithm_, SetNumEmulatedConnections(1)); | |
| 1460 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); | |
| 1461 manager_.SetFromConfig(client_config); | |
| 1462 } | |
| 1463 | |
| 1464 TEST_P(QuicSentPacketManagerTest, NegotiateNConnectionFromOptions) { | |
| 1465 // By default, changing the number of open streams does nothing. | |
| 1466 manager_.SetNumOpenStreams(5); | |
| 1467 | |
| 1468 QuicConfig config; | |
| 1469 QuicTagVector options; | |
| 1470 | |
| 1471 options.push_back(kNCON); | |
| 1472 QuicConfigPeer::SetReceivedConnectionOptions(&config, options); | |
| 1473 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1474 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); | |
| 1475 manager_.SetFromConfig(config); | |
| 1476 | |
| 1477 EXPECT_CALL(*send_algorithm_, SetNumEmulatedConnections(5)); | |
| 1478 manager_.SetNumOpenStreams(5); | |
| 1479 } | |
| 1480 | |
| 1481 TEST_P(QuicSentPacketManagerTest, NegotiateNoTLPFromOptionsAtServer) { | |
| 1482 QuicConfig config; | |
| 1483 QuicTagVector options; | |
| 1484 | |
| 1485 options.push_back(kNTLP); | |
| 1486 QuicConfigPeer::SetReceivedConnectionOptions(&config, options); | |
| 1487 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1488 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); | |
| 1489 manager_.SetFromConfig(config); | |
| 1490 EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetMaxTailLossProbes(&manager_)); | |
| 1491 } | |
| 1492 | |
| 1493 TEST_P(QuicSentPacketManagerTest, NegotiateNoTLPFromOptionsAtClient) { | |
| 1494 QuicConfig client_config; | |
| 1495 QuicTagVector options; | |
| 1496 | |
| 1497 options.push_back(kNTLP); | |
| 1498 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT); | |
| 1499 client_config.SetConnectionOptionsToSend(options); | |
| 1500 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1501 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); | |
| 1502 manager_.SetFromConfig(client_config); | |
| 1503 EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetMaxTailLossProbes(&manager_)); | |
| 1504 } | |
| 1505 | |
| 1506 TEST_P(QuicSentPacketManagerTest, NegotiateTLPRttFromOptionsAtServer) { | |
| 1507 QuicConfig config; | |
| 1508 QuicTagVector options; | |
| 1509 | |
| 1510 options.push_back(kTLPR); | |
| 1511 QuicConfigPeer::SetReceivedConnectionOptions(&config, options); | |
| 1512 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1513 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); | |
| 1514 manager_.SetFromConfig(config); | |
| 1515 EXPECT_TRUE( | |
| 1516 QuicSentPacketManagerPeer::GetEnableHalfRttTailLossProbe(&manager_)); | |
| 1517 } | |
| 1518 | |
| 1519 TEST_P(QuicSentPacketManagerTest, NegotiateTLPRttFromOptionsAtClient) { | |
| 1520 QuicConfig client_config; | |
| 1521 QuicTagVector options; | |
| 1522 | |
| 1523 options.push_back(kTLPR); | |
| 1524 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT); | |
| 1525 client_config.SetConnectionOptionsToSend(options); | |
| 1526 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1527 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); | |
| 1528 manager_.SetFromConfig(client_config); | |
| 1529 EXPECT_TRUE( | |
| 1530 QuicSentPacketManagerPeer::GetEnableHalfRttTailLossProbe(&manager_)); | |
| 1531 } | |
| 1532 | |
| 1533 TEST_P(QuicSentPacketManagerTest, NegotiateNewRTOFromOptionsAtServer) { | |
| 1534 EXPECT_FALSE(QuicSentPacketManagerPeer::GetUseNewRto(&manager_)); | |
| 1535 QuicConfig config; | |
| 1536 QuicTagVector options; | |
| 1537 | |
| 1538 options.push_back(kNRTO); | |
| 1539 QuicConfigPeer::SetReceivedConnectionOptions(&config, options); | |
| 1540 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1541 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); | |
| 1542 manager_.SetFromConfig(config); | |
| 1543 EXPECT_TRUE(QuicSentPacketManagerPeer::GetUseNewRto(&manager_)); | |
| 1544 } | |
| 1545 | |
| 1546 TEST_P(QuicSentPacketManagerTest, NegotiateNewRTOFromOptionsAtClient) { | |
| 1547 EXPECT_FALSE(QuicSentPacketManagerPeer::GetUseNewRto(&manager_)); | |
| 1548 QuicConfig client_config; | |
| 1549 QuicTagVector options; | |
| 1550 | |
| 1551 options.push_back(kNRTO); | |
| 1552 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT); | |
| 1553 client_config.SetConnectionOptionsToSend(options); | |
| 1554 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1555 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); | |
| 1556 manager_.SetFromConfig(client_config); | |
| 1557 EXPECT_TRUE(QuicSentPacketManagerPeer::GetUseNewRto(&manager_)); | |
| 1558 } | |
| 1559 | |
| 1560 TEST_P(QuicSentPacketManagerTest, NegotiateUndoFromOptionsAtServer) { | |
| 1561 FLAGS_quic_loss_recovery_use_largest_acked = true; | |
| 1562 EXPECT_FALSE(QuicSentPacketManagerPeer::GetUndoRetransmits(&manager_)); | |
| 1563 QuicConfig config; | |
| 1564 QuicTagVector options; | |
| 1565 | |
| 1566 options.push_back(kUNDO); | |
| 1567 QuicConfigPeer::SetReceivedConnectionOptions(&config, options); | |
| 1568 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1569 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); | |
| 1570 manager_.SetFromConfig(config); | |
| 1571 EXPECT_TRUE(QuicSentPacketManagerPeer::GetUndoRetransmits(&manager_)); | |
| 1572 | |
| 1573 // Ensure undo works as intended. | |
| 1574 // Send 5 packets, mark the first 4 for retransmission, and then cancel | |
| 1575 // them when 1 is acked. | |
| 1576 EXPECT_CALL(*send_algorithm_, PacingRate(_)) | |
| 1577 .WillRepeatedly(Return(QuicBandwidth::Zero())); | |
| 1578 EXPECT_CALL(*send_algorithm_, GetCongestionWindow()) | |
| 1579 .WillOnce(Return(10 * kDefaultTCPMSS)); | |
| 1580 const size_t kNumSentPackets = 5; | |
| 1581 for (size_t i = 1; i <= kNumSentPackets; ++i) { | |
| 1582 SendDataPacket(i); | |
| 1583 } | |
| 1584 MockLossAlgorithm* loss_algorithm = new MockLossAlgorithm(); | |
| 1585 QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm); | |
| 1586 EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _)); | |
| 1587 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1588 SendAlgorithmInterface::CongestionVector lost_packets; | |
| 1589 for (size_t i = 1; i < kNumSentPackets; ++i) { | |
| 1590 lost_packets.push_back(std::make_pair(i, kMaxPacketSize)); | |
| 1591 } | |
| 1592 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _)) | |
| 1593 .WillOnce(SetArgPointee<4>(lost_packets)); | |
| 1594 QuicAckFrame ack_frame = InitAckFrame(kNumSentPackets); | |
| 1595 NackPackets(1, kNumSentPackets, &ack_frame); | |
| 1596 // Congestion block the sending right before losing the packets. | |
| 1597 EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _)) | |
| 1598 .WillRepeatedly(Return(QuicTime::Delta::Infinite())); | |
| 1599 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 1600 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | |
| 1601 EXPECT_EQ(0u, BytesInFlight()); | |
| 1602 | |
| 1603 // Ack 1 and ensure the retransmissions are cancelled and put back in flight. | |
| 1604 EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _)); | |
| 1605 ack_frame = InitAckFrame(5); | |
| 1606 NackPackets(2, kNumSentPackets, &ack_frame); | |
| 1607 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 1608 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | |
| 1609 EXPECT_EQ(3u * kDefaultLength, BytesInFlight()); | |
| 1610 } | |
| 1611 | |
| 1612 TEST_P(QuicSentPacketManagerTest, NegotiateUndoFromOptionsAtClient) { | |
| 1613 FLAGS_quic_loss_recovery_use_largest_acked = true; | |
| 1614 EXPECT_FALSE(QuicSentPacketManagerPeer::GetUndoRetransmits(&manager_)); | |
| 1615 QuicConfig client_config; | |
| 1616 QuicTagVector options; | |
| 1617 | |
| 1618 options.push_back(kUNDO); | |
| 1619 QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT); | |
| 1620 client_config.SetConnectionOptionsToSend(options); | |
| 1621 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1622 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); | |
| 1623 manager_.SetFromConfig(client_config); | |
| 1624 EXPECT_TRUE(QuicSentPacketManagerPeer::GetUndoRetransmits(&manager_)); | |
| 1625 } | |
| 1626 | |
| 1627 TEST_P(QuicSentPacketManagerTest, UseInitialRoundTripTimeToSend) { | |
| 1628 uint32_t initial_rtt_us = 325000; | |
| 1629 EXPECT_NE(initial_rtt_us, | |
| 1630 manager_.GetRttStats()->smoothed_rtt().ToMicroseconds()); | |
| 1631 | |
| 1632 QuicConfig config; | |
| 1633 config.SetInitialRoundTripTimeUsToSend(initial_rtt_us); | |
| 1634 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); | |
| 1635 EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); | |
| 1636 manager_.SetFromConfig(config); | |
| 1637 | |
| 1638 EXPECT_EQ(0, manager_.GetRttStats()->smoothed_rtt().ToMicroseconds()); | |
| 1639 EXPECT_EQ(initial_rtt_us, manager_.GetRttStats()->initial_rtt_us()); | |
| 1640 } | |
| 1641 | |
| 1642 TEST_P(QuicSentPacketManagerTest, ResumeConnectionState) { | |
| 1643 // The sent packet manager should use the RTT from CachedNetworkParameters if | |
| 1644 // it is provided. | |
| 1645 const int kRttMs = 1234; | |
| 1646 CachedNetworkParameters cached_network_params; | |
| 1647 cached_network_params.set_min_rtt_ms(kRttMs); | |
| 1648 | |
| 1649 EXPECT_CALL(*send_algorithm_, ResumeConnectionState(_, false)); | |
| 1650 manager_.ResumeConnectionState(cached_network_params, false); | |
| 1651 EXPECT_EQ(kRttMs * kNumMicrosPerMilli, | |
| 1652 static_cast<uint64_t>(manager_.GetRttStats()->initial_rtt_us())); | |
| 1653 } | |
| 1654 | |
| 1655 TEST_P(QuicSentPacketManagerTest, ConnectionMigrationUnspecifiedChange) { | |
| 1656 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats()); | |
| 1657 int64_t default_init_rtt = rtt_stats->initial_rtt_us(); | |
| 1658 rtt_stats->set_initial_rtt_us(default_init_rtt * 2); | |
| 1659 EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt_us()); | |
| 1660 | |
| 1661 QuicSentPacketManagerPeer::SetConsecutiveRtoCount(&manager_, 1); | |
| 1662 EXPECT_EQ(1u, manager_.GetConsecutiveRtoCount()); | |
| 1663 QuicSentPacketManagerPeer::SetConsecutiveTlpCount(&manager_, 2); | |
| 1664 EXPECT_EQ(2u, manager_.GetConsecutiveTlpCount()); | |
| 1665 | |
| 1666 EXPECT_CALL(*send_algorithm_, OnConnectionMigration()); | |
| 1667 manager_.OnConnectionMigration(kDefaultPathId, UNSPECIFIED_CHANGE); | |
| 1668 | |
| 1669 EXPECT_EQ(default_init_rtt, rtt_stats->initial_rtt_us()); | |
| 1670 EXPECT_EQ(0u, manager_.GetConsecutiveRtoCount()); | |
| 1671 EXPECT_EQ(0u, manager_.GetConsecutiveTlpCount()); | |
| 1672 } | |
| 1673 | |
| 1674 TEST_P(QuicSentPacketManagerTest, ConnectionMigrationIPSubnetChange) { | |
| 1675 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats()); | |
| 1676 int64_t default_init_rtt = rtt_stats->initial_rtt_us(); | |
| 1677 rtt_stats->set_initial_rtt_us(default_init_rtt * 2); | |
| 1678 EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt_us()); | |
| 1679 | |
| 1680 QuicSentPacketManagerPeer::SetConsecutiveRtoCount(&manager_, 1); | |
| 1681 EXPECT_EQ(1u, manager_.GetConsecutiveRtoCount()); | |
| 1682 QuicSentPacketManagerPeer::SetConsecutiveTlpCount(&manager_, 2); | |
| 1683 EXPECT_EQ(2u, manager_.GetConsecutiveTlpCount()); | |
| 1684 | |
| 1685 manager_.OnConnectionMigration(kDefaultPathId, IPV4_SUBNET_CHANGE); | |
| 1686 | |
| 1687 EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt_us()); | |
| 1688 EXPECT_EQ(1u, manager_.GetConsecutiveRtoCount()); | |
| 1689 EXPECT_EQ(2u, manager_.GetConsecutiveTlpCount()); | |
| 1690 } | |
| 1691 | |
| 1692 TEST_P(QuicSentPacketManagerTest, ConnectionMigrationPortChange) { | |
| 1693 RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats()); | |
| 1694 int64_t default_init_rtt = rtt_stats->initial_rtt_us(); | |
| 1695 rtt_stats->set_initial_rtt_us(default_init_rtt * 2); | |
| 1696 EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt_us()); | |
| 1697 | |
| 1698 QuicSentPacketManagerPeer::SetConsecutiveRtoCount(&manager_, 1); | |
| 1699 EXPECT_EQ(1u, manager_.GetConsecutiveRtoCount()); | |
| 1700 QuicSentPacketManagerPeer::SetConsecutiveTlpCount(&manager_, 2); | |
| 1701 EXPECT_EQ(2u, manager_.GetConsecutiveTlpCount()); | |
| 1702 | |
| 1703 manager_.OnConnectionMigration(kDefaultPathId, PORT_CHANGE); | |
| 1704 | |
| 1705 EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt_us()); | |
| 1706 EXPECT_EQ(1u, manager_.GetConsecutiveRtoCount()); | |
| 1707 EXPECT_EQ(2u, manager_.GetConsecutiveTlpCount()); | |
| 1708 } | |
| 1709 | |
| 1710 TEST_P(QuicSentPacketManagerTest, PathMtuIncreased) { | |
| 1711 FLAGS_quic_no_mtu_discovery_ack_listener = true; | |
| 1712 EXPECT_CALL(*send_algorithm_, OnPacketSent(_, BytesInFlight(), 1, _, _)) | |
| 1713 .Times(1) | |
| 1714 .WillOnce(Return(true)); | |
| 1715 SerializedPacket packet(kDefaultPathId, 1, PACKET_6BYTE_PACKET_NUMBER, | |
| 1716 nullptr, kDefaultLength + 100, 0u, false, false); | |
| 1717 manager_.OnPacketSent(&packet, kInvalidPathId, 0, clock_.Now(), | |
| 1718 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA); | |
| 1719 | |
| 1720 // Ack the large packet and expect the path MTU to increase. | |
| 1721 ExpectAck(1); | |
| 1722 EXPECT_CALL(*network_change_visitor_, | |
| 1723 OnPathMtuIncreased(kDefaultLength + 100)); | |
| 1724 QuicAckFrame ack_frame = InitAckFrame(1); | |
| 1725 manager_.OnIncomingAck(ack_frame, clock_.Now()); | |
| 1726 } | |
| 1727 | |
| 1728 } // namespace | |
| 1729 } // namespace test | |
| 1730 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2193073003:
Move shared files in net/quic/ into net/quic/core/ (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master