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