Revert of Landing Recent QUIC Changes.

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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "net/base/net_errors.h"
@@ skipping 715 matching lines @@
                                   bool entropy_flag,
                                   EncryptionLevel level) {
     scoped_ptr<QuicPacket> packet(ConstructDataPacket(number, fec_group,
                                                       entropy_flag));
     scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket(
         level, number, *packet));
     connection_.ProcessUdpPacket(IPEndPoint(), IPEndPoint(), *encrypted);
     return encrypted->length();
   }
 
-  void ProcessPingPacket(QuicPacketSequenceNumber number) {
-    scoped_ptr<QuicPacket> packet(ConstructPingPacket(number));
-    scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket(
-        ENCRYPTION_NONE, number, *packet));
-    connection_.ProcessUdpPacket(IPEndPoint(), IPEndPoint(), *encrypted);
-  }
-
   void ProcessClosePacket(QuicPacketSequenceNumber number,
                           QuicFecGroupNumber fec_group) {
     scoped_ptr<QuicPacket> packet(ConstructClosePacket(number, fec_group));
     scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket(
         ENCRYPTION_NONE, number, *packet));
     connection_.ProcessUdpPacket(IPEndPoint(), IPEndPoint(), *encrypted);
   }
 
   size_t ProcessFecProtectedPacket(QuicPacketSequenceNumber number,
                                    bool expect_revival, bool entropy_flag) {
@@ skipping 115 matching lines @@
     header_.fec_flag = false;
     header_.packet_sequence_number = number;
     header_.is_in_fec_group = fec_group == 0u ? NOT_IN_FEC_GROUP : IN_FEC_GROUP;
     header_.fec_group = fec_group;
 
     QuicFrames frames;
     QuicFrame frame(&frame1_);
     frames.push_back(frame);
     QuicPacket* packet =
         BuildUnsizedDataPacket(&framer_, header_, frames).packet;
-    EXPECT_TRUE(packet != NULL);
-    return packet;
-  }
-
-  QuicPacket* ConstructPingPacket(QuicPacketSequenceNumber number) {
-    header_.public_header.connection_id = connection_id_;
-    header_.packet_sequence_number = number;
-    header_.public_header.reset_flag = false;
-    header_.public_header.version_flag = false;
-    header_.entropy_flag = false;
-    header_.fec_flag = false;
-    header_.is_in_fec_group = NOT_IN_FEC_GROUP;
-    header_.fec_group = 0;
-
-    QuicPingFrame ping;
-
-    QuicFrames frames;
-    QuicFrame frame(&ping);
-    frames.push_back(frame);
-    QuicPacket* packet =
-        BuildUnsizedDataPacket(&framer_, header_, frames).packet;
     EXPECT_TRUE(packet != NULL);
     return packet;
   }
 
   QuicPacket* ConstructClosePacket(QuicPacketSequenceNumber number,
                                    QuicFecGroupNumber fec_group) {
     header_.public_header.connection_id = connection_id_;
     header_.packet_sequence_number = number;
     header_.public_header.reset_flag = false;
     header_.public_header.version_flag = false;
@@ skipping 484 matching lines @@
       Return(kMaxPacketSize * 256 * 256 * 256 * 256));
 
   SendStreamDataToPeer(1, "foo", 12, !kFin, &last_packet);
   EXPECT_EQ(5u, last_packet);
   EXPECT_EQ(PACKET_6BYTE_SEQUENCE_NUMBER,
             creator->next_sequence_number_length());
   EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER,
             writer_->header().public_header.sequence_number_length);
 }
 
-// TODO(ianswett): Re-enable this test by finding a good way to test different
-// sequence number lengths without sending packets with giant gaps.
-TEST_P(QuicConnectionTest,
-       DISABLED_SendingDifferentSequenceNumberLengthsUnackedDelta) {
+TEST_P(QuicConnectionTest, SendingDifferentSequenceNumberLengthsUnackedDelta) {
   QuicPacketSequenceNumber last_packet;
   QuicPacketCreator* creator =
       QuicConnectionPeer::GetPacketCreator(&connection_);
   SendStreamDataToPeer(1, "foo", 0, !kFin, &last_packet);
   EXPECT_EQ(1u, last_packet);
   EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
             creator->next_sequence_number_length());
   EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
             writer_->header().public_header.sequence_number_length);
 
