src/net/quic/quic_sent_packet_manager_test.cc

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