Adds plumbing for QUIC early connection migration. No behavior change.

net/quic/quic_sent_packet_manager_test.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_sent_packet_manager.h"
 
 #include "base/stl_util.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/test_tools/quic_config_peer.h"
 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
@@ skipping 15 matching lines @@
 namespace net {
 namespace test {
 namespace {
 
 // Default packet length.
 const uint32_t kDefaultLength = 1000;
 
 // Stream ID for data sent in CreatePacket().
 const QuicStreamId kStreamId = 7;
 
+// Minimum number of consecutive RTOs before path is considered to be degrading.
+const size_t kMinTimeoutsBeforePathDegrading = 2;
+
 // Matcher to check the key of the key-value pair it receives as first argument
 // equals its second argument.
 MATCHER(KeyEq, "") {
   return std::tr1::get<0>(arg).first == std::tr1::get<1>(arg);
 }
 
 class MockDebugDelegate : public QuicSentPacketManager::DebugDelegate {
  public:
   MOCK_METHOD2(OnSpuriousPacketRetransmission,
                void(TransmissionType transmission_type,
@@ skipping 1117 matching lines @@
   SendDataPacket(1);
 
   manager_.OnRetransmissionTimeout();
   EXPECT_TRUE(manager_.HasPendingRetransmissions());
   EXPECT_EQ(kDefaultLength,
             QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
   RetransmitNextPacket(2);
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // Rto a second time.
+  EXPECT_CALL(*network_change_visitor_, OnPathDegrading());
   manager_.OnRetransmissionTimeout();
   EXPECT_TRUE(manager_.HasPendingRetransmissions());
   EXPECT_EQ(2 * kDefaultLength,
             QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
   RetransmitNextPacket(3);
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // Ack a retransmission and ensure OnRetransmissionTimeout is called.
   EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
   QuicAckFrame ack_frame;
@@ skipping 13 matching lines @@
   SendDataPacket(1);
 
   manager_.OnRetransmissionTimeout();
   EXPECT_TRUE(manager_.HasPendingRetransmissions());
   EXPECT_EQ(kDefaultLength,
             QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
   RetransmitNextPacket(2);
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // Rto a second time.
+  EXPECT_CALL(*network_change_visitor_, OnPathDegrading());
   manager_.OnRetransmissionTimeout();
   EXPECT_TRUE(manager_.HasPendingRetransmissions());
   EXPECT_EQ(2 * kDefaultLength,
             QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
   RetransmitNextPacket(3);
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // Ack a retransmission and ensure OnRetransmissionTimeout is called.
   EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
   QuicAckFrame ack_frame;
   ack_frame.ack_delay_time = QuicTime::Delta::Zero();
   ack_frame.largest_observed = 3;
   ack_frame.missing_packets.Add(1, 3);
   ExpectAck(3);
   manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   // The first two packets should still be outstanding.
   EXPECT_EQ(2 * kDefaultLength,
             QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
 }
 
+TEST_F(QuicSentPacketManagerTest, OnPathDegrading) {
+  SendDataPacket(1);
+  QuicTime::Delta delay = QuicTime::Delta::FromMilliseconds(500);
+  EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
+      .WillRepeatedly(Return(delay));
+  for (size_t i = 1; i < kMinTimeoutsBeforePathDegrading; ++i) {
+    manager_.OnRetransmissionTimeout();
+    RetransmitNextPacket(i + 2);
+  }
+  // Next RTO should cause network_change_visitor_'s OnPathDegrading method
+  // to be called.
+  EXPECT_CALL(*network_change_visitor_, OnPathDegrading());
+  manager_.OnRetransmissionTimeout();
+}
+
 TEST_F(QuicSentPacketManagerTest, GetTransmissionTime) {
   EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
 }
 
 TEST_F(QuicSentPacketManagerTest, GetTransmissionTimeCryptoHandshake) {
   SendCryptoPacket(1);
 
   // Check the min.
   RttStats* rtt_stats = QuicSentPacketManagerPeer::GetRttStats(&manager_);
   rtt_stats->set_initial_rtt_us(1 * kNumMicrosPerMilli);
@@ skipping 113 matching lines @@
 }
 
 TEST_F(QuicSentPacketManagerTest, GetTransmissionDelayMin) {
   SendDataPacket(1);
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
       .WillRepeatedly(Return(QuicTime::Delta::FromMilliseconds(1)));
   QuicTime::Delta delay = QuicTime::Delta::FromMilliseconds(200);
 
   // If the delay is smaller than the min, ensure it exponentially backs off
   // from the min.
+  EXPECT_CALL(*network_change_visitor_, OnPathDegrading());
   for (int i = 0; i < 5; ++i) {
     EXPECT_EQ(delay,
               QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
     delay = delay.Add(delay);
     manager_.OnRetransmissionTimeout();
     RetransmitNextPacket(i + 2);
   }
 }
 
 TEST_F(QuicSentPacketManagerTest, GetTransmissionDelayMax) {
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
       .WillOnce(Return(QuicTime::Delta::FromSeconds(500)));
 
   EXPECT_EQ(QuicTime::Delta::FromSeconds(60),
             QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
 }
 
 TEST_F(QuicSentPacketManagerTest, GetTransmissionDelay) {
   SendDataPacket(1);
   QuicTime::Delta delay = QuicTime::Delta::FromMilliseconds(500);
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
       .WillRepeatedly(Return(delay));
 
   // Delay should back off exponentially.
+  EXPECT_CALL(*network_change_visitor_, OnPathDegrading());
   for (int i = 0; i < 5; ++i) {
     EXPECT_EQ(delay,
               QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
     delay = delay.Add(delay);
     manager_.OnRetransmissionTimeout();
     RetransmitNextPacket(i + 2);
   }
 }
 
 TEST_F(QuicSentPacketManagerTest, GetLossDelay) {
@@ skipping 301 matching lines @@
 
   EXPECT_CALL(*send_algorithm_, ResumeConnectionState(_, false));
   manager_.ResumeConnectionState(cached_network_params, false);
   EXPECT_EQ(kRttMs * kNumMicrosPerMilli,
             static_cast<uint64_t>(manager_.GetRttStats()->initial_rtt_us()));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net