Land Recent QUIC Changes until 03/15/2015.

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 12 matching lines @@
 using testing::StrictMock;
 using testing::_;
 
 namespace net {
 namespace test {
 namespace {
 
 // Default packet length.
 const uint32 kDefaultLength = 1000;
 
+// Stream ID for data sent in CreatePacket().
+const QuicStreamId kStreamId = 7;
+
 // 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 127 matching lines @@
         &manager_, new_sequence_number));
   }
 
   SerializedPacket CreateDataPacket(QuicPacketSequenceNumber sequence_number) {
     return CreatePacket(sequence_number, true);
   }
 
   SerializedPacket CreatePacket(QuicPacketSequenceNumber sequence_number,
                                 bool retransmittable) {
     packets_.push_back(new QuicEncryptedPacket(nullptr, kDefaultLength));
-    return SerializedPacket(
-        sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER, packets_.back(), 0u,
-        retransmittable ? new RetransmittableFrames(ENCRYPTION_NONE) : nullptr);
+    RetransmittableFrames* frames = nullptr;
+    if (retransmittable) {
+      frames = new RetransmittableFrames(ENCRYPTION_NONE);
+      frames->AddStreamFrame(
+          new QuicStreamFrame(kStreamId, false, 0, IOVector()));
+    }
+    return SerializedPacket(sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER,
+                            packets_.back(), 0u, frames);
   }
 
   SerializedPacket CreateFecPacket(QuicPacketSequenceNumber sequence_number) {
     packets_.push_back(new QuicEncryptedPacket(nullptr, kDefaultLength));
     SerializedPacket serialized(sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER,
                                 packets_.back(), 0u, nullptr);
     serialized.is_fec_packet = true;
     return serialized;
   }
 
@@ skipping 120 matching lines @@
 
   // There should no longer be a pending retransmission.
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // No unacked packets remain.
   VerifyUnackedPackets(nullptr, 0);
   VerifyRetransmittablePackets(nullptr, 0);
   EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted);
 }
 
+TEST_F(QuicSentPacketManagerTest, RetransmitThenStopRetransmittingBeforeSend) {
+  SendDataPacket(1);
+  QuicSentPacketManagerPeer::MarkForRetransmission(&manager_, 1,
+                                                   TLP_RETRANSMISSION);
+  EXPECT_TRUE(manager_.HasPendingRetransmissions());
+
+  manager_.CancelRetransmissionsForStream(kStreamId);
+
+  // There should no longer be a pending retransmission.
+  EXPECT_FALSE(manager_.HasPendingRetransmissions());
+
+  QuicPacketSequenceNumber unacked[] = {1};
+  VerifyUnackedPackets(unacked, arraysize(unacked));
+  VerifyRetransmittablePackets(nullptr, 0);
+  EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted);
+}
+
 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPrevious) {
   SendDataPacket(1);
   RetransmitAndSendPacket(1, 2);
   QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
   clock_.AdvanceTime(rtt);
 
   // Ack 1 but not 2.
   ExpectAck(1);
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 1;
@@ skipping 1132 matching lines @@
 #if 0
   options.clear();
   options.push_back(kTBBR);
   QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
   EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
   EXPECT_CALL(*network_change_visitor_, OnRttChange());
   manager_.SetFromConfig(config);
   EXPECT_EQ(kBBR, QuicSentPacketManagerPeer::GetSendAlgorithm(
       manager_)->GetCongestionControlType());
 #endif
+
+  options.clear();
+  options.push_back(kBYTE);
+  QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
+  EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
+  EXPECT_CALL(*network_change_visitor_, OnRttChange());
+  manager_.SetFromConfig(config);
+  EXPECT_EQ(kCubicBytes, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
+                             ->GetCongestionControlType());
+
+  options.clear();
+  options.push_back(kRENO);
+  options.push_back(kBYTE);
+  QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
+  EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
+  EXPECT_CALL(*network_change_visitor_, OnRttChange());
+  manager_.SetFromConfig(config);
+  EXPECT_EQ(kRenoBytes, QuicSentPacketManagerPeer::GetSendAlgorithm(manager_)
+                            ->GetCongestionControlType());
 }
 
 TEST_F(QuicSentPacketManagerTest, NegotiateNumConnectionsFromOptions) {
   QuicConfig config;
   QuicTagVector options;
 
   options.push_back(k1CON);
   QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
   EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
   EXPECT_CALL(*network_change_visitor_, OnRttChange());
@@ skipping 180 matching lines @@
 
   EXPECT_CALL(*send_algorithm_, ResumeConnectionState(_));
   manager_.ResumeConnectionState(cached_network_params);
   EXPECT_EQ(kRttMs * kNumMicrosPerMilli,
             static_cast<uint64>(manager_.GetRttStats()->initial_rtt_us()));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net