Add multithreaded fake encoder and corresponding FlexFEC 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 347 matching lines @@
                  bool expect_ulpfec,
                  const std::string& codec)
       : EndToEndTest(VideoSendStreamTest::kDefaultTimeoutMs),
         payload_name_(codec),
         use_nack_(use_nack),
         expect_red_(expect_red),
         expect_ulpfec_(expect_ulpfec),
         sent_media_(false),
         sent_ulpfec_(false),
         header_extensions_enabled_(header_extensions_enabled) {
-    if (codec == "H264") {
+    if (codec == "MTFE") {

[stefan-webrtc, 2016/12/12 15:18:28]

I think this is a bit ugly. Can we pass in the objects instead and have the
caller create them?

[brandtr, 2016/12/13 11:32:23]

We could, but it seems that I would still need to pass in the codec name string,
to be set here:
https://cs.chromium.org/chromium/src/third_party/webrtc/video/video_send_stre....
This string is used when creating the coder, and DCHECKS if I don't set it.

[stefan-webrtc, 2016/12/13 13:04:46]

Right, but you can then just call it H264, instead of something unknown as MTFE.

[brandtr, 2016/12/14 10:13:50]

Yep. I also made it a FakeH264Encoder, so I'm not lying to the underlying code
about what type of encoder it is supposed to be.

[stefan-webrtc, 2016/12/14 11:42:31]

This works, but instead of only passing in the payload name you could pass in
the payload name and the encoder object and avoid the string comparisons and the
odd codec name

[brandtr, 2016/12/19 08:54:53]

Done. This made the test instantiations more verbose, however.

+      encoder_.reset(
+          new test::MultiThreadedFakeEncoder(Clock::GetRealTimeClock()));
+    } else if (codec == "H264") {
       encoder_.reset(new test::FakeH264Encoder(Clock::GetRealTimeClock()));
     } else if (codec == "VP8") {
       encoder_.reset(VP8Encoder::Create());
     } else if (codec == "VP9") {
       encoder_.reset(VP9Encoder::Create());
     } else {
       RTC_NOTREACHED();
     }
   }
 
@@ skipping 148 matching lines @@
   RunBaseTest(&test);
 }
 
 #if !defined(RTC_DISABLE_VP9)
 TEST_F(VideoSendStreamTest, DoesUtilizeUlpfecForVp9WithNackEnabled) {
   UlpfecObserver test(false, true, true, true, "VP9");
   RunBaseTest(&test);
 }
 #endif  // !defined(RTC_DISABLE_VP9)
 
+TEST_F(VideoSendStreamTest, SupportsUlpfecMTFE) {
+  UlpfecObserver test(false, false, true, true, "MTFE");
+  RunBaseTest(&test);
+}
+
 // TODO(brandtr): Move these FlexFEC tests when we have created
 // FlexfecSendStream.
 class FlexfecObserver : public test::EndToEndTest {
  public:
   FlexfecObserver(bool header_extensions_enabled,
                   bool use_nack,
                   const std::string& codec)
       : EndToEndTest(VideoSendStreamTest::kDefaultTimeoutMs),
         payload_name_(codec),
         use_nack_(use_nack),
         sent_media_(false),
         sent_flexfec_(false),
         header_extensions_enabled_(header_extensions_enabled) {
-    if (codec == "H264") {
+    if (codec == "MTFE") {
+      encoder_.reset(
+          new test::MultiThreadedFakeEncoder(Clock::GetRealTimeClock()));
+    } else if (codec == "H264") {
       encoder_.reset(new test::FakeH264Encoder(Clock::GetRealTimeClock()));
     } else if (codec == "VP8") {
       encoder_.reset(VP8Encoder::Create());
     } else if (codec == "VP9") {
       encoder_.reset(VP9Encoder::Create());
     } else {
       RTC_NOTREACHED();
     }
   }
 
@@ skipping 107 matching lines @@
 TEST_F(VideoSendStreamTest, SupportsFlexfecH264) {
   FlexfecObserver test(false, false, "H264");
   RunBaseTest(&test);
 }
 
 TEST_F(VideoSendStreamTest, SupportsFlexfecWithNackH264) {
   FlexfecObserver test(false, true, "H264");
   RunBaseTest(&test);
 }
 
+TEST_F(VideoSendStreamTest, SupportsFlexfecMTFE) {
+  FlexfecObserver test(false, false, "MTFE");
+  RunBaseTest(&test);
+}
+
 void VideoSendStreamTest::TestNackRetransmission(
     uint32_t retransmit_ssrc,
     uint8_t retransmit_payload_type) {
   class NackObserver : public test::SendTest {
    public:
     explicit NackObserver(uint32_t retransmit_ssrc,
                           uint8_t retransmit_payload_type)
         : SendTest(kDefaultTimeoutMs),
           send_count_(0),
           retransmit_ssrc_(retransmit_ssrc),
@@ skipping 2523 matching lines @@
    private:
     Call* call_;
     rtc::CriticalSection crit_;
     uint32_t max_bitrate_kbps_ GUARDED_BY(&crit_);
   } test;
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc