API changes to Write path Session on down for FEC protection.

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"
 #include "net/quic/congestion_control/loss_detection_interface.h"
 #include "net/quic/congestion_control/receive_algorithm_interface.h"
 #include "net/quic/congestion_control/send_algorithm_interface.h"
 #include "net/quic/crypto/null_encrypter.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/mock_random.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_framer_peer.h"
 #include "net/quic/test_tools/quic_packet_creator_peer.h"
-#include "net/quic/test_tools/quic_packet_generator_peer.h"
 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/simple_quic_framer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using std::map;
 using std::vector;
 using testing::AnyNumber;
@@ skipping 418 matching lines @@
         SerializedPacket(sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER,
                          packet, entropy_hash, retransmittable_frames));
   }
 
   QuicConsumedData SendStreamDataWithString(
       QuicStreamId id,
       StringPiece data,
       QuicStreamOffset offset,
       bool fin,
       QuicAckNotifier::DelegateInterface* delegate) {
+    return SendStreamDataWithStringHelper(id, data, offset, fin,
+                                          MAY_FEC_PROTECT, delegate);
+  }
+
+  QuicConsumedData SendStreamDataWithStringWithFec(
+      QuicStreamId id,
+      StringPiece data,
+      QuicStreamOffset offset,
+      bool fin,
+      QuicAckNotifier::DelegateInterface* delegate) {
+    return SendStreamDataWithStringHelper(id, data, offset, fin,
+                                          MUST_FEC_PROTECT, delegate);
+  }
+
+  QuicConsumedData SendStreamDataWithStringHelper(
+      QuicStreamId id,
+      StringPiece data,
+      QuicStreamOffset offset,
+      bool fin,
+      FecProtection fec_protection,
+      QuicAckNotifier::DelegateInterface* delegate) {
     IOVector data_iov;
     if (!data.empty()) {
       data_iov.Append(const_cast<char*>(data.data()), data.size());
     }
-    return QuicConnection::SendStreamData(id, data_iov, offset, fin, delegate);
+    return QuicConnection::SendStreamData(id, data_iov, offset, fin,
+                                          fec_protection, delegate);
   }
 
   QuicConsumedData SendStreamData3() {
     return SendStreamDataWithString(kClientDataStreamId1, "food", 0, !kFin,
                                     NULL);
   }
 
+  QuicConsumedData SendStreamData3WithFec() {
+    return SendStreamDataWithStringWithFec(kClientDataStreamId1, "food", 0,
+                                           !kFin, NULL);
+  }
+
   QuicConsumedData SendStreamData5() {
     return SendStreamDataWithString(kClientDataStreamId2, "food2", 0,
                                     !kFin, NULL);
   }
 
+  QuicConsumedData SendStreamData5WithFec() {
+    return SendStreamDataWithStringWithFec(kClientDataStreamId2, "food2", 0,
+                                           !kFin, NULL);
+  }
   // Ensures the connection can write stream data before writing.
   QuicConsumedData EnsureWritableAndSendStreamData5() {
     EXPECT_TRUE(CanWriteStreamData());
     return SendStreamData5();
   }
 
   // The crypto stream has special semantics so that it is not blocked by a
   // congestion window limitation, and also so that it gets put into a separate
   // packet (so that it is easier to reason about a crypto frame not being
   // split needlessly across packet boundaries).  As a result, we have separate
@@ skipping 962 matching lines @@
   // GetPacketLengthForOneStream() assumes a stream offset of 0 in determining
   // packet length. The size of the offset field in a stream frame is 0 for
   // offset 0, and 2 for non-zero offsets up through 64K. Increase
   // max_packet_length by 2 so that subsequent packets containing subsequent
   // stream frames with non-zero offets will fit within the packet length.
   size_t length = 2 + GetPacketLengthForOneStream(
           connection_.version(), kIncludeVersion, PACKET_1BYTE_SEQUENCE_NUMBER,
           IN_FEC_GROUP, &payload_length);
   creator->set_max_packet_length(length);
 
