Rename Fec to Ulpfec in VideoSendStreamTest.

webrtc/video/video_send_stream_tests.cc

 /*
  *  Copyright (c) 2013 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.
  */
 #include <algorithm>  // max
@@ skipping 293 matching lines @@
       return true;
     }
 
     RtcpStatistics stats_;
   };
 
   std::unique_ptr<LossyStatistician> lossy_stats_;
   StatisticianMap stats_map_;
 };
 
-class FecObserver : public test::EndToEndTest {
+class UlpfecObserver : public test::EndToEndTest {
  public:
-  FecObserver(bool header_extensions_enabled,
+  UlpfecObserver(bool header_extensions_enabled,
               bool use_nack,
               bool expect_red,
-              bool expect_fec,
+              bool expect_ulpfec,
               const std::string& codec)
       : EndToEndTest(VideoSendStreamTest::kDefaultTimeoutMs),
         payload_name_(codec),
         use_nack_(use_nack),
         expect_red_(expect_red),
-        expect_fec_(expect_fec),
+        expect_ulpfec_(expect_ulpfec),
         send_count_(0),
         received_media_(false),
         received_fec_(false),
         header_extensions_enabled_(header_extensions_enabled) {
     if (codec == "H264") {
       encoder_.reset(new test::FakeH264Encoder(Clock::GetRealTimeClock()));
     } else if (codec == "VP8") {
       encoder_.reset(VideoEncoder::Create(VideoEncoder::EncoderType::kVp8));
     } else if (codec == "VP9") {
       encoder_.reset(VideoEncoder::Create(VideoEncoder::EncoderType::kVp9));
@@ skipping 42 matching lines @@
       }
       EXPECT_TRUE(header.extension.hasTransportSequenceNumber);
       uint16_t seq_num_diff = header.extension.transportSequenceNumber -
                               prev_header_.extension.transportSequenceNumber;
       EXPECT_EQ(1, seq_num_diff);
     }
 
     if (encapsulated_payload_type != -1) {
       if (encapsulated_payload_type ==
           VideoSendStreamTest::kUlpfecPayloadType) {
-        EXPECT_TRUE(expect_fec_);
+        EXPECT_TRUE(expect_ulpfec_);
         received_fec_ = true;
       } else {
         received_media_ = true;
       }
     }
 
     if (send_count_ > 100 && received_media_) {
-      if (received_fec_ || !expect_fec_)
+      if (received_fec_ || !expect_ulpfec_)
         observation_complete_.Set();
     }
 
     prev_header_ = header;
 
     return SEND_PACKET;
   }
 
   test::PacketTransport* CreateSendTransport(Call* sender_call) override {
     // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
@@ skipping 39 matching lines @@
 
   void PerformTest() override {
     EXPECT_TRUE(Wait()) << "Timed out waiting for FEC and media packets.";
   }
 
   std::unique_ptr<internal::TransportAdapter> transport_adapter_;
   std::unique_ptr<VideoEncoder> encoder_;
   const std::string payload_name_;
   const bool use_nack_;
   const bool expect_red_;
-  const bool expect_fec_;
+  const bool expect_ulpfec_;
   int send_count_;
   bool received_media_;
   bool received_fec_;
   bool header_extensions_enabled_;
   RTPHeader prev_header_;
 };
 
-TEST_F(VideoSendStreamTest, SupportsFecWithExtensions) {
-  FecObserver test(true, false, true, true, "VP8");
+TEST_F(VideoSendStreamTest, SupportsUlpfecWithExtensions) {
+  UlpfecObserver test(true, false, true, true, "VP8");
   RunBaseTest(&test);
 }
 
-TEST_F(VideoSendStreamTest, SupportsFecWithoutExtensions) {
-  FecObserver test(false, false, true, true, "VP8");
+TEST_F(VideoSendStreamTest, SupportsUlpfecWithoutExtensions) {
+  UlpfecObserver test(false, false, true, true, "VP8");
   RunBaseTest(&test);
 }
 
 // The FEC scheme used is not efficient for H264, so we should not use RED/FEC
 // since we'll still have to re-request FEC packets, effectively wasting
 // bandwidth since the receiver has to wait for FEC retransmissions to determine
 // that the received state is actually decodable.
-TEST_F(VideoSendStreamTest, DoesNotUtilizeFecForH264WithNackEnabled) {
-  FecObserver test(false, true, true, false, "H264");
+TEST_F(VideoSendStreamTest, DoesNotUtilizeUlpfecForH264WithNackEnabled) {
+  UlpfecObserver test(false, true, true, false, "H264");
   RunBaseTest(&test);
 }
 
 // Without retransmissions FEC for H264 is fine.
 TEST_F(VideoSendStreamTest, DoesUtilizeRedForH264WithoutNackEnabled) {
-  FecObserver test(false, false, true, true, "H264");
+  UlpfecObserver test(false, false, true, true, "H264");
   RunBaseTest(&test);
 }
 
 TEST_F(VideoSendStreamTest, DoesUtilizeRedForVp8WithNackEnabled) {
-  FecObserver test(false, true, true, true, "VP8");
+  UlpfecObserver test(false, true, true, true, "VP8");
   RunBaseTest(&test);
 }
 
 #if !defined(RTC_DISABLE_VP9)
 TEST_F(VideoSendStreamTest, DoesUtilizeRedForVp9WithNackEnabled) {
-  FecObserver test(false, true, true, true, "VP9");
+  UlpfecObserver test(false, true, true, true, "VP9");
   RunBaseTest(&test);
 }
 #endif  // !defined(RTC_DISABLE_VP9)
 
 void VideoSendStreamTest::TestNackRetransmission(
     uint32_t retransmit_ssrc,
     uint8_t retransmit_payload_type) {
   class NackObserver : public test::SendTest {
    public:
     explicit NackObserver(uint32_t retransmit_ssrc,
@@ skipping 2381 matching lines @@
         observation_complete_.Set();
       }
     }
   } test;
 
   RunBaseTest(&test);
 }
 #endif  // !defined(RTC_DISABLE_VP9)
 
 }  // namespace webrtc