Generalize FEC unit tests and rename GenerateFec. (pt. 3)

webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 259 matching lines @@
                                                    ssrc);
               // Generate random values for payload
               for (size_t j = 12; j < media_packet->length; ++j) {
                 media_packet->data[j] = random.Rand<uint8_t>();
               }
               media_packet_list.push_back(std::move(media_packet));
               seq_num++;
             }
             media_packet_list.back()->data[1] |= 0x80;
 
-            ASSERT_EQ(0, fec.GenerateFec(media_packet_list, protection_factor,
-                                         num_imp_packets, kUseUnequalProtection,
-                                         fec_mask_type, &fec_packet_list))
-                << "GenerateFec() failed";
+            ASSERT_EQ(0, fec.EncodeFec(media_packet_list, protection_factor,
+                                       num_imp_packets, kUseUnequalProtection,
+                                       fec_mask_type, &fec_packet_list))
+                << "EncodeFec() failed";
 
             ASSERT_EQ(num_fec_packets, fec_packet_list.size())
                 << "We requested " << num_fec_packets << " FEC packets, but "
-                << "GenerateFec() produced " << fec_packet_list.size();
+                << "EncodeFec() produced " << fec_packet_list.size();
 
             memset(media_loss_mask, 0, sizeof(media_loss_mask));
             uint32_t media_packet_idx = 0;
             for (const auto& media_packet : media_packet_list) {
               // We want a value between 0 and 1.
               const float loss_random_variable = random.Rand<float>();
 
               if (loss_random_variable >= loss_rate[loss_rate_idx]) {
                 media_loss_mask[media_packet_idx] = 1;
                 std::unique_ptr<ForwardErrorCorrection::ReceivedPacket>
@@ skipping 87 matching lines @@
                              num_packets_to_decode, reorder_rate,
                              duplicate_rate, &random);
 
               if (fec_packet_received == false) {
                 for (const auto& received_packet : to_decode_list) {
                   if (received_packet->is_fec) {
                     fec_packet_received = true;
                   }
                 }
               }
-              ASSERT_EQ(0, fec.DecodeFec(&to_decode_list,
-                                         &recovered_packet_list))
+              ASSERT_EQ(0,
+                        fec.DecodeFec(&to_decode_list, &recovered_packet_list))
                   << "DecodeFec() failed";
               ASSERT_TRUE(to_decode_list.empty())
                   << "Received packet list is not empty.";
             }
             media_packet_idx = 0;
             for (const auto& media_packet : media_packet_list) {
               if (media_loss_mask[media_packet_idx] == 1) {
                 // Should have recovered this packet.
                 auto recovered_packet_list_it = recovered_packet_list.cbegin();
 
@@ skipping 40 matching lines @@
   }    // loop over mask types
 
   // Have DecodeFec clear the recovered packet list.
   fec.ResetState(&recovered_packet_list);
   ASSERT_TRUE(recovered_packet_list.empty())
       << "Recovered packet list is not empty";
 }
 
 }  // namespace test
 }  // namespace webrtc