OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/quic/quic_sent_packet_manager.h" | 5 #include "net/quic/quic_sent_packet_manager.h" |
6 | 6 |
7 #include "base/stl_util.h" | 7 #include "base/stl_util.h" |
8 #include "net/quic/quic_flags.h" | 8 #include "net/quic/quic_flags.h" |
9 #include "net/quic/test_tools/quic_config_peer.h" | 9 #include "net/quic/test_tools/quic_config_peer.h" |
10 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h" | 10 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h" |
(...skipping 26 matching lines...) Expand all Loading... |
37 class MockDebugDelegate : public QuicSentPacketManager::DebugDelegate { | 37 class MockDebugDelegate : public QuicSentPacketManager::DebugDelegate { |
38 public: | 38 public: |
39 MOCK_METHOD2(OnSpuriousPacketRetransmition, | 39 MOCK_METHOD2(OnSpuriousPacketRetransmition, |
40 void(TransmissionType transmission_type, | 40 void(TransmissionType transmission_type, |
41 QuicByteCount byte_size)); | 41 QuicByteCount byte_size)); |
42 }; | 42 }; |
43 | 43 |
44 class QuicSentPacketManagerTest : public ::testing::TestWithParam<bool> { | 44 class QuicSentPacketManagerTest : public ::testing::TestWithParam<bool> { |
45 protected: | 45 protected: |
46 QuicSentPacketManagerTest() | 46 QuicSentPacketManagerTest() |
47 : manager_(true, &clock_, &stats_, kFixRateCongestionControl, kNack), | 47 : manager_(true, &clock_, &stats_, kCubic, kNack), |
48 send_algorithm_(new StrictMock<MockSendAlgorithm>), | 48 send_algorithm_(new StrictMock<MockSendAlgorithm>), |
49 network_change_visitor_(new StrictMock<MockNetworkChangeVisitor>) { | 49 network_change_visitor_(new StrictMock<MockNetworkChangeVisitor>) { |
50 QuicSentPacketManagerPeer::SetSendAlgorithm(&manager_, send_algorithm_); | 50 QuicSentPacketManagerPeer::SetSendAlgorithm(&manager_, send_algorithm_); |
51 // Disable tail loss probes for most tests. | 51 // Disable tail loss probes for most tests. |
52 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 0); | 52 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 0); |
53 // Advance the time 1s so the send times are never QuicTime::Zero. | 53 // Advance the time 1s so the send times are never QuicTime::Zero. |
54 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000)); | 54 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000)); |
55 manager_.set_network_change_visitor(network_change_visitor_.get()); | 55 manager_.set_network_change_visitor(network_change_visitor_.get()); |
56 } | 56 } |
57 | 57 |
(...skipping 236 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
294 VerifyUnackedPackets(unacked, arraysize(unacked)); | 294 VerifyUnackedPackets(unacked, arraysize(unacked)); |
295 QuicPacketSequenceNumber retransmittable[] = { 2 }; | 295 QuicPacketSequenceNumber retransmittable[] = { 2 }; |
296 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable)); | 296 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable)); |
297 } | 297 } |
298 | 298 |
299 TEST_F(QuicSentPacketManagerTest, RetransmitThenAck) { | 299 TEST_F(QuicSentPacketManagerTest, RetransmitThenAck) { |
300 SendDataPacket(1); | 300 SendDataPacket(1); |
301 RetransmitAndSendPacket(1, 2); | 301 RetransmitAndSendPacket(1, 2); |
302 | 302 |
303 // Ack 2 but not 1. | 303 // Ack 2 but not 1. |
304 ReceivedPacketInfo received_info; | 304 QuicAckFrame ack_frame; |
305 received_info.largest_observed = 2; | 305 ack_frame.largest_observed = 2; |
306 received_info.missing_packets.insert(1); | 306 ack_frame.missing_packets.insert(1); |
307 ExpectAck(2); | 307 ExpectAck(2); |
308 manager_.OnIncomingAck(received_info, clock_.Now()); | 308 manager_.OnIncomingAck(ack_frame, clock_.Now()); |
309 | 309 |
310 // Packet 1 is unacked, pending, but not retransmittable. | 310 // Packet 1 is unacked, pending, but not retransmittable. |
311 QuicPacketSequenceNumber unacked[] = { 1 }; | 311 QuicPacketSequenceNumber unacked[] = { 1 }; |
312 VerifyUnackedPackets(unacked, arraysize(unacked)); | 312 VerifyUnackedPackets(unacked, arraysize(unacked)); |
313 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | 313 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); |
314 VerifyRetransmittablePackets(NULL, 0); | 314 VerifyRetransmittablePackets(NULL, 0); |
315 } | 315 } |
316 | 316 |
317 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckBeforeSend) { | 317 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckBeforeSend) { |
318 SendDataPacket(1); | 318 SendDataPacket(1); |
319 QuicSentPacketManagerPeer::MarkForRetransmission( | 319 QuicSentPacketManagerPeer::MarkForRetransmission( |
320 &manager_, 1, TLP_RETRANSMISSION); | 320 &manager_, 1, TLP_RETRANSMISSION); |
321 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | 321 EXPECT_TRUE(manager_.HasPendingRetransmissions()); |
322 | 322 |
323 // Ack 1. | 323 // Ack 1. |
324 ReceivedPacketInfo received_info; | 324 QuicAckFrame ack_frame; |
325 received_info.largest_observed = 1; | 325 ack_frame.largest_observed = 1; |
326 ExpectAck(1); | 326 ExpectAck(1); |
327 manager_.OnIncomingAck(received_info, clock_.Now()); | 327 manager_.OnIncomingAck(ack_frame, clock_.Now()); |
328 | 328 |
329 // There should no longer be a pending retransmission. | 329 // There should no longer be a pending retransmission. |
330 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | 330 EXPECT_FALSE(manager_.HasPendingRetransmissions()); |
331 | 331 |
332 // No unacked packets remain. | 332 // No unacked packets remain. |
333 VerifyUnackedPackets(NULL, 0); | 333 VerifyUnackedPackets(NULL, 0); |
334 VerifyRetransmittablePackets(NULL, 0); | 334 VerifyRetransmittablePackets(NULL, 0); |
335 EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted); | 335 EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted); |
336 } | 336 } |
337 | 337 |
338 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPrevious) { | 338 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPrevious) { |
339 SendDataPacket(1); | 339 SendDataPacket(1); |
340 RetransmitPacket(1, 2); | 340 RetransmitPacket(1, 2); |
341 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15); | 341 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15); |
342 clock_.AdvanceTime(rtt); | 342 clock_.AdvanceTime(rtt); |
343 | 343 |
344 // Ack 1 but not 2. | 344 // Ack 1 but not 2. |
345 ExpectAck(1); | 345 ExpectAck(1); |
346 ReceivedPacketInfo received_info; | 346 QuicAckFrame ack_frame; |
347 received_info.largest_observed = 1; | 347 ack_frame.largest_observed = 1; |
348 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 348 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
349 | 349 |
350 // 2 should be unacked, since it may provide an RTT measurement. | 350 // 2 should be unacked, since it may provide an RTT measurement. |
351 QuicPacketSequenceNumber unacked[] = { 2 }; | 351 QuicPacketSequenceNumber unacked[] = { 2 }; |
352 VerifyUnackedPackets(unacked, arraysize(unacked)); | 352 VerifyUnackedPackets(unacked, arraysize(unacked)); |
353 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | 353 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); |
354 VerifyRetransmittablePackets(NULL, 0); | 354 VerifyRetransmittablePackets(NULL, 0); |
355 | 355 |
356 // Verify that the retransmission alarm would not fire, | 356 // Verify that the retransmission alarm would not fire, |
357 // since there is no retransmittable data outstanding. | 357 // since there is no retransmittable data outstanding. |
358 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime()); | 358 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime()); |
359 EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted); | 359 EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted); |
360 } | 360 } |
361 | 361 |
362 TEST_F(QuicSentPacketManagerTest, RetransmitAndSendThenAckPrevious) { | 362 TEST_F(QuicSentPacketManagerTest, RetransmitAndSendThenAckPrevious) { |
363 SendDataPacket(1); | 363 SendDataPacket(1); |
364 RetransmitAndSendPacket(1, 2); | 364 RetransmitAndSendPacket(1, 2); |
365 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15); | 365 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15); |
366 clock_.AdvanceTime(rtt); | 366 clock_.AdvanceTime(rtt); |
367 | 367 |
368 // Ack 1 but not 2. | 368 // Ack 1 but not 2. |
369 ExpectAck(1); | 369 ExpectAck(1); |
370 ReceivedPacketInfo received_info; | 370 QuicAckFrame ack_frame; |
371 received_info.largest_observed = 1; | 371 ack_frame.largest_observed = 1; |
372 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 372 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
373 | 373 |
374 // 2 remains unacked, but no packets have retransmittable data. | 374 // 2 remains unacked, but no packets have retransmittable data. |
375 QuicPacketSequenceNumber unacked[] = { 2 }; | 375 QuicPacketSequenceNumber unacked[] = { 2 }; |
376 VerifyUnackedPackets(unacked, arraysize(unacked)); | 376 VerifyUnackedPackets(unacked, arraysize(unacked)); |
377 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | 377 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); |
378 VerifyRetransmittablePackets(NULL, 0); | 378 VerifyRetransmittablePackets(NULL, 0); |
379 | 379 |
380 EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted); | 380 EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted); |
381 } | 381 } |
382 | 382 |
383 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPreviousThenNackRetransmit) { | 383 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPreviousThenNackRetransmit) { |
384 SendDataPacket(1); | 384 SendDataPacket(1); |
385 RetransmitPacket(1, 2); | 385 RetransmitPacket(1, 2); |
386 EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 2, _, _)) | 386 EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 2, _, _)) |
387 .WillOnce(Return(true)); | 387 .WillOnce(Return(true)); |
388 manager_.OnPacketSent(2, clock_.ApproximateNow(), kDefaultLength, | 388 manager_.OnPacketSent(2, clock_.ApproximateNow(), kDefaultLength, |
389 LOSS_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA); | 389 LOSS_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA); |
390 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15); | 390 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15); |
391 clock_.AdvanceTime(rtt); | 391 clock_.AdvanceTime(rtt); |
392 | 392 |
393 // First, ACK packet 1 which makes packet 2 non-retransmittable. | 393 // First, ACK packet 1 which makes packet 2 non-retransmittable. |
394 ExpectAck(1); | 394 ExpectAck(1); |
395 ReceivedPacketInfo received_info; | 395 QuicAckFrame ack_frame; |
396 received_info.largest_observed = 1; | 396 ack_frame.largest_observed = 1; |
397 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 397 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
398 | 398 |
399 SendDataPacket(3); | 399 SendDataPacket(3); |
400 SendDataPacket(4); | 400 SendDataPacket(4); |
401 SendDataPacket(5); | 401 SendDataPacket(5); |
402 clock_.AdvanceTime(rtt); | 402 clock_.AdvanceTime(rtt); |
403 | 403 |
404 // Next, NACK packet 2 three times. | 404 // Next, NACK packet 2 three times. |
405 received_info.largest_observed = 3; | 405 ack_frame.largest_observed = 3; |
406 received_info.missing_packets.insert(2); | 406 ack_frame.missing_packets.insert(2); |
407 ExpectAck(3); | 407 ExpectAck(3); |
408 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 408 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
409 | 409 |
410 received_info.largest_observed = 4; | 410 ack_frame.largest_observed = 4; |
411 ExpectAck(4); | 411 ExpectAck(4); |
412 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 412 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
413 | 413 |
414 received_info.largest_observed = 5; | 414 ack_frame.largest_observed = 5; |
415 ExpectAckAndLoss(true, 5, 2); | 415 ExpectAckAndLoss(true, 5, 2); |
416 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 416 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
417 | 417 |
418 // No packets remain unacked. | 418 // No packets remain unacked. |
419 VerifyUnackedPackets(NULL, 0); | 419 VerifyUnackedPackets(NULL, 0); |
420 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | 420 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); |
421 VerifyRetransmittablePackets(NULL, 0); | 421 VerifyRetransmittablePackets(NULL, 0); |
422 | 422 |
423 // Verify that the retransmission alarm would not fire, | 423 // Verify that the retransmission alarm would not fire, |
424 // since there is no retransmittable data outstanding. | 424 // since there is no retransmittable data outstanding. |
425 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime()); | 425 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime()); |
426 } | 426 } |
427 | 427 |
428 TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckPreviousBeforeSend) { | 428 TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckPreviousBeforeSend) { |
429 SendDataPacket(1); | 429 SendDataPacket(1); |
430 RetransmitAndSendPacket(1, 2); | 430 RetransmitAndSendPacket(1, 2); |
431 | 431 |
432 // Fire the RTO, which will mark 2 for retransmission (but will not send it). | 432 // Fire the RTO, which will mark 2 for retransmission (but will not send it). |
433 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true)); | 433 EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true)); |
434 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_)); | 434 EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_)); |
435 EXPECT_CALL(*send_algorithm_, GetCongestionWindow()) | 435 EXPECT_CALL(*send_algorithm_, GetCongestionWindow()) |
436 .WillOnce(Return(2 * kDefaultTCPMSS)); | 436 .WillOnce(Return(2 * kDefaultTCPMSS)); |
437 manager_.OnRetransmissionTimeout(); | 437 manager_.OnRetransmissionTimeout(); |
438 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | 438 EXPECT_TRUE(manager_.HasPendingRetransmissions()); |
439 | 439 |
440 // Ack 1 but not 2, before 2 is able to be sent. | 440 // Ack 1 but not 2, before 2 is able to be sent. |
441 // Since 1 has been retransmitted, it has already been lost, and so the | 441 // Since 1 has been retransmitted, it has already been lost, and so the |
442 // send algorithm is not informed that it has been ACK'd. | 442 // send algorithm is not informed that it has been ACK'd. |
443 ReceivedPacketInfo received_info; | 443 QuicAckFrame ack_frame; |
444 received_info.largest_observed = 1; | 444 ack_frame.largest_observed = 1; |
445 ExpectUpdatedRtt(1); | 445 ExpectUpdatedRtt(1); |
446 EXPECT_CALL(*send_algorithm_, RevertRetransmissionTimeout()); | 446 EXPECT_CALL(*send_algorithm_, RevertRetransmissionTimeout()); |
447 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 447 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
448 | 448 |
449 // Since 2 was marked for retransmit, when 1 is acked, 2 is kept for RTT. | 449 // Since 2 was marked for retransmit, when 1 is acked, 2 is kept for RTT. |
450 QuicPacketSequenceNumber unacked[] = { 2 }; | 450 QuicPacketSequenceNumber unacked[] = { 2 }; |
451 VerifyUnackedPackets(unacked, arraysize(unacked)); | 451 VerifyUnackedPackets(unacked, arraysize(unacked)); |
452 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | 452 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); |
453 VerifyRetransmittablePackets(NULL, 0); | 453 VerifyRetransmittablePackets(NULL, 0); |
454 | 454 |
455 // Verify that the retransmission alarm would not fire, | 455 // Verify that the retransmission alarm would not fire, |
456 // since there is no retransmittable data outstanding. | 456 // since there is no retransmittable data outstanding. |
457 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime()); | 457 EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime()); |
458 } | 458 } |
459 | 459 |
460 TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckFirst) { | 460 TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckFirst) { |
461 StrictMock<MockDebugDelegate> debug_delegate; | 461 StrictMock<MockDebugDelegate> debug_delegate; |
462 EXPECT_CALL(debug_delegate, OnSpuriousPacketRetransmition( | 462 EXPECT_CALL(debug_delegate, OnSpuriousPacketRetransmition( |
463 TLP_RETRANSMISSION, kDefaultLength)).Times(2); | 463 TLP_RETRANSMISSION, kDefaultLength)).Times(2); |
464 manager_.set_debug_delegate(&debug_delegate); | 464 manager_.set_debug_delegate(&debug_delegate); |
465 | 465 |
466 SendDataPacket(1); | 466 SendDataPacket(1); |
467 RetransmitAndSendPacket(1, 2); | 467 RetransmitAndSendPacket(1, 2); |
468 RetransmitAndSendPacket(2, 3); | 468 RetransmitAndSendPacket(2, 3); |
469 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15); | 469 QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15); |
470 clock_.AdvanceTime(rtt); | 470 clock_.AdvanceTime(rtt); |
471 | 471 |
472 // Ack 1 but not 2 or 3. | 472 // Ack 1 but not 2 or 3. |
473 ExpectAck(1); | 473 ExpectAck(1); |
474 ReceivedPacketInfo received_info; | 474 QuicAckFrame ack_frame; |
475 received_info.largest_observed = 1; | 475 ack_frame.largest_observed = 1; |
476 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 476 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
477 | 477 |
478 // 2 and 3 remain unacked, but no packets have retransmittable data. | 478 // 2 and 3 remain unacked, but no packets have retransmittable data. |
479 QuicPacketSequenceNumber unacked[] = { 2, 3 }; | 479 QuicPacketSequenceNumber unacked[] = { 2, 3 }; |
480 VerifyUnackedPackets(unacked, arraysize(unacked)); | 480 VerifyUnackedPackets(unacked, arraysize(unacked)); |
481 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | 481 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); |
482 VerifyRetransmittablePackets(NULL, 0); | 482 VerifyRetransmittablePackets(NULL, 0); |
483 | 483 |
484 // Ensure packet 2 is lost when 4 is sent and 3 and 4 are acked. | 484 // Ensure packet 2 is lost when 4 is sent and 3 and 4 are acked. |
485 SendDataPacket(4); | 485 SendDataPacket(4); |
486 received_info.largest_observed = 4; | 486 ack_frame.largest_observed = 4; |
487 received_info.missing_packets.insert(2); | 487 ack_frame.missing_packets.insert(2); |
488 QuicPacketSequenceNumber acked[] = { 3, 4 }; | 488 QuicPacketSequenceNumber acked[] = { 3, 4 }; |
489 ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0); | 489 ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0); |
490 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 490 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
491 | 491 |
492 QuicPacketSequenceNumber unacked2[] = { 2 }; | 492 QuicPacketSequenceNumber unacked2[] = { 2 }; |
493 VerifyUnackedPackets(unacked2, arraysize(unacked2)); | 493 VerifyUnackedPackets(unacked2, arraysize(unacked2)); |
494 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | 494 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); |
495 | 495 |
496 SendDataPacket(5); | 496 SendDataPacket(5); |
497 received_info.largest_observed = 5; | 497 ack_frame.largest_observed = 5; |
498 ExpectAckAndLoss(true, 5, 2); | 498 ExpectAckAndLoss(true, 5, 2); |
499 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 499 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
500 | 500 |
501 VerifyUnackedPackets(NULL, 0); | 501 VerifyUnackedPackets(NULL, 0); |
502 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | 502 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); |
503 EXPECT_EQ(2u, stats_.packets_spuriously_retransmitted); | 503 EXPECT_EQ(2u, stats_.packets_spuriously_retransmitted); |
504 } | 504 } |
505 | 505 |
506 TEST_F(QuicSentPacketManagerTest, LoseButDontRetransmitRevivedPacket) { | 506 TEST_F(QuicSentPacketManagerTest, LoseButDontRetransmitRevivedPacket) { |
507 SendDataPacket(1); | 507 SendDataPacket(1); |
508 SendDataPacket(2); | 508 SendDataPacket(2); |
509 SendFecPacket(3); | 509 SendFecPacket(3); |
510 SendDataPacket(4); | 510 SendDataPacket(4); |
511 | 511 |
512 // Ack 2 and 3, and mark 1 as revived. | 512 // Ack 2 and 3, and mark 1 as revived. |
513 ReceivedPacketInfo received_info; | 513 QuicAckFrame ack_frame; |
514 received_info.largest_observed = 3; | 514 ack_frame.largest_observed = 3; |
515 received_info.missing_packets.insert(1); | 515 ack_frame.missing_packets.insert(1); |
516 received_info.revived_packets.insert(1); | 516 ack_frame.revived_packets.insert(1); |
517 QuicPacketSequenceNumber acked[] = { 2, 3 }; | 517 QuicPacketSequenceNumber acked[] = { 2, 3 }; |
518 ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0); | 518 ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0); |
519 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 519 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
520 | 520 |
521 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | 521 EXPECT_FALSE(manager_.HasPendingRetransmissions()); |
522 QuicPacketSequenceNumber unacked[] = { 1, 4 }; | 522 QuicPacketSequenceNumber unacked[] = { 1, 4 }; |
523 VerifyUnackedPackets(unacked, arraysize(unacked)); | 523 VerifyUnackedPackets(unacked, arraysize(unacked)); |
524 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | 524 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); |
525 QuicPacketSequenceNumber retransmittable[] = { 4 }; | 525 QuicPacketSequenceNumber retransmittable[] = { 4 }; |
526 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable)); | 526 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable)); |
527 | 527 |
528 // Ack the 4th packet and expect the 1st to be considered lost. | 528 // Ack the 4th packet and expect the 1st to be considered lost. |
529 received_info.largest_observed = 4; | 529 ack_frame.largest_observed = 4; |
530 ExpectAckAndLoss(true, 4, 1); | 530 ExpectAckAndLoss(true, 4, 1); |
531 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 531 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
532 | 532 |
533 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | 533 EXPECT_FALSE(manager_.HasPendingRetransmissions()); |
534 VerifyRetransmittablePackets(NULL, 0); | 534 VerifyRetransmittablePackets(NULL, 0); |
535 } | 535 } |
536 | 536 |
537 TEST_F(QuicSentPacketManagerTest, MarkLostThenReviveAndDontRetransmitPacket) { | 537 TEST_F(QuicSentPacketManagerTest, MarkLostThenReviveAndDontRetransmitPacket) { |
538 SendDataPacket(1); | 538 SendDataPacket(1); |
539 SendDataPacket(2); | 539 SendDataPacket(2); |
540 SendDataPacket(3); | 540 SendDataPacket(3); |
541 SendDataPacket(4); | 541 SendDataPacket(4); |
542 SendFecPacket(5); | 542 SendFecPacket(5); |
543 | 543 |
544 // Ack 2, 3, and 4, and expect the 1st to be considered lost. | 544 // Ack 2, 3, and 4, and expect the 1st to be considered lost. |
545 ReceivedPacketInfo received_info; | 545 QuicAckFrame ack_frame; |
546 received_info.largest_observed = 4; | 546 ack_frame.largest_observed = 4; |
547 received_info.missing_packets.insert(1); | 547 ack_frame.missing_packets.insert(1); |
548 QuicPacketSequenceNumber acked[] = { 2, 3, 4 }; | 548 QuicPacketSequenceNumber acked[] = { 2, 3, 4 }; |
549 QuicPacketSequenceNumber lost[] = { 1 }; | 549 QuicPacketSequenceNumber lost[] = { 1 }; |
550 ExpectAcksAndLosses(true, acked, arraysize(acked), lost, arraysize(lost)); | 550 ExpectAcksAndLosses(true, acked, arraysize(acked), lost, arraysize(lost)); |
551 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 551 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
552 | 552 |
553 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | 553 EXPECT_TRUE(manager_.HasPendingRetransmissions()); |
554 QuicPacketSequenceNumber unacked[] = { 1, 5 }; | 554 QuicPacketSequenceNumber unacked[] = { 1, 5 }; |
555 VerifyUnackedPackets(unacked, arraysize(unacked)); | 555 VerifyUnackedPackets(unacked, arraysize(unacked)); |
556 QuicPacketSequenceNumber retransmittable[] = { 1 }; | 556 QuicPacketSequenceNumber retransmittable[] = { 1 }; |
557 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable)); | 557 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable)); |
558 | 558 |
559 // Ack 5th packet (FEC) and revive 1st packet. 1st packet should now be | 559 // Ack 5th packet (FEC) and revive 1st packet. 1st packet should now be |
560 // removed from pending retransmissions map. | 560 // removed from pending retransmissions map. |
561 received_info.largest_observed = 5; | 561 ack_frame.largest_observed = 5; |
562 received_info.revived_packets.insert(1); | 562 ack_frame.revived_packets.insert(1); |
563 ExpectAck(5); | 563 ExpectAck(5); |
564 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 564 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
565 | 565 |
566 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | 566 EXPECT_FALSE(manager_.HasPendingRetransmissions()); |
567 VerifyRetransmittablePackets(NULL, 0); | 567 VerifyRetransmittablePackets(NULL, 0); |
568 } | 568 } |
569 | 569 |
570 TEST_F(QuicSentPacketManagerTest, TruncatedAck) { | 570 TEST_F(QuicSentPacketManagerTest, TruncatedAck) { |
571 SendDataPacket(1); | 571 SendDataPacket(1); |
572 RetransmitAndSendPacket(1, 2); | 572 RetransmitAndSendPacket(1, 2); |
573 RetransmitAndSendPacket(2, 3); | 573 RetransmitAndSendPacket(2, 3); |
574 RetransmitAndSendPacket(3, 4); | 574 RetransmitAndSendPacket(3, 4); |
575 RetransmitAndSendPacket(4, 5); | 575 RetransmitAndSendPacket(4, 5); |
576 | 576 |
577 // Truncated ack with 4 NACKs, so the first packet is lost. | 577 // Truncated ack with 4 NACKs, so the first packet is lost. |
578 ReceivedPacketInfo received_info; | 578 QuicAckFrame ack_frame; |
579 received_info.largest_observed = 4; | 579 ack_frame.largest_observed = 4; |
580 received_info.missing_packets.insert(1); | 580 ack_frame.missing_packets.insert(1); |
581 received_info.missing_packets.insert(2); | 581 ack_frame.missing_packets.insert(2); |
582 received_info.missing_packets.insert(3); | 582 ack_frame.missing_packets.insert(3); |
583 received_info.missing_packets.insert(4); | 583 ack_frame.missing_packets.insert(4); |
584 received_info.is_truncated = true; | 584 ack_frame.is_truncated = true; |
585 | 585 |
586 QuicPacketSequenceNumber lost[] = { 1 }; | 586 QuicPacketSequenceNumber lost[] = { 1 }; |
587 ExpectAcksAndLosses(true, NULL, 0, lost, arraysize(lost)); | 587 ExpectAcksAndLosses(true, NULL, 0, lost, arraysize(lost)); |
588 manager_.OnIncomingAck(received_info, clock_.Now()); | 588 manager_.OnIncomingAck(ack_frame, clock_.Now()); |
589 | 589 |
590 // High water mark will be raised. | 590 // High water mark will be raised. |
591 QuicPacketSequenceNumber unacked[] = { 2, 3, 4, 5 }; | 591 QuicPacketSequenceNumber unacked[] = { 2, 3, 4, 5 }; |
592 VerifyUnackedPackets(unacked, arraysize(unacked)); | 592 VerifyUnackedPackets(unacked, arraysize(unacked)); |
593 QuicPacketSequenceNumber retransmittable[] = { 5 }; | 593 QuicPacketSequenceNumber retransmittable[] = { 5 }; |
594 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable)); | 594 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable)); |
595 } | 595 } |
596 | 596 |
597 TEST_F(QuicSentPacketManagerTest, AckPreviousTransmissionThenTruncatedAck) { | 597 TEST_F(QuicSentPacketManagerTest, AckPreviousTransmissionThenTruncatedAck) { |
598 SendDataPacket(1); | 598 SendDataPacket(1); |
599 RetransmitAndSendPacket(1, 2); | 599 RetransmitAndSendPacket(1, 2); |
600 RetransmitAndSendPacket(2, 3); | 600 RetransmitAndSendPacket(2, 3); |
601 RetransmitAndSendPacket(3, 4); | 601 RetransmitAndSendPacket(3, 4); |
602 manager_.OnSerializedPacket(CreateDataPacket(5)); | 602 manager_.OnSerializedPacket(CreateDataPacket(5)); |
603 manager_.OnSerializedPacket(CreateDataPacket(6)); | 603 manager_.OnSerializedPacket(CreateDataPacket(6)); |
604 manager_.OnSerializedPacket(CreateDataPacket(7)); | 604 manager_.OnSerializedPacket(CreateDataPacket(7)); |
605 manager_.OnSerializedPacket(CreateDataPacket(8)); | 605 manager_.OnSerializedPacket(CreateDataPacket(8)); |
606 manager_.OnSerializedPacket(CreateDataPacket(9)); | 606 manager_.OnSerializedPacket(CreateDataPacket(9)); |
607 | 607 |
608 // Ack previous transmission | 608 // Ack previous transmission |
609 { | 609 { |
610 ReceivedPacketInfo received_info; | 610 QuicAckFrame ack_frame; |
611 received_info.largest_observed = 2; | 611 ack_frame.largest_observed = 2; |
612 received_info.missing_packets.insert(1); | 612 ack_frame.missing_packets.insert(1); |
613 ExpectAck(2); | 613 ExpectAck(2); |
614 manager_.OnIncomingAck(received_info, clock_.Now()); | 614 manager_.OnIncomingAck(ack_frame, clock_.Now()); |
615 EXPECT_TRUE(manager_.IsUnacked(4)); | 615 EXPECT_TRUE(manager_.IsUnacked(4)); |
616 } | 616 } |
617 | 617 |
618 // Truncated ack with 4 NACKs | 618 // Truncated ack with 4 NACKs |
619 { | 619 { |
620 ReceivedPacketInfo received_info; | 620 QuicAckFrame ack_frame; |
621 received_info.largest_observed = 6; | 621 ack_frame.largest_observed = 6; |
622 received_info.missing_packets.insert(3); | 622 ack_frame.missing_packets.insert(3); |
623 received_info.missing_packets.insert(4); | 623 ack_frame.missing_packets.insert(4); |
624 received_info.missing_packets.insert(5); | 624 ack_frame.missing_packets.insert(5); |
625 received_info.missing_packets.insert(6); | 625 ack_frame.missing_packets.insert(6); |
626 received_info.is_truncated = true; | 626 ack_frame.is_truncated = true; |
627 ExpectAckAndLoss(false, 1, 3); | 627 ExpectAckAndLoss(false, 1, 3); |
628 manager_.OnIncomingAck(received_info, clock_.Now()); | 628 manager_.OnIncomingAck(ack_frame, clock_.Now()); |
629 } | 629 } |
630 | 630 |
631 // High water mark will be raised. | 631 // High water mark will be raised. |
632 QuicPacketSequenceNumber unacked[] = { 4, 5, 6, 7, 8, 9 }; | 632 QuicPacketSequenceNumber unacked[] = { 4, 5, 6, 7, 8, 9 }; |
633 VerifyUnackedPackets(unacked, arraysize(unacked)); | 633 VerifyUnackedPackets(unacked, arraysize(unacked)); |
634 QuicPacketSequenceNumber retransmittable[] = { 5, 6, 7, 8, 9 }; | 634 QuicPacketSequenceNumber retransmittable[] = { 5, 6, 7, 8, 9 }; |
635 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable)); | 635 VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable)); |
636 } | 636 } |
637 | 637 |
638 TEST_F(QuicSentPacketManagerTest, GetLeastUnackedSentPacket) { | 638 TEST_F(QuicSentPacketManagerTest, GetLeastUnackedSentPacket) { |
(...skipping 27 matching lines...) Expand all Loading... |
666 | 666 |
667 SerializedPacket serialized_packet3(CreateFecPacket(3)); | 667 SerializedPacket serialized_packet3(CreateFecPacket(3)); |
668 manager_.OnSerializedPacket(serialized_packet3); | 668 manager_.OnSerializedPacket(serialized_packet3); |
669 EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket()); | 669 EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket()); |
670 | 670 |
671 QuicPacketSequenceNumber unacked[] = { 1, 2, 3 }; | 671 QuicPacketSequenceNumber unacked[] = { 1, 2, 3 }; |
672 VerifyUnackedPackets(unacked, arraysize(unacked)); | 672 VerifyUnackedPackets(unacked, arraysize(unacked)); |
673 VerifyRetransmittablePackets(NULL, 0); | 673 VerifyRetransmittablePackets(NULL, 0); |
674 | 674 |
675 // Ack 2, which has never been sent, so there's no rtt update. | 675 // Ack 2, which has never been sent, so there's no rtt update. |
676 ReceivedPacketInfo received_info; | 676 QuicAckFrame ack_frame; |
677 received_info.largest_observed = 2; | 677 ack_frame.largest_observed = 2; |
678 manager_.OnIncomingAck(received_info, clock_.Now()); | 678 manager_.OnIncomingAck(ack_frame, clock_.Now()); |
679 | 679 |
680 EXPECT_EQ(3u, manager_.GetLeastUnackedSentPacket()); | 680 EXPECT_EQ(3u, manager_.GetLeastUnackedSentPacket()); |
681 } | 681 } |
682 | 682 |
683 TEST_F(QuicSentPacketManagerTest, GetSentTime) { | 683 TEST_F(QuicSentPacketManagerTest, GetSentTime) { |
684 VerifyUnackedPackets(NULL, 0); | 684 VerifyUnackedPackets(NULL, 0); |
685 | 685 |
686 SerializedPacket serialized_packet(CreateFecPacket(1)); | 686 SerializedPacket serialized_packet(CreateFecPacket(1)); |
687 manager_.OnSerializedPacket(serialized_packet); | 687 manager_.OnSerializedPacket(serialized_packet); |
688 EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 1, _, _)) | 688 EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 1, _, _)) |
(...skipping 17 matching lines...) Expand all Loading... |
706 EXPECT_EQ(QuicTime::Zero(), | 706 EXPECT_EQ(QuicTime::Zero(), |
707 QuicSentPacketManagerPeer::GetSentTime(&manager_, 1)); | 707 QuicSentPacketManagerPeer::GetSentTime(&manager_, 1)); |
708 EXPECT_EQ(sent_time, QuicSentPacketManagerPeer::GetSentTime(&manager_, 2)); | 708 EXPECT_EQ(sent_time, QuicSentPacketManagerPeer::GetSentTime(&manager_, 2)); |
709 } | 709 } |
710 | 710 |
711 TEST_F(QuicSentPacketManagerTest, AckAckAndUpdateRtt) { | 711 TEST_F(QuicSentPacketManagerTest, AckAckAndUpdateRtt) { |
712 SendDataPacket(1); | 712 SendDataPacket(1); |
713 SendAckPacket(2); | 713 SendAckPacket(2); |
714 | 714 |
715 // Now ack the ack and expect an RTT update. | 715 // Now ack the ack and expect an RTT update. |
716 ReceivedPacketInfo received_info; | 716 QuicAckFrame ack_frame; |
717 received_info.largest_observed = 2; | 717 ack_frame.largest_observed = 2; |
718 received_info.delta_time_largest_observed = | 718 ack_frame.delta_time_largest_observed = |
719 QuicTime::Delta::FromMilliseconds(5); | 719 QuicTime::Delta::FromMilliseconds(5); |
720 | 720 |
721 ExpectAck(1); | 721 ExpectAck(1); |
722 manager_.OnIncomingAck(received_info, clock_.Now()); | 722 manager_.OnIncomingAck(ack_frame, clock_.Now()); |
723 | 723 |
724 SendAckPacket(3); | 724 SendAckPacket(3); |
725 | 725 |
726 // Now ack the ack and expect only an RTT update. | 726 // Now ack the ack and expect only an RTT update. |
727 received_info.largest_observed = 3; | 727 ack_frame.largest_observed = 3; |
728 ExpectUpdatedRtt(3); | 728 ExpectUpdatedRtt(3); |
729 manager_.OnIncomingAck(received_info, clock_.Now()); | 729 manager_.OnIncomingAck(ack_frame, clock_.Now()); |
730 } | 730 } |
731 | 731 |
732 TEST_F(QuicSentPacketManagerTest, Rtt) { | 732 TEST_F(QuicSentPacketManagerTest, Rtt) { |
733 QuicPacketSequenceNumber sequence_number = 1; | 733 QuicPacketSequenceNumber sequence_number = 1; |
734 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(15); | 734 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(15); |
735 SendDataPacket(sequence_number); | 735 SendDataPacket(sequence_number); |
736 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(20)); | 736 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(20)); |
737 | 737 |
738 ExpectAck(sequence_number); | 738 ExpectAck(sequence_number); |
739 ReceivedPacketInfo received_info; | 739 QuicAckFrame ack_frame; |
740 received_info.largest_observed = sequence_number; | 740 ack_frame.largest_observed = sequence_number; |
741 received_info.delta_time_largest_observed = | 741 ack_frame.delta_time_largest_observed = |
742 QuicTime::Delta::FromMilliseconds(5); | 742 QuicTime::Delta::FromMilliseconds(5); |
743 manager_.OnIncomingAck(received_info, clock_.Now()); | 743 manager_.OnIncomingAck(ack_frame, clock_.Now()); |
744 EXPECT_EQ(expected_rtt, | 744 EXPECT_EQ(expected_rtt, |
745 QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt()); | 745 QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt()); |
746 } | 746 } |
747 | 747 |
748 TEST_F(QuicSentPacketManagerTest, RttWithInvalidDelta) { | 748 TEST_F(QuicSentPacketManagerTest, RttWithInvalidDelta) { |
749 // Expect that the RTT is equal to the local time elapsed, since the | 749 // Expect that the RTT is equal to the local time elapsed, since the |
750 // delta_time_largest_observed is larger than the local time elapsed | 750 // delta_time_largest_observed is larger than the local time elapsed |
751 // and is hence invalid. | 751 // and is hence invalid. |
752 QuicPacketSequenceNumber sequence_number = 1; | 752 QuicPacketSequenceNumber sequence_number = 1; |
753 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10); | 753 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10); |
754 SendDataPacket(sequence_number); | 754 SendDataPacket(sequence_number); |
755 clock_.AdvanceTime(expected_rtt); | 755 clock_.AdvanceTime(expected_rtt); |
756 | 756 |
757 ExpectAck(sequence_number); | 757 ExpectAck(sequence_number); |
758 ReceivedPacketInfo received_info; | 758 QuicAckFrame ack_frame; |
759 received_info.largest_observed = sequence_number; | 759 ack_frame.largest_observed = sequence_number; |
760 received_info.delta_time_largest_observed = | 760 ack_frame.delta_time_largest_observed = |
761 QuicTime::Delta::FromMilliseconds(11); | 761 QuicTime::Delta::FromMilliseconds(11); |
762 manager_.OnIncomingAck(received_info, clock_.Now()); | 762 manager_.OnIncomingAck(ack_frame, clock_.Now()); |
763 EXPECT_EQ(expected_rtt, | 763 EXPECT_EQ(expected_rtt, |
764 QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt()); | 764 QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt()); |
765 } | 765 } |
766 | 766 |
767 TEST_F(QuicSentPacketManagerTest, RttWithInfiniteDelta) { | 767 TEST_F(QuicSentPacketManagerTest, RttWithInfiniteDelta) { |
768 // Expect that the RTT is equal to the local time elapsed, since the | 768 // Expect that the RTT is equal to the local time elapsed, since the |
769 // delta_time_largest_observed is infinite, and is hence invalid. | 769 // delta_time_largest_observed is infinite, and is hence invalid. |
770 QuicPacketSequenceNumber sequence_number = 1; | 770 QuicPacketSequenceNumber sequence_number = 1; |
771 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10); | 771 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10); |
772 SendDataPacket(sequence_number); | 772 SendDataPacket(sequence_number); |
773 clock_.AdvanceTime(expected_rtt); | 773 clock_.AdvanceTime(expected_rtt); |
774 | 774 |
775 ExpectAck(sequence_number); | 775 ExpectAck(sequence_number); |
776 ReceivedPacketInfo received_info; | 776 QuicAckFrame ack_frame; |
777 received_info.largest_observed = sequence_number; | 777 ack_frame.largest_observed = sequence_number; |
778 received_info.delta_time_largest_observed = QuicTime::Delta::Infinite(); | 778 ack_frame.delta_time_largest_observed = QuicTime::Delta::Infinite(); |
779 manager_.OnIncomingAck(received_info, clock_.Now()); | 779 manager_.OnIncomingAck(ack_frame, clock_.Now()); |
780 EXPECT_EQ(expected_rtt, | 780 EXPECT_EQ(expected_rtt, |
781 QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt()); | 781 QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt()); |
782 } | 782 } |
783 | 783 |
784 TEST_F(QuicSentPacketManagerTest, RttZeroDelta) { | 784 TEST_F(QuicSentPacketManagerTest, RttZeroDelta) { |
785 // Expect that the RTT is the time between send and receive since the | 785 // Expect that the RTT is the time between send and receive since the |
786 // delta_time_largest_observed is zero. | 786 // delta_time_largest_observed is zero. |
787 QuicPacketSequenceNumber sequence_number = 1; | 787 QuicPacketSequenceNumber sequence_number = 1; |
788 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10); | 788 QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10); |
789 SendDataPacket(sequence_number); | 789 SendDataPacket(sequence_number); |
790 clock_.AdvanceTime(expected_rtt); | 790 clock_.AdvanceTime(expected_rtt); |
791 | 791 |
792 ExpectAck(sequence_number); | 792 ExpectAck(sequence_number); |
793 ReceivedPacketInfo received_info; | 793 QuicAckFrame ack_frame; |
794 received_info.largest_observed = sequence_number; | 794 ack_frame.largest_observed = sequence_number; |
795 received_info.delta_time_largest_observed = QuicTime::Delta::Zero(); | 795 ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero(); |
796 manager_.OnIncomingAck(received_info, clock_.Now()); | 796 manager_.OnIncomingAck(ack_frame, clock_.Now()); |
797 EXPECT_EQ(expected_rtt, | 797 EXPECT_EQ(expected_rtt, |
798 QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt()); | 798 QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt()); |
799 } | 799 } |
800 | 800 |
801 TEST_F(QuicSentPacketManagerTest, TailLossProbeTimeout) { | 801 TEST_F(QuicSentPacketManagerTest, TailLossProbeTimeout) { |
802 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2); | 802 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2); |
803 | 803 |
804 // Send 1 packet. | 804 // Send 1 packet. |
805 QuicPacketSequenceNumber sequence_number = 1; | 805 QuicPacketSequenceNumber sequence_number = 1; |
806 SendDataPacket(sequence_number); | 806 SendDataPacket(sequence_number); |
(...skipping 17 matching lines...) Expand all Loading... |
824 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | 824 EXPECT_TRUE(manager_.HasPendingRetransmissions()); |
825 RetransmitNextPacket(3); | 825 RetransmitNextPacket(3); |
826 EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).WillOnce(Return( | 826 EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).WillOnce(Return( |
827 QuicTime::Delta::Infinite())); | 827 QuicTime::Delta::Infinite())); |
828 EXPECT_EQ(QuicTime::Delta::Infinite(), | 828 EXPECT_EQ(QuicTime::Delta::Infinite(), |
829 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA)); | 829 manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA)); |
830 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | 830 EXPECT_FALSE(manager_.HasPendingRetransmissions()); |
831 | 831 |
832 // Ack the third and ensure the first two are still pending. | 832 // Ack the third and ensure the first two are still pending. |
833 ExpectAck(3); | 833 ExpectAck(3); |
834 ReceivedPacketInfo received_info; | 834 QuicAckFrame ack_frame; |
835 received_info.largest_observed = 3; | 835 ack_frame.largest_observed = 3; |
836 received_info.missing_packets.insert(1); | 836 ack_frame.missing_packets.insert(1); |
837 received_info.missing_packets.insert(2); | 837 ack_frame.missing_packets.insert(2); |
838 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 838 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
839 | 839 |
840 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | 840 EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); |
841 | 841 |
842 // Acking two more packets will lose both of them due to nacks. | 842 // Acking two more packets will lose both of them due to nacks. |
843 received_info.largest_observed = 5; | 843 ack_frame.largest_observed = 5; |
844 QuicPacketSequenceNumber lost[] = { 1, 2 }; | 844 QuicPacketSequenceNumber lost[] = { 1, 2 }; |
845 ExpectAcksAndLosses(false, NULL, 0, lost, arraysize(lost)); | 845 ExpectAcksAndLosses(false, NULL, 0, lost, arraysize(lost)); |
846 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 846 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
847 | 847 |
848 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | 848 EXPECT_FALSE(manager_.HasPendingRetransmissions()); |
849 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | 849 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); |
850 EXPECT_EQ(2u, stats_.tlp_count); | 850 EXPECT_EQ(2u, stats_.tlp_count); |
851 EXPECT_EQ(0u, stats_.rto_count); | 851 EXPECT_EQ(0u, stats_.rto_count); |
852 } | 852 } |
853 | 853 |
854 TEST_F(QuicSentPacketManagerTest, TailLossProbeThenRTO) { | 854 TEST_F(QuicSentPacketManagerTest, TailLossProbeThenRTO) { |
855 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2); | 855 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2); |
856 | 856 |
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
924 manager_.OnRetransmissionTimeout(); | 924 manager_.OnRetransmissionTimeout(); |
925 RetransmitNextPacket(8); | 925 RetransmitNextPacket(8); |
926 RetransmitNextPacket(9); | 926 RetransmitNextPacket(9); |
927 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | 927 EXPECT_FALSE(manager_.HasPendingRetransmissions()); |
928 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | 928 EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); |
929 | 929 |
930 // Now ack the two crypto packets and the speculatively encrypted request, | 930 // Now ack the two crypto packets and the speculatively encrypted request, |
931 // and ensure the first four crypto packets get abandoned, but not lost. | 931 // and ensure the first four crypto packets get abandoned, but not lost. |
932 QuicPacketSequenceNumber acked[] = { 3, 4, 5, 8, 9 }; | 932 QuicPacketSequenceNumber acked[] = { 3, 4, 5, 8, 9 }; |
933 ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0); | 933 ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0); |
934 ReceivedPacketInfo received_info; | 934 QuicAckFrame ack_frame; |
935 received_info.largest_observed = 9; | 935 ack_frame.largest_observed = 9; |
936 received_info.missing_packets.insert(1); | 936 ack_frame.missing_packets.insert(1); |
937 received_info.missing_packets.insert(2); | 937 ack_frame.missing_packets.insert(2); |
938 received_info.missing_packets.insert(6); | 938 ack_frame.missing_packets.insert(6); |
939 received_info.missing_packets.insert(7); | 939 ack_frame.missing_packets.insert(7); |
940 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 940 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
941 | 941 |
942 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | 942 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); |
943 } | 943 } |
944 | 944 |
945 TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeoutVersionNegotiation) { | 945 TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeoutVersionNegotiation) { |
946 // Send 2 crypto packets and 3 data packets. | 946 // Send 2 crypto packets and 3 data packets. |
947 const size_t kNumSentCryptoPackets = 2; | 947 const size_t kNumSentCryptoPackets = 2; |
948 for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) { | 948 for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) { |
949 SendCryptoPacket(i); | 949 SendCryptoPacket(i); |
950 } | 950 } |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
984 manager_.OnRetransmissionTimeout(); | 984 manager_.OnRetransmissionTimeout(); |
985 RetransmitNextPacket(2); | 985 RetransmitNextPacket(2); |
986 | 986 |
987 // Retransmit the crypto packet as 3. | 987 // Retransmit the crypto packet as 3. |
988 manager_.OnRetransmissionTimeout(); | 988 manager_.OnRetransmissionTimeout(); |
989 RetransmitNextPacket(3); | 989 RetransmitNextPacket(3); |
990 | 990 |
991 // Now ack the second crypto packet, and ensure the first gets removed, but | 991 // Now ack the second crypto packet, and ensure the first gets removed, but |
992 // the third does not. | 992 // the third does not. |
993 ExpectUpdatedRtt(2); | 993 ExpectUpdatedRtt(2); |
994 ReceivedPacketInfo received_info; | 994 QuicAckFrame ack_frame; |
995 received_info.largest_observed = 2; | 995 ack_frame.largest_observed = 2; |
996 received_info.missing_packets.insert(1); | 996 ack_frame.missing_packets.insert(1); |
997 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 997 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
998 | 998 |
999 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | 999 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); |
1000 QuicPacketSequenceNumber unacked[] = { 3 }; | 1000 QuicPacketSequenceNumber unacked[] = { 3 }; |
1001 VerifyUnackedPackets(unacked, arraysize(unacked)); | 1001 VerifyUnackedPackets(unacked, arraysize(unacked)); |
1002 } | 1002 } |
1003 | 1003 |
1004 TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeoutUnsentDataPacket) { | 1004 TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeoutUnsentDataPacket) { |
1005 // Send 2 crypto packets and serialize 1 data packet. | 1005 // Send 2 crypto packets and serialize 1 data packet. |
1006 const size_t kNumSentCryptoPackets = 2; | 1006 const size_t kNumSentCryptoPackets = 2; |
1007 for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) { | 1007 for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) { |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1057 // connection goes forward secure. | 1057 // connection goes forward secure. |
1058 manager_.NeuterUnencryptedPackets(); | 1058 manager_.NeuterUnencryptedPackets(); |
1059 QuicPacketSequenceNumber unacked[] = { 1, 2, 3}; | 1059 QuicPacketSequenceNumber unacked[] = { 1, 2, 3}; |
1060 VerifyUnackedPackets(unacked, arraysize(unacked)); | 1060 VerifyUnackedPackets(unacked, arraysize(unacked)); |
1061 VerifyRetransmittablePackets(NULL, 0); | 1061 VerifyRetransmittablePackets(NULL, 0); |
1062 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | 1062 EXPECT_FALSE(manager_.HasPendingRetransmissions()); |
1063 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); | 1063 EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_)); |
1064 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); | 1064 EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_)); |
1065 | 1065 |
1066 // Ensure both packets get discarded when packet 2 is acked. | 1066 // Ensure both packets get discarded when packet 2 is acked. |
1067 ReceivedPacketInfo received_info; | 1067 QuicAckFrame ack_frame; |
1068 received_info.largest_observed = 3; | 1068 ack_frame.largest_observed = 3; |
1069 received_info.missing_packets.insert(1); | 1069 ack_frame.missing_packets.insert(1); |
1070 received_info.missing_packets.insert(2); | 1070 ack_frame.missing_packets.insert(2); |
1071 ExpectUpdatedRtt(3); | 1071 ExpectUpdatedRtt(3); |
1072 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 1072 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
1073 VerifyUnackedPackets(NULL, 0); | 1073 VerifyUnackedPackets(NULL, 0); |
1074 VerifyRetransmittablePackets(NULL, 0); | 1074 VerifyRetransmittablePackets(NULL, 0); |
1075 } | 1075 } |
1076 | 1076 |
1077 TEST_F(QuicSentPacketManagerTest, TailLossProbeTimeoutUnsentDataPacket) { | 1077 TEST_F(QuicSentPacketManagerTest, TailLossProbeTimeoutUnsentDataPacket) { |
1078 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2); | 1078 QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2); |
1079 // Serialize two data packets and send the latter. | 1079 // Serialize two data packets and send the latter. |
1080 SerializedPacket packet(CreateDataPacket(1)); | 1080 SerializedPacket packet(CreateDataPacket(1)); |
1081 manager_.OnSerializedPacket(packet); | 1081 manager_.OnSerializedPacket(packet); |
1082 SendDataPacket(2); | 1082 SendDataPacket(2); |
(...skipping 26 matching lines...) Expand all Loading... |
1109 EXPECT_EQ(min_rtt, | 1109 EXPECT_EQ(min_rtt, |
1110 QuicSentPacketManagerPeer::GetRttStats( | 1110 QuicSentPacketManagerPeer::GetRttStats( |
1111 &manager_)->recent_min_rtt()); | 1111 &manager_)->recent_min_rtt()); |
1112 | 1112 |
1113 // Send two packets with no prior bytes in flight. | 1113 // Send two packets with no prior bytes in flight. |
1114 SendDataPacket(1); | 1114 SendDataPacket(1); |
1115 SendDataPacket(2); | 1115 SendDataPacket(2); |
1116 | 1116 |
1117 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(100)); | 1117 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(100)); |
1118 // Ack two packets with 100ms RTT observations. | 1118 // Ack two packets with 100ms RTT observations. |
1119 ReceivedPacketInfo received_info; | 1119 QuicAckFrame ack_frame; |
1120 received_info.delta_time_largest_observed = QuicTime::Delta::Zero(); | 1120 ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero(); |
1121 received_info.largest_observed = 1; | 1121 ack_frame.largest_observed = 1; |
1122 ExpectAck(1); | 1122 ExpectAck(1); |
1123 manager_.OnIncomingAck(received_info, clock_.Now()); | 1123 manager_.OnIncomingAck(ack_frame, clock_.Now()); |
1124 | 1124 |
1125 // First ack does not change recent min rtt. | 1125 // First ack does not change recent min rtt. |
1126 EXPECT_EQ(min_rtt, | 1126 EXPECT_EQ(min_rtt, |
1127 QuicSentPacketManagerPeer::GetRttStats( | 1127 QuicSentPacketManagerPeer::GetRttStats( |
1128 &manager_)->recent_min_rtt()); | 1128 &manager_)->recent_min_rtt()); |
1129 | 1129 |
1130 received_info.largest_observed = 2; | 1130 ack_frame.largest_observed = 2; |
1131 ExpectAck(2); | 1131 ExpectAck(2); |
1132 manager_.OnIncomingAck(received_info, clock_.Now()); | 1132 manager_.OnIncomingAck(ack_frame, clock_.Now()); |
1133 | 1133 |
1134 EXPECT_EQ(min_rtt, | 1134 EXPECT_EQ(min_rtt, |
1135 QuicSentPacketManagerPeer::GetRttStats(&manager_)->min_rtt()); | 1135 QuicSentPacketManagerPeer::GetRttStats(&manager_)->min_rtt()); |
1136 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100), | 1136 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100), |
1137 QuicSentPacketManagerPeer::GetRttStats( | 1137 QuicSentPacketManagerPeer::GetRttStats( |
1138 &manager_)->recent_min_rtt()); | 1138 &manager_)->recent_min_rtt()); |
1139 } | 1139 } |
1140 | 1140 |
1141 TEST_F(QuicSentPacketManagerTest, RetransmissionTimeout) { | 1141 TEST_F(QuicSentPacketManagerTest, RetransmissionTimeout) { |
1142 // Send 100 packets and then ensure all are abandoned when the RTO fires. | 1142 // Send 100 packets and then ensure all are abandoned when the RTO fires. |
(...skipping 108 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1251 RetransmitNextPacket(6); | 1251 RetransmitNextPacket(6); |
1252 EXPECT_EQ(2 * kDefaultLength, | 1252 EXPECT_EQ(2 * kDefaultLength, |
1253 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); | 1253 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); |
1254 EXPECT_TRUE(manager_.HasPendingRetransmissions()); | 1254 EXPECT_TRUE(manager_.HasPendingRetransmissions()); |
1255 | 1255 |
1256 // The delay should double the second time. | 1256 // The delay should double the second time. |
1257 expected_time = clock_.Now().Add(expected_rto_delay).Add(expected_rto_delay); | 1257 expected_time = clock_.Now().Add(expected_rto_delay).Add(expected_rto_delay); |
1258 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime()); | 1258 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime()); |
1259 | 1259 |
1260 // Ack a packet and ensure the RTO goes back to the original value. | 1260 // Ack a packet and ensure the RTO goes back to the original value. |
1261 ReceivedPacketInfo received_info; | 1261 QuicAckFrame ack_frame; |
1262 received_info.largest_observed = 2; | 1262 ack_frame.largest_observed = 2; |
1263 received_info.missing_packets.insert(1); | 1263 ack_frame.missing_packets.insert(1); |
1264 ExpectUpdatedRtt(2); | 1264 ExpectUpdatedRtt(2); |
1265 EXPECT_CALL(*send_algorithm_, RevertRetransmissionTimeout()); | 1265 EXPECT_CALL(*send_algorithm_, RevertRetransmissionTimeout()); |
1266 manager_.OnIncomingAck(received_info, clock_.ApproximateNow()); | 1266 manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow()); |
1267 EXPECT_FALSE(manager_.HasPendingRetransmissions()); | 1267 EXPECT_FALSE(manager_.HasPendingRetransmissions()); |
1268 EXPECT_EQ(4 * kDefaultLength, | 1268 EXPECT_EQ(4 * kDefaultLength, |
1269 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); | 1269 QuicSentPacketManagerPeer::GetBytesInFlight(&manager_)); |
1270 | 1270 |
1271 // Wait 2RTTs from now for the RTO, since it's the max of the RTO time | 1271 // Wait 2RTTs from now for the RTO, since it's the max of the RTO time |
1272 // and the TLP time. In production, there would always be two TLP's first. | 1272 // and the TLP time. In production, there would always be two TLP's first. |
1273 expected_time = clock_.Now().Add(QuicTime::Delta::FromMilliseconds(200)); | 1273 expected_time = clock_.Now().Add(QuicTime::Delta::FromMilliseconds(200)); |
1274 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime()); | 1274 EXPECT_EQ(expected_time, manager_.GetRetransmissionTime()); |
1275 } | 1275 } |
1276 | 1276 |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1330 EXPECT_CALL(*loss_algorithm, GetLossTimeout()) | 1330 EXPECT_CALL(*loss_algorithm, GetLossTimeout()) |
1331 .WillRepeatedly(Return(QuicTime::Zero())); | 1331 .WillRepeatedly(Return(QuicTime::Zero())); |
1332 SendDataPacket(1); | 1332 SendDataPacket(1); |
1333 SendDataPacket(2); | 1333 SendDataPacket(2); |
1334 | 1334 |
1335 // Handle an ack which causes the loss algorithm to be evaluated and | 1335 // Handle an ack which causes the loss algorithm to be evaluated and |
1336 // set the loss timeout. | 1336 // set the loss timeout. |
1337 ExpectAck(2); | 1337 ExpectAck(2); |
1338 EXPECT_CALL(*loss_algorithm, DetectLostPackets(_, _, _, _)) | 1338 EXPECT_CALL(*loss_algorithm, DetectLostPackets(_, _, _, _)) |
1339 .WillOnce(Return(SequenceNumberSet())); | 1339 .WillOnce(Return(SequenceNumberSet())); |
1340 ReceivedPacketInfo received_info; | 1340 QuicAckFrame ack_frame; |
1341 received_info.largest_observed = 2; | 1341 ack_frame.largest_observed = 2; |
1342 received_info.missing_packets.insert(1); | 1342 ack_frame.missing_packets.insert(1); |
1343 manager_.OnIncomingAck(received_info, clock_.Now()); | 1343 manager_.OnIncomingAck(ack_frame, clock_.Now()); |
1344 | 1344 |
1345 QuicTime timeout(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(10))); | 1345 QuicTime timeout(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(10))); |
1346 EXPECT_CALL(*loss_algorithm, GetLossTimeout()) | 1346 EXPECT_CALL(*loss_algorithm, GetLossTimeout()) |
1347 .WillRepeatedly(Return(timeout)); | 1347 .WillRepeatedly(Return(timeout)); |
1348 EXPECT_EQ(timeout, manager_.GetRetransmissionTime()); | 1348 EXPECT_EQ(timeout, manager_.GetRetransmissionTime()); |
1349 | 1349 |
1350 // Fire the retransmission timeout and ensure the loss detection algorithm | 1350 // Fire the retransmission timeout and ensure the loss detection algorithm |
1351 // is invoked. | 1351 // is invoked. |
1352 EXPECT_CALL(*loss_algorithm, DetectLostPackets(_, _, _, _)) | 1352 EXPECT_CALL(*loss_algorithm, DetectLostPackets(_, _, _, _)) |
1353 .WillOnce(Return(SequenceNumberSet())); | 1353 .WillOnce(Return(SequenceNumberSet())); |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1428 .WillOnce(Return(100 * kDefaultTCPMSS)); | 1428 .WillOnce(Return(100 * kDefaultTCPMSS)); |
1429 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); | 1429 EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); |
1430 manager_.SetFromConfig(config); | 1430 manager_.SetFromConfig(config); |
1431 | 1431 |
1432 EXPECT_TRUE(manager_.using_pacing()); | 1432 EXPECT_TRUE(manager_.using_pacing()); |
1433 } | 1433 } |
1434 | 1434 |
1435 } // namespace | 1435 } // namespace |
1436 } // namespace test | 1436 } // namespace test |
1437 } // namespace net | 1437 } // namespace net |
OLD | NEW |