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