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