Change from re-transmitting an packet with a retransmit number to sending a new packet with a new s…

net/quic/quic_connection_test.cc

 // Copyright (c) 2012 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_connection.h"
 
 #include "net/base/net_errors.h"
 #include "net/quic/congestion_control/quic_receipt_metrics_collector.h"
 #include "net/quic/congestion_control/quic_send_scheduler.h"
 #include "net/quic/crypto/quic_encrypter.h"
@@ skipping 151 matching lines @@
   void SetCollector(QuicReceiptMetricsCollector* collector) {
     QuicConnectionPeer::SetCollector(this, collector);
   }
 
   void SetScheduler(QuicSendScheduler* scheduler) {
     QuicConnectionPeer::SetScheduler(this, scheduler);
   }
 
   bool SendPacket(QuicPacketSequenceNumber sequence_number,
                   QuicPacket* packet,
-                  bool resend,
-                  bool force) {
-    return QuicConnection::SendPacket(sequence_number, packet, resend, force);
+                  bool should_resend,
+                  bool force,
+                  bool is_retransmit) {
+    return QuicConnection::SendPacket(
+        sequence_number, packet, should_resend, force, is_retransmit);
   }
 };
 
 class QuicConnectionTest : public ::testing::Test {
  protected:
   QuicConnectionTest()
       : guid_(42),
         framer_(QuicDecrypter::Create(kNULL), QuicEncrypter::Create(kNULL)),
         creator_(guid_, &framer_),
         scheduler_(new MockScheduler()),
@@ skipping 103 matching lines @@
   bool NonRetransmitting(QuicPacketSequenceNumber number) {
     return last_frame()->sent_info.non_retransmiting.find(
         number) !=
         last_frame()->sent_info.non_retransmiting.end();
   }
 
   QuicPacket* ConstructDataPacket(QuicPacketSequenceNumber number,
                                   QuicFecGroupNumber fec_group) {
     header_.guid = guid_;
     header_.packet_sequence_number = number;
-    header_.retransmission_count = 0;
     header_.transmission_time = 0;
     header_.flags = PACKET_FLAGS_NONE;
     header_.fec_group = fec_group;
 
     QuicFrames frames;
     QuicFrame frame(&frame1_);
     frames.push_back(frame);
     QuicPacket* packet = NULL;
-    EXPECT_TRUE(framer_.ConstructFragementDataPacket(header_, frames, &packet));
+    EXPECT_TRUE(framer_.ConstructFrameDataPacket(header_, frames, &packet));
     return packet;
   }
 
   QuicGuid guid_;
   QuicFramer framer_;
   QuicPacketCreator creator_;
 
   MockScheduler* scheduler_;
   MockClock clock_;
   TestConnectionHelper* helper_;
@@ skipping 363 matching lines @@
   ProcessFecProtectedPacket(4, false);
   ProcessFecProtectedPacket(5, true);
 }
 
 TEST_F(QuicConnectionTest, TestResend) {
   // TODO(rch): make this work
   // FLAGS_fake_packet_loss_percentage = 100;
   const uint64 kDefaultResendTimeMs = 500u;
 
   connection_.SendStreamData(1, "foo", 0, false, NULL);
-  EXPECT_EQ(0u, last_header()->retransmission_count);
+  EXPECT_EQ(1u, last_header()->packet_sequence_number);
   EXPECT_EQ(0u, last_header()->transmission_time);
   EXPECT_EQ(1u, helper_->resend_alarms().size());
   EXPECT_EQ(kDefaultResendTimeMs * 1000,
             helper_->resend_alarms().find(1)->second);
   // Simulate the resend alarm firing
   clock_.AdvanceTimeInMicroseconds(kDefaultResendTimeMs * 1000);
   connection_.MaybeResendPacket(1);
-  EXPECT_EQ(1u, last_header()->retransmission_count);
+  EXPECT_EQ(2u, last_header()->packet_sequence_number);
   EXPECT_EQ(kDefaultResendTimeMs * 1000,
             last_header()->transmission_time);
 }
 
-
 TEST_F(QuicConnectionTest, TestQueued) {
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
   helper_->set_blocked(true);
   connection_.SendStreamData(1, "foo", 0, false, NULL);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 
   // Attempt to send all packets, but since we're actually still
   // blocked, they should all remain queued.
   EXPECT_FALSE(connection_.OnCanWrite());
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
@@ skipping 84 matching lines @@
   EXPECT_EQ(kDefaultTimeout + 5000, helper_->timeout_alarm());
 
   // This time, we should time out.
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_CONNECTION_TIMED_OUT, false));
   clock_.AdvanceTimeInMicroseconds(5000);
   EXPECT_EQ(kDefaultTimeout + 5000, clock_.NowInUsec());
   EXPECT_TRUE(connection_.CheckForTimeout());
   EXPECT_FALSE(connection_.connected());
 }
 
+// TODO(ianswett): Add scheduler tests when resend is false.
 TEST_F(QuicConnectionTest, SendScheduler) {
   // Test that if we send a packet without delay, it is not queued.
   scoped_ptr<QuicPacket> packet(ConstructDataPacket(1, 0));
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(0));
-  connection_.SendPacket(1, packet.get(), true, false);
+  connection_.SendPacket(1, packet.get(), true, false, false);
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
 
 TEST_F(QuicConnectionTest, SendSchedulerDelay) {
   // Test that if we send a packet with a delay, it ends up queued.
   scoped_ptr<QuicPacket> packet(ConstructDataPacket(1, 0));
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(1));
   EXPECT_CALL(*scheduler_, SentPacket(1, _, _)).Times(0);
