Protected streams report RTP messages directly to the FlexFec streams

webrtc/test/call_test.cc

 /*
  *  Copyright (c) 2014 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 318 matching lines @@
   RTC_DCHECK(video_receive_streams_.empty());
   RTC_DCHECK(audio_send_stream_ == nullptr);
   RTC_DCHECK(audio_receive_streams_.empty());
 
   video_send_stream_ = sender_call_->CreateVideoSendStream(
       video_send_config_.Copy(), video_encoder_config_.Copy());
   for (size_t i = 0; i < video_receive_configs_.size(); ++i) {
     video_receive_streams_.push_back(receiver_call_->CreateVideoReceiveStream(
         video_receive_configs_[i].Copy()));
   }
+
+  AssociateFlexfecStreamsWithVideoStreams();
 }
 
 void CallTest::SetFakeVideoCaptureRotation(VideoRotation rotation) {
   frame_generator_capturer_->SetFakeRotation(rotation);
 }
 
 void CallTest::CreateAudioStreams() {
   audio_send_stream_ = sender_call_->CreateAudioSendStream(audio_send_config_);
   for (size_t i = 0; i < audio_receive_configs_.size(); ++i) {
     audio_receive_streams_.push_back(
         receiver_call_->CreateAudioReceiveStream(audio_receive_configs_[i]));
   }
 }
 
 void CallTest::CreateFlexfecStreams() {
   for (size_t i = 0; i < flexfec_receive_configs_.size(); ++i) {
     flexfec_receive_streams_.push_back(
         receiver_call_->CreateFlexfecReceiveStream(
             flexfec_receive_configs_[i]));
   }
+
+  AssociateFlexfecStreamsWithVideoStreams();
+}
+
+void CallTest::AssociateFlexfecStreamsWithVideoStreams() {
+  // All FlexFEC streams protect all of the video streams.
+  for (auto* flexfec_receive_stream : flexfec_receive_streams_) {
+    for (auto* video_recv_stream : video_receive_streams_) {
+      video_recv_stream->AddSecondarySink(flexfec_receive_stream);
+    }
+  }
+}
+
+void CallTest::DissociateFlexfecStreamsFromVideoStreams() {
+  for (VideoReceiveStream* video_recv_stream : video_receive_streams_) {
+    for (FlexfecReceiveStream* flexfec_recv_stream : flexfec_receive_streams_) {
+      video_recv_stream->RemoveSecondarySink(flexfec_recv_stream);
+    }
+  }
 }
 
 void CallTest::DestroyStreams() {
+  DissociateFlexfecStreamsFromVideoStreams();
+
   if (audio_send_stream_)
     sender_call_->DestroyAudioSendStream(audio_send_stream_);
   audio_send_stream_ = nullptr;
   for (AudioReceiveStream* audio_recv_stream : audio_receive_streams_)
     receiver_call_->DestroyAudioReceiveStream(audio_recv_stream);
 
   if (video_send_stream_)
     sender_call_->DestroyVideoSendStream(video_send_stream_);
   video_send_stream_ = nullptr;
 
-  for (VideoReceiveStream* video_recv_stream : video_receive_streams_)
+  for (VideoReceiveStream* video_recv_stream : video_receive_streams_) {
     receiver_call_->DestroyVideoReceiveStream(video_recv_stream);
+  }
 
   for (FlexfecReceiveStream* flexfec_recv_stream : flexfec_receive_streams_)
     receiver_call_->DestroyFlexfecReceiveStream(flexfec_recv_stream);
 
   video_receive_streams_.clear();
   allocated_decoders_.clear();
 }
 
 void CallTest::CreateVoiceEngines() {
   voe_send_.voice_engine = VoiceEngine::Create();
@@ skipping 163 matching lines @@
 
 EndToEndTest::EndToEndTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
 }
 
 bool EndToEndTest::ShouldCreateReceivers() const {
   return true;
 }
 
 }  // namespace test
 }  // namespace webrtc