Land Recent QUIC Changes.

net/quic/quic_packet_creator_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_packet_creator.h"
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/null_encrypter.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
@@ skipping 101 matching lines @@
         client_framer_.GetMaxPlaintextSize(
             creator_.options()->max_packet_length);
   }
 
   // Returns the number of bytes consumed by the non-data fields of a stream
   // frame, assuming it is the last frame in the packet
   size_t GetStreamFrameOverhead(InFecGroup is_in_fec_group) {
     return QuicFramer::GetMinStreamFrameSize(
         client_framer_.version(), kStreamId, kOffset, true, is_in_fec_group);
   }
-
   static const QuicStreamId kStreamId = 1u;
   static const QuicStreamOffset kOffset = 1u;
 
   QuicFrames frames_;
   QuicFramer server_framer_;
   QuicFramer client_framer_;
   testing::StrictMock<MockFramerVisitor> framer_visitor_;
   QuicPacketSequenceNumber sequence_number_;
   QuicConnectionId connection_id_;
   string data_;
   MockRandom mock_random_;
   QuicPacketCreator creator_;
 };
 
 // Run all packet creator tests with all supported versions of QUIC, and with
 // and without version in the packet header.
 INSTANTIATE_TEST_CASE_P(QuicPacketCreatorTests,
                         QuicPacketCreatorTest,
                         ::testing::ValuesIn(GetTestParams()));
 
-
 TEST_P(QuicPacketCreatorTest, SerializeFrames) {
   frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u, 0u))));
   frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
   frames_.push_back(QuicFrame(new QuicStreamFrame(0u, true, 0u, IOVector())));
   SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
   delete frames_[0].ack_frame;
   delete frames_[1].stream_frame;
   delete frames_[2].stream_frame;
 
   {
     InSequence s;
     EXPECT_CALL(framer_visitor_, OnPacket());
     EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
     EXPECT_CALL(framer_visitor_, OnAckFrame(_));
     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
   ProcessPacket(serialized.packet);
   delete serialized.packet;
 }
 
 TEST_P(QuicPacketCreatorTest, SerializeWithFEC) {
-  creator_.options()->max_packets_per_fec_group = 6;
+  // Enable FEC protection, and send FEC packet every 6 packets.
+  EXPECT_TRUE(QuicPacketCreatorPeer::SwitchFecProtectionOn(&creator_, 6));
   // Should return false since we do not have enough packets in the FEC group to
   // trigger an FEC packet.
   ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
 
   frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
   SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
   delete frames_[0].stream_frame;
 
   {
     InSequence s;
@@ skipping 71 matching lines @@
   }
   ProcessPacket(serialized.packet);
   delete serialized.packet;
 }
 
 TEST_P(QuicPacketCreatorTest, SerializeWithFECChangingSequenceNumberLength) {
   // Test goal is to test the following sequence (P1 => generate Packet 1):
   // P1 <change seq num length> P2 FEC,
   // and we expect that sequence number length should not change until the end
   // of the open FEC group.
-  creator_.options()->max_packets_per_fec_group = 6;
+
+  // Enable FEC protection, and send FEC packet every 6 packets.
+  EXPECT_TRUE(QuicPacketCreatorPeer::SwitchFecProtectionOn(&creator_, 6));
   // Should return false since we do not have enough packets in the FEC group to
   // trigger an FEC packet.
   ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
   frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u, 0u))));
 
   // Generate Packet 1.
   creator_.AddSavedFrame(frames_[0]);
   // Change the sequence number length mid-FEC group and it should not change.
   creator_.options()->send_sequence_number_length =
       PACKET_4BYTE_SEQUENCE_NUMBER;
@@ skipping 111 matching lines @@
   EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
   EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
   EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
   EXPECT_CALL(framer_visitor_, OnConnectionCloseFrame(_));
   EXPECT_CALL(framer_visitor_, OnPacketComplete());
 
   ProcessPacket(serialized.packet);
   delete serialized.packet;
 }
 