@@ skipping 1318 matching lines @@
   EXPECT_EQ(default_timeout.Add(QuicTime::Delta::FromMilliseconds(5)),
             clock_.ApproximateNow());
   connection_.GetTimeoutAlarm()->Fire();
   EXPECT_FALSE(connection_.GetTimeoutAlarm()->IsSet());
   EXPECT_FALSE(connection_.connected());
 }
 
 TEST_P(QuicConnectionTest, SendScheduler) {
   // Test that if we send a packet without delay, it is not queued.
   QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
+  EXPECT_CALL(*send_algorithm_,
+              TimeUntilSend(_, _, _)).WillOnce(
+                  testing::Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
   connection_.SendPacket(
       ENCRYPTION_NONE, 1, packet, kTestEntropyHash, HAS_RETRANSMITTABLE_DATA);
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
 
-TEST_P(QuicConnectionTest, SendSchedulerEAGAIN) {
+TEST_P(QuicConnectionTest, SendSchedulerDelay) {
+  // Test that if we send a packet with a delay, it ends up queued.
   QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
-  BlockOnNextWrite();
+  EXPECT_CALL(*send_algorithm_,
+              TimeUntilSend(_, _, _)).WillOnce(
+                  testing::Return(QuicTime::Delta::FromMicroseconds(1)));
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 1, _, _)).Times(0);
   connection_.SendPacket(
       ENCRYPTION_NONE, 1, packet, kTestEntropyHash, HAS_RETRANSMITTABLE_DATA);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 }
 
+TEST_P(QuicConnectionTest, SendSchedulerEAGAIN) {
+  QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
+  BlockOnNextWrite();
+  EXPECT_CALL(*send_algorithm_,
+              TimeUntilSend(_, _, _)).WillOnce(
+                  testing::Return(QuicTime::Delta::Zero()));
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 1, _, _)).Times(0);
+  connection_.SendPacket(
+      ENCRYPTION_NONE, 1, packet, kTestEntropyHash, HAS_RETRANSMITTABLE_DATA);
+  EXPECT_EQ(1u, connection_.NumQueuedPackets());
+}
+
+TEST_P(QuicConnectionTest, SendSchedulerDelayThenSend) {
+  // Test that if we send a packet with a delay, it ends up queued.
+  QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
+  EXPECT_CALL(*send_algorithm_,
+              TimeUntilSend(_, _, _)).WillOnce(
+                  testing::Return(QuicTime::Delta::FromMicroseconds(1)));
+  connection_.SendPacket(
+       ENCRYPTION_NONE, 1, packet, kTestEntropyHash, HAS_RETRANSMITTABLE_DATA);
+  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(*send_algorithm_,
+              TimeUntilSend(_, _, _)).WillRepeatedly(
+                  testing::Return(QuicTime::Delta::Zero()));
+  clock_.AdvanceTime(QuicTime::Delta::FromMicroseconds(1));
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
+  connection_.GetSendAlarm()->Fire();
+  EXPECT_EQ(0u, connection_.NumQueuedPackets());
+}
+
+TEST_P(QuicConnectionTest, SendSchedulerDelayThenRetransmit) {
+  CongestionUnblockWrites();
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 1, _, _));
+  connection_.SendStreamDataWithString(3, "foo", 0, !kFin, NULL);
+  EXPECT_EQ(0u, connection_.NumQueuedPackets());
+  // Advance the time for retransmission of lost packet.
+  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(501));
+  // Test that if we send a retransmit with a delay, it ends up queued in the
+  // sent packet manager, but not yet serialized.
+  EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
+  CongestionBlockWrites();
+  connection_.GetRetransmissionAlarm()->Fire();
+  EXPECT_EQ(0u, connection_.NumQueuedPackets());
+
+  // Advance the clock to fire the alarm, and configure the scheduler
+  // to permit the packet to be sent.
+  CongestionUnblockWrites();
+
+  // Ensure the scheduler is notified this is a retransmit.
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
+  clock_.AdvanceTime(QuicTime::Delta::FromMicroseconds(1));
+  connection_.GetSendAlarm()->Fire();
+  EXPECT_EQ(0u, connection_.NumQueuedPackets());
+}
+
+TEST_P(QuicConnectionTest, SendSchedulerDelayAndQueue) {
+  QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
+  EXPECT_CALL(*send_algorithm_,
+              TimeUntilSend(_, _, _)).WillOnce(
+                  testing::Return(QuicTime::Delta::FromMicroseconds(1)));
+  connection_.SendPacket(
+      ENCRYPTION_NONE, 1, packet, kTestEntropyHash, HAS_RETRANSMITTABLE_DATA);
+  EXPECT_EQ(1u, connection_.NumQueuedPackets());
+
+  // Attempt to send another packet and make sure that it gets queued.
+  packet = ConstructDataPacket(2, 0, !kEntropyFlag);
+  connection_.SendPacket(
+      ENCRYPTION_NONE, 2, packet, kTestEntropyHash, HAS_RETRANSMITTABLE_DATA);
+  EXPECT_EQ(2u, connection_.NumQueuedPackets());
+}
+
+TEST_P(QuicConnectionTest, SendSchedulerDelayThenAckAndSend) {
+  EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
+  QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
+  EXPECT_CALL(*send_algorithm_,
+              TimeUntilSend(_, _, _)).WillOnce(
+                  testing::Return(QuicTime::Delta::FromMicroseconds(10)));
+  connection_.SendPacket(
+      ENCRYPTION_NONE, 1, packet, kTestEntropyHash, HAS_RETRANSMITTABLE_DATA);
+  EXPECT_EQ(1u, connection_.NumQueuedPackets());
+
+  // Now send non-retransmitting information, that we're not going to
+  // retransmit 3. The far end should stop waiting for it.
+  QuicAckFrame frame = InitAckFrame(0);
+  EXPECT_CALL(*send_algorithm_,
+              TimeUntilSend(_, _, _)).WillRepeatedly(
+                  testing::Return(QuicTime::Delta::Zero()));
+  EXPECT_CALL(*send_algorithm_,
+              OnPacketSent(_, _, _, _, _));
+  ProcessAckPacket(&frame);
+
+  EXPECT_EQ(0u, connection_.NumQueuedPackets());
+  // Ensure alarm is not set
+  EXPECT_FALSE(connection_.GetSendAlarm()->IsSet());
+}
+
+TEST_P(QuicConnectionTest, SendSchedulerDelayThenAckAndHold) {
+  EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
+  QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
+  EXPECT_CALL(*send_algorithm_,
+              TimeUntilSend(_, _, _)).WillOnce(
+                  testing::Return(QuicTime::Delta::FromMicroseconds(10)));
+  connection_.SendPacket(
+      ENCRYPTION_NONE, 1, packet, kTestEntropyHash, HAS_RETRANSMITTABLE_DATA);
+  EXPECT_EQ(1u, connection_.NumQueuedPackets());
+
+  // Now send non-retransmitting information, that we're not going to
+  // retransmit 3.  The far end should stop waiting for it.
+  QuicAckFrame frame = InitAckFrame(0);
+  EXPECT_CALL(*send_algorithm_,
+              TimeUntilSend(_, _, _)).WillOnce(
+                  testing::Return(QuicTime::Delta::FromMicroseconds(1)));
+  ProcessAckPacket(&frame);
+
+  EXPECT_EQ(1u, connection_.NumQueuedPackets());
+}
+
+TEST_P(QuicConnectionTest, SendSchedulerDelayThenOnCanWrite) {
+  // TODO(ianswett): This test is unrealistic, because we would not serialize
+  // new data if the send algorithm said not to.
+  QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
+  CongestionBlockWrites();
+  connection_.SendPacket(
+      ENCRYPTION_NONE, 1, packet, kTestEntropyHash, HAS_RETRANSMITTABLE_DATA);
+  EXPECT_EQ(1u, connection_.NumQueuedPackets());
+
+  // OnCanWrite should send the packet, because it won't consult the send
+  // algorithm for queued packets.
+  connection_.OnCanWrite();
+  EXPECT_EQ(0u, connection_.NumQueuedPackets());
+}
+
 TEST_P(QuicConnectionTest, TestQueueLimitsOnSendStreamData) {
   // All packets carry version info till version is negotiated.
   size_t payload_length;
   size_t length = GetPacketLengthForOneStream(
       connection_.version(), kIncludeVersion, PACKET_1BYTE_SEQUENCE_NUMBER,
       NOT_IN_FEC_GROUP, &payload_length);
   QuicConnectionPeer::GetPacketCreator(&connection_)->set_max_packet_length(
       length);
 
   // Queue the first packet.
@@ skipping 80 matching lines @@
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   ProcessPacket(1);
   ProcessPacket(2);
   // Check that ack is sent and that delayed ack alarm is reset.
   EXPECT_EQ(2u, writer_->frame_count());
   EXPECT_FALSE(writer_->stop_waiting_frames().empty());
   EXPECT_FALSE(writer_->ack_frames().empty());
   EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
 }
 
-TEST_P(QuicConnectionTest, SendDelayedAckForPing) {
-  if (version() < QUIC_VERSION_18) {
-    return;
-  }
-  EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-  EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-  ProcessPingPacket(1);
-  EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
-}
-
 TEST_P(QuicConnectionTest, NoAckOnOldNacks) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   // Drop one packet, triggering a sequence of acks.
   ProcessPacket(2);
   size_t frames_per_ack = 2;
   EXPECT_EQ(frames_per_ack, writer_->frame_count());
   EXPECT_FALSE(writer_->ack_frames().empty());
   writer_->Reset();
   ProcessPacket(3);
   EXPECT_EQ(frames_per_ack, writer_->frame_count());
@@ skipping 983 matching lines @@
   QuicBlockedFrame blocked;
   blocked.stream_id = 3;
   EXPECT_CALL(visitor_, OnBlockedFrames(_));
   ProcessFramePacket(QuicFrame(&blocked));
   EXPECT_TRUE(ack_alarm->IsSet());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net