-  // And send FEC every two packets.
-  QuicPacketGeneratorPeer::SwitchFecProtectionOn(
-      QuicConnectionPeer::GetPacketGenerator(&connection_), 2);
+  // Enable FEC.
+  creator->set_max_packets_per_fec_group(2);
 
-  // Send 4 data packets and 2 FEC packets.
+  // Send 4 protected data packets, which will also trigger 2 FEC packets.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(6);
   // The first stream frame will have 2 fewer overhead bytes than the other 3.
   const string payload(payload_length * 4 + 2, 'a');
-  connection_.SendStreamDataWithString(1, payload, 0, !kFin, NULL);
+  connection_.SendStreamDataWithStringWithFec(1, payload, 0, !kFin, NULL);
   // Expect the FEC group to be closed after SendStreamDataWithString.
-  EXPECT_FALSE(creator->ShouldSendFec(true));
-  EXPECT_TRUE(creator->IsFecProtected());
+  EXPECT_FALSE(creator->IsFecGroupOpen());
+  EXPECT_FALSE(creator->IsFecProtected());
 }
 
 TEST_P(QuicConnectionTest, FECQueueing) {
   // All packets carry version info till version is negotiated.
   size_t payload_length;
   QuicPacketCreator* creator =
       QuicConnectionPeer::GetPacketCreator(&connection_);
   size_t length = GetPacketLengthForOneStream(
       connection_.version(), kIncludeVersion, PACKET_1BYTE_SEQUENCE_NUMBER,
       IN_FEC_GROUP, &payload_length);
   creator->set_max_packet_length(length);
-  // And send FEC every two packets.
-  QuicPacketGeneratorPeer::SwitchFecProtectionOn(
-      QuicConnectionPeer::GetPacketGenerator(&connection_), 1);
+  // Enable FEC.
+  creator->set_max_packets_per_fec_group(1);
 
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
   BlockOnNextWrite();
   const string payload(payload_length, 'a');
-  connection_.SendStreamDataWithString(1, payload, 0, !kFin, NULL);
-  EXPECT_FALSE(creator->ShouldSendFec(true));
-  EXPECT_TRUE(creator->IsFecProtected());
+  connection_.SendStreamDataWithStringWithFec(1, payload, 0, !kFin, NULL);
+  EXPECT_FALSE(creator->IsFecGroupOpen());
+  EXPECT_FALSE(creator->IsFecProtected());
   // Expect the first data packet and the fec packet to be queued.
   EXPECT_EQ(2u, connection_.NumQueuedPackets());
 }
 
 TEST_P(QuicConnectionTest, AbandonFECFromCongestionWindow) {
-  QuicPacketGeneratorPeer::SwitchFecProtectionOn(
-      QuicConnectionPeer::GetPacketGenerator(&connection_), 1);
+  // Enable FEC.
+  QuicConnectionPeer::GetPacketCreator(
+      &connection_)->set_max_packets_per_fec_group(1);
 
   // 1 Data and 1 FEC packet.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
-  connection_.SendStreamDataWithString(3, "foo", 0, !kFin, NULL);
+  connection_.SendStreamDataWithStringWithFec(3, "foo", 0, !kFin, NULL);
 
   const QuicTime::Delta retransmission_time =
       QuicTime::Delta::FromMilliseconds(5000);
   clock_.AdvanceTime(retransmission_time);
 
   // Abandon FEC packet and data packet.
   EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
   EXPECT_CALL(visitor_, OnCanWrite());
   connection_.OnRetransmissionTimeout();
 }
 
 TEST_P(QuicConnectionTest, DontAbandonAckedFEC) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-  QuicPacketGeneratorPeer::SwitchFecProtectionOn(
-      QuicConnectionPeer::GetPacketGenerator(&connection_), 1);
+  // Enable FEC.
+  QuicConnectionPeer::GetPacketCreator(
+      &connection_)->set_max_packets_per_fec_group(1);
 
   // 1 Data and 1 FEC packet.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(6);
-  connection_.SendStreamDataWithString(3, "foo", 0, !kFin, NULL);
+  connection_.SendStreamDataWithStringWithFec(3, "foo", 0, !kFin, NULL);
   // Send some more data afterwards to ensure early retransmit doesn't trigger.
