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