Remove parity tracking in FEC groups as part of the migration to

net/quic/quic_fec_group_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 <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 18 matching lines @@
 
 const bool kEntropyFlag[] = {
   false,
   true,
   true,
   false,
   true,
   true,
 };
 
-const bool kTestFecPacketEntropy = false;
-
 }  // namespace
 
 class QuicFecGroupTest : public ::testing::Test {
  protected:
   void RunTest(size_t num_packets, size_t lost_packet, bool out_of_order) {
     size_t max_len = strlen(kData[0]);
     scoped_ptr<char[]> redundancy(new char[max_len]);
-    bool entropy_redundancy = false;
     for (size_t packet = 0; packet < num_packets; ++packet) {
       for (size_t i = 0; i < max_len; i++) {
         if (packet == 0) {
           // Initialize to the first packet.
           redundancy[i] = kData[0][i];
           continue;
         }
         // XOR in the remaining packets.
         uint8 byte = i > strlen(kData[packet]) ? 0x00 : kData[packet][i];
         redundancy[i] = redundancy[i] ^ byte;
       }
-      entropy_redundancy = (entropy_redundancy != kEntropyFlag[packet]);
     }
 
     QuicFecGroup group;
 
     // If we're out of order, send the FEC packet in the position of the
     // lost packet. Otherwise send all (non-missing) packets, then FEC.
     if (out_of_order) {
       // Update the FEC state for each non-lost packet.
       for (size_t packet = 0; packet < num_packets; packet++) {
         if (packet == lost_packet) {
           ASSERT_FALSE(group.IsFinished());
           QuicFecData fec;
           fec.fec_group = 0;
           fec.redundancy = StringPiece(redundancy.get(), strlen(kData[0]));
-          ASSERT_TRUE(group.UpdateFec(num_packets, entropy_redundancy, fec));
+          ASSERT_TRUE(group.UpdateFec(num_packets, fec));
         } else {
           QuicPacketHeader header;
           header.packet_sequence_number = packet;
           header.entropy_flag = kEntropyFlag[packet];
           ASSERT_TRUE(group.Update(header, kData[packet]));
         }
         ASSERT_TRUE(group.CanRevive() == (packet == num_packets - 1));
       }
     } else {
     // Update the FEC state for each non-lost packet.
       for (size_t packet = 0; packet < num_packets; packet++) {
         if (packet == lost_packet) {
           continue;
         }
 
         QuicPacketHeader header;
         header.packet_sequence_number = packet;
         header.entropy_flag = kEntropyFlag[packet];
         ASSERT_TRUE(group.Update(header, kData[packet]));
         ASSERT_FALSE(group.CanRevive());
       }
 
       ASSERT_FALSE(group.IsFinished());
       // Attempt to revive the missing packet.
       QuicFecData fec;
       fec.fec_group = 0;
       fec.redundancy = StringPiece(redundancy.get(), strlen(kData[0]));
 
-      ASSERT_TRUE(group.UpdateFec(num_packets, entropy_redundancy, fec));
+      ASSERT_TRUE(group.UpdateFec(num_packets, fec));
     }
     QuicPacketHeader header;
     char recovered[kMaxPacketSize];
     ASSERT_TRUE(group.CanRevive());
     size_t len = group.Revive(&header, recovered, arraysize(recovered));
     ASSERT_NE(0u, len)
         << "Failed to revive packet " << lost_packet << " out of "
         << num_packets;
     EXPECT_EQ(lost_packet, header.packet_sequence_number)
         << "Failed to revive packet " << lost_packet << " out of "
         << num_packets;
-    EXPECT_EQ(kEntropyFlag[lost_packet], header.entropy_flag);
+    // Revived packets have an unknown entropy.
+    EXPECT_EQ(0, header.entropy_flag);
     ASSERT_GE(len, strlen(kData[lost_packet])) << "Incorrect length";
     for (size_t i = 0; i < strlen(kData[lost_packet]); i++) {
       EXPECT_EQ(kData[lost_packet][i], recovered[i]);
     }
     ASSERT_TRUE(group.IsFinished());
   }
 };
 
 TEST_F(QuicFecGroupTest, UpdateAndRevive) {
   RunTest(2, 0, false);
@@ skipping 24 matching lines @@
 
   QuicPacketHeader header;
   header.packet_sequence_number = 3;
   group.Update(header, data1);
 
   QuicFecData fec;
   fec.fec_group = 1;
   fec.redundancy = redundancy;
 
   header.packet_sequence_number = 2;
-  ASSERT_FALSE(group.UpdateFec(2, kTestFecPacketEntropy, fec));
+  ASSERT_FALSE(group.UpdateFec(2, fec));
 }
 
 TEST_F(QuicFecGroupTest, ProtectsPacketsBefore) {
   QuicPacketHeader header;
   header.packet_sequence_number = 3;
 
   QuicFecGroup group;
   ASSERT_TRUE(group.Update(header, kData[0]));
 
   EXPECT_FALSE(group.ProtectsPacketsBefore(1));
@@ skipping 28 matching lines @@
   EXPECT_TRUE(group.ProtectsPacketsBefore(9));
   EXPECT_TRUE(group.ProtectsPacketsBefore(50));
 }
 
 TEST_F(QuicFecGroupTest, ProtectsPacketsBeforeWithFecData) {
   QuicFecData fec;
   fec.fec_group = 2;
   fec.redundancy = kData[0];
 
   QuicFecGroup group;
-  ASSERT_TRUE(group.UpdateFec(3, kTestFecPacketEntropy, fec));
+  ASSERT_TRUE(group.UpdateFec(3, fec));
 
   EXPECT_FALSE(group.ProtectsPacketsBefore(1));
   EXPECT_FALSE(group.ProtectsPacketsBefore(2));
   EXPECT_TRUE(group.ProtectsPacketsBefore(3));
   EXPECT_TRUE(group.ProtectsPacketsBefore(4));
   EXPECT_TRUE(group.ProtectsPacketsBefore(5));
   EXPECT_TRUE(group.ProtectsPacketsBefore(50));
 }
 
 }  // namespace net