-  connection_.SendStreamDataWithString(3, "foo", 3, !kFin, NULL);
-  connection_.SendStreamDataWithString(3, "foo", 6, !kFin, NULL);
+  connection_.SendStreamDataWithStringWithFec(3, "foo", 3, !kFin, NULL);
+  connection_.SendStreamDataWithStringWithFec(3, "foo", 6, !kFin, NULL);
 
   QuicAckFrame ack_fec = InitAckFrame(2, 1);
   // Data packet missing.
   // TODO(ianswett): Note that this is not a sensible ack, since if the FEC was
   // received, it would cause the covered packet to be acked as well.
   NackPacket(1, &ack_fec);
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   ProcessAckPacket(&ack_fec);
   clock_.AdvanceTime(DefaultRetransmissionTime());
 
   // Don't abandon the acked FEC packet, but it will abandon 2 the subsequent
   // FEC packets.
   EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(3);
   connection_.GetRetransmissionAlarm()->Fire();
 }
 
 TEST_P(QuicConnectionTest, AbandonAllFEC) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-  QuicPacketGeneratorPeer::SwitchFecProtectionOn(
-      QuicConnectionPeer::GetPacketGenerator(&connection_), 1);
+  // Enable FEC.
+  QuicConnectionPeer::GetPacketCreator(
+      &connection_)->set_max_packets_per_fec_group(1);
 
   // 1 Data and 1 FEC packet.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(6);
-  connection_.SendStreamDataWithString(3, "foo", 0, !kFin, NULL);
+  connection_.SendStreamDataWithStringWithFec(3, "foo", 0, !kFin, NULL);
   // Send some more data afterwards to ensure early retransmit doesn't trigger.
-  connection_.SendStreamDataWithString(3, "foo", 3, !kFin, NULL);
+  connection_.SendStreamDataWithStringWithFec(3, "foo", 3, !kFin, NULL);
   // Advance the time so not all the FEC packets are abandoned.
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
-  connection_.SendStreamDataWithString(3, "foo", 6, !kFin, NULL);
+  connection_.SendStreamDataWithStringWithFec(3, "foo", 6, !kFin, NULL);
 
   QuicAckFrame ack_fec = InitAckFrame(5, 1);
   // Ack all data packets, but no fec packets.
   NackPacket(2, &ack_fec);
   NackPacket(4, &ack_fec);
 
   // Lose the first FEC packet and ack the three data packets.
   SequenceNumberSet lost_packets;
   lost_packets.insert(2);
   EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