+TEST_P(QuicPacketCreatorTest, SwitchFecOnOffWithNoGroup) {
+  // Enable FEC protection.
+  creator_.set_max_packets_per_fec_group(6);
+  EXPECT_TRUE(creator_.IsFecEnabled());
+  EXPECT_FALSE(creator_.IsFecProtected());
+
+  // Turn on FEC protection.
+  creator_.StartFecProtectingPackets();
+  EXPECT_TRUE(creator_.IsFecProtected());
+  // We have no packets in the FEC group, so no FEC packet can be created.
+  EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/true));
+  // Since no packets are in FEC group yet, we should be able to turn FEC
+  // off with no trouble.
+  creator_.StopFecProtectingPackets();
+  EXPECT_FALSE(creator_.IsFecProtected());
+}
+
+TEST_P(QuicPacketCreatorTest, SwitchFecOnOffWithGroupInProgress) {
+  // Enable FEC protection, and send FEC packet every 6 packets.
+  EXPECT_TRUE(QuicPacketCreatorPeer::SwitchFecProtectionOn(&creator_, 6));
+  frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
+  SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
+  delete frames_[0].stream_frame;
+  delete serialized.packet;
+
+  EXPECT_TRUE(creator_.IsFecProtected());
+  // We do not have enough packets in the FEC group to trigger an FEC packet.
+  EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
+  // Should return true since there are packets in the FEC group.
+  EXPECT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
+
+  // Switching FEC off should not change creator state, since there is an
+  // FEC packet under construction.
+  EXPECT_DFATAL(creator_.StopFecProtectingPackets(),
+                "Cannot stop FEC protection with open FEC group.");
+  EXPECT_TRUE(creator_.IsFecProtected());
+  // Confirm that FEC packet is still under construction.
+  EXPECT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
+
+  serialized = creator_.SerializeFec();
+  delete serialized.packet;
+
+  // Switching FEC on/off should work now.
+  creator_.StopFecProtectingPackets();
+  EXPECT_FALSE(creator_.IsFecProtected());
+  creator_.StartFecProtectingPackets();
+  EXPECT_TRUE(creator_.IsFecProtected());
+}
+
+TEST_P(QuicPacketCreatorTest, SwitchFecOnWithStreamFrameQueued) {
+  // Add a stream frame to the creator.
+  QuicFrame frame;
+  size_t consumed = creator_.CreateStreamFrame(
+      1u, MakeIOVector("test"), 0u, false, &frame);
+  EXPECT_EQ(4u, consumed);
+  ASSERT_TRUE(frame.stream_frame);
+  EXPECT_TRUE(creator_.AddSavedFrame(frame));
+  EXPECT_TRUE(creator_.HasPendingFrames());
+
+   // Enable FEC protection, and send FEC packet every 6 packets.
+  creator_.set_max_packets_per_fec_group(6);
+  EXPECT_TRUE(creator_.IsFecEnabled());
+  EXPECT_DFATAL(creator_.StartFecProtectingPackets(),
+                "Cannot start FEC protection with pending frames.");
+  EXPECT_FALSE(creator_.IsFecProtected());
+
+  // Serialize packet for transmission.
+  SerializedPacket serialized = creator_.SerializePacket();
+  delete serialized.packet;
+  delete serialized.retransmittable_frames;
+  EXPECT_FALSE(creator_.HasPendingFrames());
+
+  // Since all pending frames have been serialized, turning FEC on should work.
+  creator_.StartFecProtectingPackets();
+  EXPECT_TRUE(creator_.IsFecProtected());
+}
+
 TEST_P(QuicPacketCreatorTest, CreateStreamFrame) {
   QuicFrame frame;
   size_t consumed = creator_.CreateStreamFrame(1u, MakeIOVector("test"), 0u,
                                                false, &frame);
   EXPECT_EQ(4u, consumed);
   CheckStreamFrame(frame, 1u, "test", 0u, false);
   delete frame.stream_frame;
 }
 
 TEST_P(QuicPacketCreatorTest, CreateStreamFrameFin) {
@@ skipping 58 matching lines @@
     size_t expected_bytes_free = bytes_free < 3 ? 0 : bytes_free - 2;
     EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta;
     SerializedPacket serialized_packet = creator_.SerializePacket();
     ASSERT_TRUE(serialized_packet.packet);
     delete serialized_packet.packet;
     delete serialized_packet.retransmittable_frames;
   }
 }
 
 TEST_P(QuicPacketCreatorTest, StreamFrameConsumptionWithFec) {
-  // Turn on FEC protection.
-  creator_.options()->max_packets_per_fec_group = 6;
+  // Enable FEC protection, and send FEC packet every 6 packets.
+  EXPECT_TRUE(QuicPacketCreatorPeer::SwitchFecProtectionOn(&creator_, 6));
   // Compute the total overhead for a single frame in packet.
   const size_t overhead = GetPacketHeaderOverhead(IN_FEC_GROUP)
       + GetEncryptionOverhead() + GetStreamFrameOverhead(IN_FEC_GROUP);
   size_t capacity = kDefaultMaxPacketSize - overhead;
   // Now, test various sizes around this size.
   for (int delta = -5; delta <= 5; ++delta) {
     string data(capacity + delta, 'A');
     size_t bytes_free = delta > 0 ? 0 : 0 - delta;
     QuicFrame frame;
     size_t bytes_consumed = creator_.CreateStreamFrame(
@@ skipping 281 matching lines @@
     // After 64 calls, BoolSource will refresh the bucket - make sure it does.
     mock_random_.ChangeValue();
   }
 
   delete frames_[0].stream_frame;
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net