-  connection_.SendPacket(1, packet.get(), true, false);
+  connection_.SendPacket(1, packet.get(), true, false, false);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 }
 
 TEST_F(QuicConnectionTest, SendSchedulerForce) {
   // Test that if we force send a packet, it is not queued.
   scoped_ptr<QuicPacket> packet(ConstructDataPacket(1, 0));
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).Times(0);
-  connection_.SendPacket(1, packet.get(), true, true);
+  connection_.SendPacket(1, packet.get(), true, true, false);
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
 
 TEST_F(QuicConnectionTest, SendSchedulerEAGAIN) {
   scoped_ptr<QuicPacket> packet(ConstructDataPacket(1, 0));
   helper_->set_blocked(true);
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(0));
   EXPECT_CALL(*scheduler_, SentPacket(1, _, _)).Times(0);
-  connection_.SendPacket(1, packet.get(), true, false);
+  connection_.SendPacket(1, packet.get(), true, false, false);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 }
 
 TEST_F(QuicConnectionTest, SendSchedulerDelayThenSend) {
   // Test that if we send a packet with a delay, it ends up queued.
   scoped_ptr<QuicPacket> packet(ConstructDataPacket(1, 0));
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(1));
-  connection_.SendPacket(1, packet.get(), true, false);
+  connection_.SendPacket(1, packet.get(), true, false, false);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 
   // Advance the clock to fire the alarm, and configure the scheduler
   // to permit the packet to be sent.
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(0));
   clock_.AdvanceTimeInMicroseconds(1);
   connection_.OnCanWrite();
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
 
+TEST_F(QuicConnectionTest, SendSchedulerDelayThenRetransmit) {
+  // Test that if we send a retransmit with a delay, it ends up queued.
+  scoped_ptr<QuicPacket> packet(ConstructDataPacket(1, 0));
+  EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(1));
+  connection_.SendPacket(1, packet.get(), true, false, true);
+  EXPECT_EQ(1u, connection_.NumQueuedPackets());
+
+  // Advance the clock to fire the alarm, and configure the scheduler
+  // to permit the packet to be sent.
+  EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(0));
+  clock_.AdvanceTimeInMicroseconds(1);
+
+  // Ensure the scheduler is notified this is a retransmit.
+  EXPECT_CALL(*scheduler_, SentPacket(1, _, true));
+  clock_.AdvanceTimeInMicroseconds(1);
+  connection_.OnCanWrite();
+  EXPECT_EQ(0u, connection_.NumQueuedPackets());
+}
+
 TEST_F(QuicConnectionTest, SendSchedulerDelayAndQueue) {
   scoped_ptr<QuicPacket> packet(ConstructDataPacket(1, 0));
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(1));
-  connection_.SendPacket(1, packet.get(), true, false);
+  connection_.SendPacket(1, packet.get(), true, false, false);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 
   // Attempt to send another packet and make sure that it gets queued.
-  connection_.SendPacket(2, packet.get(), true, false);
+  connection_.SendPacket(2, packet.get(), true, false, false);
   EXPECT_EQ(2u, connection_.NumQueuedPackets());
 }
 
 TEST_F(QuicConnectionTest, SendSchedulerDelayThenAckAndSend) {
   scoped_ptr<QuicPacket> packet(ConstructDataPacket(1, 0));
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(10));
-  connection_.SendPacket(1, packet.get(), true, false);
+  connection_.SendPacket(1, packet.get(), true, false, false);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 
   // Now send non-retransmitting information, that we're not going to resend 3.
   // The far end should stop waiting for it.
   QuicAckFrame frame(0, 0, 1);
   frame.sent_info.non_retransmiting.insert(3);
   EXPECT_CALL(*scheduler_, OnIncomingAckFrame(testing::_));
   EXPECT_CALL(*scheduler_, TimeUntilSend(true))
       .WillRepeatedly(testing::Return(0));
   SendAckPacket(&frame);
 
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
   // Ensure alarm is not set
   EXPECT_FALSE(helper_->IsSendAlarmSet());
 }
 
 TEST_F(QuicConnectionTest, SendSchedulerDelayThenAckAndHold) {
   scoped_ptr<QuicPacket> packet(ConstructDataPacket(1, 0));
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(10));
-  connection_.SendPacket(1, packet.get(), true, false);
+  connection_.SendPacket(1, packet.get(), true, false, false);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 
   // Now send non-resending information, that we're not going to resend 3.
   // The far end should stop waiting for it.
   QuicAckFrame frame(0, 0, 1);
   frame.sent_info.non_retransmiting.insert(3);
   EXPECT_CALL(*scheduler_, OnIncomingAckFrame(testing::_));
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(1));
   SendAckPacket(&frame);
 
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 }
 
 TEST_F(QuicConnectionTest, SendSchedulerDelayThenOnCanWrite) {
   scoped_ptr<QuicPacket> packet(ConstructDataPacket(1, 0));
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(10));
-  connection_.SendPacket(1, packet.get(), true, false);
+  connection_.SendPacket(1, packet.get(), true, false, false);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 
   // OnCanWrite should not send the packet (because of the delay)
   // but should still return true.
   EXPECT_TRUE(connection_.OnCanWrite());
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net