Add FlexFEC to CallTest.

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 47 matching lines @@
   void TestVp9NonFlexMode(uint8_t num_temporal_layers,
                           uint8_t num_spatial_layers);
 
   void TestRequestSourceRotateVideo(bool support_orientation_ext);
 };
 
 TEST_F(VideoSendStreamTest, CanStartStartedStream) {
   CreateSenderCall(Call::Config(&event_log_));
 
   test::NullTransport transport;
-  CreateSendConfig(1, 0, &transport);
+  CreateSendConfig(1, 0, 0, &transport);
   CreateVideoStreams();
   video_send_stream_->Start();
   video_send_stream_->Start();
   DestroyStreams();
 }
 
 TEST_F(VideoSendStreamTest, CanStopStoppedStream) {
   CreateSenderCall(Call::Config(&event_log_));
 
   test::NullTransport transport;
-  CreateSendConfig(1, 0, &transport);
+  CreateSendConfig(1, 0, 0, &transport);
   CreateVideoStreams();
   video_send_stream_->Stop();
   video_send_stream_->Stop();
   DestroyStreams();
 }
 
 TEST_F(VideoSendStreamTest, SupportsCName) {
   static std::string kCName = "PjQatC14dGfbVwGPUOA9IH7RlsFDbWl4AhXEiDsBizo=";
   class CNameObserver : public test::SendTest {
    public:
@@ skipping 1420 matching lines @@
 
     rtc::CriticalSection crit_;
     rtc::Event init_encode_called_;
     size_t number_of_initializations_ GUARDED_BY(&crit_);
     int last_initialized_frame_width_ GUARDED_BY(&crit_);
     int last_initialized_frame_height_ GUARDED_BY(&crit_);
   };
 
   CreateSenderCall(Call::Config(&event_log_));
   test::NullTransport transport;
-  CreateSendConfig(1, 0, &transport);
+  CreateSendConfig(1, 0, 0, &transport);
   EncoderObserver encoder;
   video_send_config_.encoder_settings.encoder = &encoder;
   CreateVideoStreams();
   CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
                                kDefaultHeight);
   frame_generator_capturer_->Start();
 
   encoder.WaitForResolution(kDefaultWidth, kDefaultHeight);
   frame_generator_capturer_->ChangeResolution(kDefaultWidth * 2,
                                               kDefaultHeight * 2);
@@ skipping 36 matching lines @@
 
    private:
     rtc::CriticalSection crit_;
     rtc::Event start_bitrate_changed_;
     int start_bitrate_kbps_ GUARDED_BY(crit_);
   };
 
   CreateSenderCall(Call::Config(&event_log_));
 
   test::NullTransport transport;
-  CreateSendConfig(1, 0, &transport);
+  CreateSendConfig(1, 0, 0, &transport);
 
   Call::Config::BitrateConfig bitrate_config;
   bitrate_config.start_bitrate_bps = 2 * video_encoder_config_.max_bitrate_bps;
   sender_call_->SetBitrateConfig(bitrate_config);
 
   StartBitrateObserver encoder;
   video_send_config_.encoder_settings.encoder = &encoder;
   // Since this test does not use a capturer, set |internal_source| = true.
   // Encoder configuration is otherwise updated on the next video frame.
   video_send_config_.encoder_settings.internal_source = true;
@@ skipping 60 matching lines @@
    private:
     rtc::CriticalSection crit_;
     rtc::Event encoder_init_;
     rtc::Event bitrate_changed_;
     int bitrate_kbps_ GUARDED_BY(crit_);
   };
 
   CreateSenderCall(Call::Config(&event_log_));
 
   test::NullTransport transport;
-  CreateSendConfig(1, 0, &transport);
+  CreateSendConfig(1, 0, 0, &transport);
 
   StartStopBitrateObserver encoder;
   video_send_config_.encoder_settings.encoder = &encoder;
   video_send_config_.encoder_settings.internal_source = true;
 
   CreateVideoStreams();
 
   EXPECT_TRUE(encoder.WaitForEncoderInit());
   EXPECT_GT(encoder.GetBitrateKbps(), 0);
   video_send_stream_->Start();
@@ skipping 34 matching lines @@
     std::vector<VideoFrame> output_frames_;
 
     // Indicate an output frame has arrived.
     rtc::Event output_frame_event_;
   };
 
   // Initialize send stream.
   CreateSenderCall(Call::Config(&event_log_));
 
   test::NullTransport transport;
-  CreateSendConfig(1, 0, &transport);
+  CreateSendConfig(1, 0, 0, &transport);
   FrameObserver observer;
   video_send_config_.pre_encode_callback = &observer;
   CreateVideoStreams();
 
   // Prepare five input frames. Send ordinary VideoFrame and texture frames
   // alternatively.
   std::vector<VideoFrame> input_frames;
   int width = 168;
   int height = 132;
 
@@ skipping 1234 matching lines @@
 
   RunBaseTest(&test);
 }
 #endif  // !defined(RTC_DISABLE_VP9)
 
 void VideoSendStreamTest::TestRequestSourceRotateVideo(
     bool support_orientation_ext) {
   CreateSenderCall(Call::Config(&event_log_));
 
   test::NullTransport transport;
-  CreateSendConfig(1, 0, &transport);
+  CreateSendConfig(1, 0, 0, &transport);
   video_send_config_.rtp.extensions.clear();
   if (support_orientation_ext) {
     video_send_config_.rtp.extensions.push_back(
         RtpExtension(RtpExtension::kVideoRotationUri, 1));
   }
 
   CreateVideoStreams();
   test::FrameForwarder forwarder;
   video_send_stream_->SetSource(
       &forwarder, VideoSendStream::DegradationPreference::kBalanced);
 
   EXPECT_TRUE(forwarder.sink_wants().rotation_applied !=
               support_orientation_ext);
 
   DestroyStreams();
 }
 
 TEST_F(VideoSendStreamTest,
        RequestSourceRotateIfVideoOrientationExtensionNotSupported) {
   TestRequestSourceRotateVideo(false);
 }
 
 TEST_F(VideoSendStreamTest,
        DoNotRequestsRotationIfVideoOrientationExtensionSupported) {
   TestRequestSourceRotateVideo(true);
 }
 
 }  // namespace webrtc