Correct (enlarge) the situations when QuicPacketGenerator::MaybeSendFecPacketAndCloseGroup calls pa…

net/quic/quic_packet_generator_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_generator.h"
 
 #include <string>
 
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/null_encrypter.h"
@@ skipping 1199 matching lines @@
     CheckPacketHasSingleStreamFrame(4);
     // FEC packet is sent after 2 packets and when send policy is
     // FEC_ANY_TRIGGER.
     CheckPacketIsFec(5, 4);
     CheckPacketHasSingleStreamFrame(6);
     CheckPacketHasSingleStreamFrame(7);
     // FEC packet is sent after 2 packets and when send policy is
     // FEC_ANY_TRIGGER.
     CheckPacketIsFec(8, 7);
   }
-  EXPECT_TRUE(creator_->IsFecProtected());
+  EXPECT_FALSE(creator_->IsFecProtected());
+
+  // Do the another send (with MAY_FEC_PROTECT) on a different stream id, which
+  // should not produce an FEC packet because the last FEC group has been
+  // closed.
+  {
+    InSequence dummy;
+    EXPECT_CALL(delegate_, OnSerializedPacket(_))
+        .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
+    EXPECT_CALL(delegate_, OnSerializedPacket(_))
+        .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
+    EXPECT_CALL(delegate_, OnSerializedPacket(_))
+        .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
+  }
+  consumed = generator_.ConsumeData(9, CreateData(data_len), 0, true,
+                                    MAY_FEC_PROTECT, nullptr);
+  EXPECT_EQ(data_len, consumed.bytes_consumed);
+  EXPECT_TRUE(consumed.fin_consumed);
+  EXPECT_FALSE(generator_.HasQueuedFrames());
+  if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
+    CheckPacketHasSingleStreamFrame(6);
+    CheckPacketHasSingleStreamFrame(7);
+    CheckPacketHasSingleStreamFrame(8);
+  } else {
+    CheckPacketHasSingleStreamFrame(9);
+    CheckPacketHasSingleStreamFrame(10);
+    CheckPacketHasSingleStreamFrame(11);
+  }
+  EXPECT_FALSE(creator_->IsFecProtected());
 }
 
 // 1. Create and send one packet with MUST_FEC_PROTECT.
 // 2. Call FecTimeout, expect FEC packet is sent.
 // 3. Do the same thing over again, with a different stream id.
 TEST_P(QuicPacketGeneratorTest, FecPacketSentOnFecTimeout) {
   delegate_.SetCanWriteAnything();
   creator_->set_max_packets_per_fec_group(1000);
   EXPECT_FALSE(creator_->IsFecProtected());
 
@@ skipping 414 matching lines @@
   // This will not serialize any packets, because of the invalid frame.
   EXPECT_CALL(delegate_,
               CloseConnection(QUIC_FAILED_TO_SERIALIZE_PACKET, false));
   EXPECT_DFATAL(generator_.FinishBatchOperations(),
                 "packet_number_length 1 is too small "
                 "for least_unacked_delta: 1001");
 }
 
 }  // namespace test
 }  // namespace net