@@ skipping 85 matching lines @@
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
   EXPECT_FALSE(connection_.HasQueuedData());
 
   // Parse the last packet and ensure it's the stream frame from stream 3.
   EXPECT_EQ(1u, writer_->frame_count());
   ASSERT_EQ(1u, writer_->stream_frames().size());
   EXPECT_EQ(kClientDataStreamId1, writer_->stream_frames()[0].stream_id);
 }
 
 TEST_P(QuicConnectionTest, FramePackingFEC) {
-  // Enable fec.
-  QuicPacketGeneratorPeer::SwitchFecProtectionOn(
-      QuicConnectionPeer::GetPacketGenerator(&connection_), 6);
+  // Enable FEC.
+  QuicConnectionPeer::GetPacketCreator(
+      &connection_)->set_max_packets_per_fec_group(6);
 
   CongestionBlockWrites();
 
-  // Send an ack and two stream frames in 1 packet by queueing them.
+  // Queue an ack and two stream frames. Ack gets flushed when FEC is turned on
+  // for sending protected data; two stream frames are packing in 1 packet.
+  EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(DoAll(
+      IgnoreResult(InvokeWithoutArgs(
+          &connection_, &TestConnection::SendStreamData3WithFec)),
+      IgnoreResult(InvokeWithoutArgs(
+          &connection_, &TestConnection::SendStreamData5WithFec))));
   connection_.SendAck();
-  EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(DoAll(
-      IgnoreResult(InvokeWithoutArgs(&connection_,
-                                     &TestConnection::SendStreamData3)),
-      IgnoreResult(InvokeWithoutArgs(&connection_,
-                                     &TestConnection::SendStreamData5))));
 
-  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(3);
   CongestionUnblockWrites();
   connection_.GetSendAlarm()->Fire();
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
   EXPECT_FALSE(connection_.HasQueuedData());
 
   // Parse the last packet and ensure it's in an fec group.
-  EXPECT_EQ(1u, writer_->header().fec_group);
+  EXPECT_EQ(2u, writer_->header().fec_group);
   EXPECT_EQ(0u, writer_->frame_count());
 }
 
 TEST_P(QuicConnectionTest, FramePackingAckResponse) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   // Process a data packet to queue up a pending ack.
   EXPECT_CALL(visitor_, OnStreamFrames(_)).Times(1);
   ProcessDataPacket(1, 1, kEntropyFlag);
 
   EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(DoAll(
@@ skipping 28 matching lines @@
 
 TEST_P(QuicConnectionTest, FramePackingSendv) {
   // Send data in 1 packet by writing multiple blocks in a single iovector
   // using writev.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
 
   char data[] = "ABCD";
   IOVector data_iov;
   data_iov.AppendNoCoalesce(data, 2);
   data_iov.AppendNoCoalesce(data + 2, 2);
-  connection_.SendStreamData(1, data_iov, 0, !kFin, NULL);
+  connection_.SendStreamData(1, data_iov, 0, !kFin, MAY_FEC_PROTECT, NULL);
 
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
   EXPECT_FALSE(connection_.HasQueuedData());
 
   // Parse the last packet and ensure multiple iovector blocks have
   // been packed into a single stream frame from one stream.
   EXPECT_EQ(1u, writer_->frame_count());
   EXPECT_EQ(1u, writer_->stream_frames().size());
   QuicStreamFrame frame = writer_->stream_frames()[0];
   EXPECT_EQ(1u, frame.stream_id);
   EXPECT_EQ("ABCD", string(static_cast<char*>
                            (frame.data.iovec()[0].iov_base),
                            (frame.data.iovec()[0].iov_len)));
 }
 
 TEST_P(QuicConnectionTest, FramePackingSendvQueued) {
   // Try to send two stream frames in 1 packet by using writev.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
 
   BlockOnNextWrite();
   char data[] = "ABCD";
   IOVector data_iov;
   data_iov.AppendNoCoalesce(data, 2);
   data_iov.AppendNoCoalesce(data + 2, 2);
-  connection_.SendStreamData(1, data_iov, 0, !kFin, NULL);
+  connection_.SendStreamData(1, data_iov, 0, !kFin, MAY_FEC_PROTECT, NULL);
 
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
   EXPECT_TRUE(connection_.HasQueuedData());
 
   // Unblock the writes and actually send.
   writer_->SetWritable();
   connection_.OnCanWrite();
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 
   // Parse the last packet and ensure it's one stream frame from one stream.
   EXPECT_EQ(1u, writer_->frame_count());
   EXPECT_EQ(1u, writer_->stream_frames().size());
   EXPECT_EQ(1u, writer_->stream_frames()[0].stream_id);
 }
 
 TEST_P(QuicConnectionTest, SendingZeroBytes) {
   // Send a zero byte write with a fin using writev.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
   IOVector empty_iov;
-  connection_.SendStreamData(1, empty_iov, 0, kFin, NULL);
+  connection_.SendStreamData(1, empty_iov, 0, kFin, MAY_FEC_PROTECT, NULL);
 
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
   EXPECT_FALSE(connection_.HasQueuedData());
 
   // Parse the last packet and ensure it's one stream frame from one stream.
   EXPECT_EQ(1u, writer_->frame_count());
   EXPECT_EQ(1u, writer_->stream_frames().size());
   EXPECT_EQ(1u, writer_->stream_frames()[0].stream_id);
   EXPECT_TRUE(writer_->stream_frames()[0].fin);
 }
@@ skipping 2197 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