Reland "Moved VideoReceiveStream::Decoder::decoder_factory to VideoReceiveStream::Config::decoder_factory."

This reverts commit a4f23ad0ce.

Reason for revert: Downstream fix landed.

TBR=mflodman@webrtc.org

Original change's description:
> Revert "Moved VideoReceiveStream::Decoder::decoder_factory to VideoReceiveStream::Config::decoder_factory."
>
> This reverts commit acb9d8365a.
>
> Reason for revert: Break downstream stuff.
>
> Original change's description:
> > Moved VideoReceiveStream::Decoder::decoder_factory to VideoReceiveStream::Config::decoder_factory.
> >
> > Bug: webrtc:9106
> > Change-Id: I85712f3ab6a734d3fad7819491d3b8e3388b47e7
> > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/180342
> > Reviewed-by: Niels Moller <nisse@webrtc.org>
> > Reviewed-by: Magnus Flodman <mflodman@webrtc.org>
> > Commit-Queue: Philip Eliasson <philipel@webrtc.org>
> > Cr-Commit-Position: refs/heads/master@{#31834}
>
> TBR=nisse@webrtc.org,philipel@webrtc.org,mflodman@webrtc.org
>
> Change-Id: I6cfdb85a154a78135839f84edf5f69673d5ab715
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Bug: webrtc:9106
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/180807
> Reviewed-by: Philip Eliasson <philipel@webrtc.org>
> Commit-Queue: Philip Eliasson <philipel@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#31835}

TBR=nisse@webrtc.org,philipel@webrtc.org,mflodman@webrtc.org

# Not skipping CQ checks because this is a reland.

Bug: webrtc:9106
Change-Id: I03b3e68532107bec37bcc6e47a5489c84fe91ef9
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/180808
Commit-Queue: Philip Eliasson <philipel@webrtc.org>
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Reviewed-by: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31866}

call/bitrate_estimator_tests.cc

@@ -191,7 +191,7 @@ class BitrateEstimatorTest : public test::CallTest {
       send_stream_->Start();
 
       VideoReceiveStream::Decoder decoder;
-      decoder.decoder_factory = &decoder_factory_;
+      test_->receive_config_.decoder_factory = &decoder_factory_;
       decoder.payload_type = test_->GetVideoSendConfig()->rtp.payload_type;
       decoder.video_format =
           SdpVideoFormat(test_->GetVideoSendConfig()->rtp.payload_name);

call/video_receive_stream.h

@@ -70,10 +70,6 @@ class VideoReceiveStream {
     ~Decoder();
     std::string ToString() const;
 
-    // Ownership stays with WebrtcVideoEngine (delegated from PeerConnection).
-    // TODO(nisse): Move one level out, to VideoReceiveStream::Config, and later
-    // to the configuration of VideoStreamDecoder.
-    VideoDecoderFactory* decoder_factory = nullptr;
     SdpVideoFormat video_format;
 
     // Received RTP packets with this payload type will be sent to this decoder
@@ -173,6 +169,9 @@ class VideoReceiveStream {
     // Decoders for every payload that we can receive.
     std::vector<Decoder> decoders;
 
+    // Ownership stays with WebrtcVideoEngine (delegated from PeerConnection).
+    VideoDecoderFactory* decoder_factory = nullptr;
+
     // Receive-stream specific RTP settings.
     struct Rtp {
       Rtp();

media/engine/webrtc_video_engine.cc

@@ -2771,12 +2771,12 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs(
   config_.decoders.clear();
   config_.rtp.rtx_associated_payload_types.clear();
   config_.rtp.raw_payload_types.clear();
+  config_.decoder_factory = decoder_factory_;
   for (const auto& recv_codec : recv_codecs) {
     webrtc::SdpVideoFormat video_format(recv_codec.codec.name,
                                         recv_codec.codec.params);
 
     webrtc::VideoReceiveStream::Decoder decoder;
-    decoder.decoder_factory = decoder_factory_;
     decoder.video_format = video_format;
     decoder.payload_type = recv_codec.codec.id;
     decoder.video_format =

rtc_tools/video_replay.cc

@@ -335,7 +335,6 @@ class RtpReplayer final {
       for (auto& decoder : receive_config.decoders) {
         decoder = test::CreateMatchingDecoder(decoder.payload_type,
                                               decoder.video_format.name);
-        decoder.decoder_factory = stream_state->decoder_factory.get();
       }
       // Create a window for this config.
       std::stringstream window_title;
@@ -344,6 +343,7 @@ class RtpReplayer final {
           test::VideoRenderer::Create(window_title.str().c_str(), 640, 480));
       // Create a receive stream for this config.
       receive_config.renderer = stream_state->sinks.back().get();
+      receive_config.decoder_factory = stream_state->decoder_factory.get();
       stream_state->receive_streams.emplace_back(
           call->CreateVideoReceiveStream(std::move(receive_config)));
     }
@@ -402,7 +402,7 @@ class RtpReplayer final {
                 DecoderBitstreamFilename().c_str());
           });
     }
-    decoder.decoder_factory = stream_state->decoder_factory.get();
+    receive_config.decoder_factory = stream_state->decoder_factory.get();
     receive_config.decoders.push_back(decoder);
 
     stream_state->receive_streams.emplace_back(

test/call_test.cc

@@ -388,9 +388,9 @@ void CallTest::AddMatchingVideoReceiveConfigs(
     decoder.video_format = SdpVideoFormat(video_send_config.rtp.payload_name);
     // Force fake decoders on non-selected simulcast streams.
     if (!decode_sub_stream || i == *decode_sub_stream) {
-      decoder.decoder_factory = decoder_factory;
+      video_recv_config.decoder_factory = decoder_factory;
     } else {
-      decoder.decoder_factory = &fake_decoder_factory_;
+      video_recv_config.decoder_factory = &fake_decoder_factory_;
     }
     video_recv_config.decoders.push_back(decoder);
     receive_configs->emplace_back(std::move(video_recv_config));

test/fuzzers/utils/rtp_replayer.cc

@@ -113,7 +113,6 @@ void RtpReplayer::SetupVideoStreams(
     for (auto& decoder : receive_config.decoders) {
       decoder = test::CreateMatchingDecoder(decoder.payload_type,
                                             decoder.video_format.name);
-      decoder.decoder_factory = stream_state->decoder_factory.get();
     }
 
     // Create the window to display the rendered video.
@@ -121,6 +120,7 @@ void RtpReplayer::SetupVideoStreams(
         test::VideoRenderer::Create("Fuzzing WebRTC Video Config", 640, 480));
     // Create a receive stream for this config.
     receive_config.renderer = stream_state->sinks.back().get();
+    receive_config.decoder_factory = stream_state->decoder_factory.get();
     stream_state->receive_streams.emplace_back(
         call->CreateVideoReceiveStream(std::move(receive_config)));
   }

test/scenario/video_stream.cc

@@ -323,6 +323,7 @@ std::unique_ptr<FrameGeneratorInterface> CreateFrameGenerator(
 VideoReceiveStream::Config CreateVideoReceiveStreamConfig(
     VideoStreamConfig config,
     Transport* feedback_transport,
+    VideoDecoderFactory* decoder_factory,
     VideoReceiveStream::Decoder decoder,
     rtc::VideoSinkInterface<VideoFrame>* renderer,
     uint32_t local_ssrc,
@@ -338,6 +339,7 @@ VideoReceiveStream::Config CreateVideoReceiveStreamConfig(
   recv.rtp.nack.rtp_history_ms = config.stream.nack_history_time.ms();
   recv.rtp.protected_by_flexfec = config.stream.use_flexfec;
   recv.rtp.remote_ssrc = ssrc;
+  recv.decoder_factory = decoder_factory;
   recv.decoders.push_back(decoder);
   recv.renderer = renderer;
   if (config.stream.use_rtx) {
@@ -549,7 +551,6 @@ ReceiveVideoStream::ReceiveVideoStream(CallClient* receiver,
   VideoReceiveStream::Decoder decoder =
       CreateMatchingDecoder(CodecTypeToPayloadType(config.encoder.codec),
                             CodecTypeToPayloadString(config.encoder.codec));
-  decoder.decoder_factory = decoder_factory_.get();
   size_t num_streams = 1;
   if (config.encoder.codec == VideoStreamConfig::Encoder::Codec::kVideoCodecVP8)
     num_streams = config.encoder.layers.spatial;
@@ -561,7 +562,7 @@ ReceiveVideoStream::ReceiveVideoStream(CallClient* receiver,
       renderer = render_taps_.back().get();
     }
     auto recv_config = CreateVideoReceiveStreamConfig(
-        config, feedback_transport, decoder, renderer,
+        config, feedback_transport, decoder_factory_.get(), decoder, renderer,
         receiver_->GetNextVideoLocalSsrc(), send_stream->ssrcs_[i],
         send_stream->rtx_ssrcs_[i]);
     if (config.stream.use_flexfec) {

video/end_to_end_tests/codec_tests.cc

@@ -84,7 +84,7 @@ class CodecObserver : public test::EndToEndTest,
         send_config->rtp.payload_type;
     (*receive_configs)[0].decoders[0].video_format =
         SdpVideoFormat(send_config->rtp.payload_name);
-    (*receive_configs)[0].decoders[0].decoder_factory = decoder_factory_;
+    (*receive_configs)[0].decoder_factory = decoder_factory_;
   }
 
   void OnFrame(const VideoFrame& video_frame) override {

video/end_to_end_tests/fec_tests.cc

@@ -120,7 +120,7 @@ TEST_F(FecEndToEndTest, ReceivesUlpfec) {
       encoder_config->codec_type = kVideoCodecVP8;
       VideoReceiveStream::Decoder decoder =
           test::CreateMatchingDecoder(*send_config);
-      decoder.decoder_factory = &decoder_factory_;
+      (*receive_configs)[0].decoder_factory = &decoder_factory_;
       (*receive_configs)[0].decoders.clear();
       (*receive_configs)[0].decoders.push_back(decoder);
 
@@ -487,7 +487,7 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
           send_config->rtp.payload_type;
       (*receive_configs)[0].decoders[0].video_format =
           SdpVideoFormat(send_config->rtp.payload_name);
-      (*receive_configs)[0].decoders[0].decoder_factory = &decoder_factory_;
+      (*receive_configs)[0].decoder_factory = &decoder_factory_;
     }
 
     void PerformTest() override {

video/end_to_end_tests/frame_encryption_tests.cc

@@ -46,8 +46,8 @@ class DecryptedFrameObserver : public test::EndToEndTest,
     encoder_config->codec_type = kVideoCodecVP8;
     VideoReceiveStream::Decoder decoder =
         test::CreateMatchingDecoder(*send_config);
-    decoder.decoder_factory = &decoder_factory_;
     for (auto& recv_config : *receive_configs) {
+      recv_config.decoder_factory = &decoder_factory_;
       recv_config.decoders.clear();
       recv_config.decoders.push_back(decoder);
       recv_config.renderer = this;

video/end_to_end_tests/multi_codec_receive_tests.cc

@@ -182,12 +182,12 @@ void MultiCodecReceiveTest::ConfigureDecoders(
     VideoDecoderFactory* decoder_factory) {
   video_receive_configs_[0].decoders.clear();
   // Placing the payload names in a std::set retains the unique names only.
+  video_receive_configs_[0].decoder_factory = decoder_factory;
   std::set<std::string> unique_payload_names;
   for (const auto& config : configs)
     if (unique_payload_names.insert(config.payload_name).second) {
       VideoReceiveStream::Decoder decoder = test::CreateMatchingDecoder(
           PayloadNameToPayloadType(config.payload_name), config.payload_name);
-      decoder.decoder_factory = decoder_factory;
 
       video_receive_configs_[0].decoders.push_back(decoder);
     }

video/end_to_end_tests/multi_stream_tester.cc

@@ -102,9 +102,9 @@ void MultiStreamTester::RunTest() {
       VideoReceiveStream::Config receive_config(receiver_transport.get());
       receive_config.rtp.remote_ssrc = ssrc;
       receive_config.rtp.local_ssrc = test::CallTest::kReceiverLocalVideoSsrc;
+      receive_config.decoder_factory = &decoder_factory;
       VideoReceiveStream::Decoder decoder =
           test::CreateMatchingDecoder(send_config);
-      decoder.decoder_factory = &decoder_factory;
       receive_config.decoders.push_back(decoder);
 
       UpdateReceiveConfig(i, &receive_config);

video/video_receive_stream.cc

@@ -238,9 +238,9 @@ VideoReceiveStream::VideoReceiveStream(
   network_sequence_checker_.Detach();
 
   RTC_DCHECK(!config_.decoders.empty());
+  RTC_CHECK(config_.decoder_factory);
   std::set<int> decoder_payload_types;
   for (const Decoder& decoder : config_.decoders) {
-    RTC_CHECK(decoder.decoder_factory);
     RTC_CHECK(decoder_payload_types.find(decoder.payload_type) ==
               decoder_payload_types.end())
         << "Duplicate payload type (" << decoder.payload_type
@@ -336,7 +336,7 @@ void VideoReceiveStream::Start() {
 
   for (const Decoder& decoder : config_.decoders) {
     std::unique_ptr<VideoDecoder> video_decoder =
-        decoder.decoder_factory->LegacyCreateVideoDecoder(decoder.video_format,
+        config_.decoder_factory->LegacyCreateVideoDecoder(decoder.video_format,
                                                           config_.stream_id);
     // If we still have no valid decoder, we have to create a "Null" decoder
     // that ignores all calls. The reason we can get into this state is that the

video/video_receive_stream2.cc

@@ -235,9 +235,9 @@ VideoReceiveStream2::VideoReceiveStream2(
   module_process_sequence_checker_.Detach();
 
   RTC_DCHECK(!config_.decoders.empty());
+  RTC_CHECK(config_.decoder_factory);
   std::set<int> decoder_payload_types;
   for (const Decoder& decoder : config_.decoders) {
-    RTC_CHECK(decoder.decoder_factory);
     RTC_CHECK(decoder_payload_types.find(decoder.payload_type) ==
               decoder_payload_types.end())
         << "Duplicate payload type (" << decoder.payload_type
@@ -312,7 +312,7 @@ void VideoReceiveStream2::Start() {
 
   for (const Decoder& decoder : config_.decoders) {
     std::unique_ptr<VideoDecoder> video_decoder =
-        decoder.decoder_factory->LegacyCreateVideoDecoder(decoder.video_format,
+        config_.decoder_factory->LegacyCreateVideoDecoder(decoder.video_format,
                                                           config_.stream_id);
     // If we still have no valid decoder, we have to create a "Null" decoder
     // that ignores all calls. The reason we can get into this state is that the

video/video_receive_stream2_unittest.cc

@@ -105,12 +105,12 @@ class VideoReceiveStream2Test : public ::testing::Test {
     config_.rtp.remote_ssrc = 1111;
     config_.rtp.local_ssrc = 2222;
     config_.renderer = &fake_renderer_;
+    config_.decoder_factory = &h264_decoder_factory_;
     VideoReceiveStream::Decoder h264_decoder;
     h264_decoder.payload_type = 99;
     h264_decoder.video_format = SdpVideoFormat("H264");
     h264_decoder.video_format.parameters.insert(
         {"sprop-parameter-sets", "Z0IACpZTBYmI,aMljiA=="});
-    h264_decoder.decoder_factory = &h264_decoder_factory_;
     config_.decoders.push_back(h264_decoder);
 
     clock_ = Clock::GetRealTimeClock();
@@ -244,10 +244,10 @@ class VideoReceiveStream2TestWithFakeDecoder : public ::testing::Test {
     config_.rtp.remote_ssrc = 1111;
     config_.rtp.local_ssrc = 2222;
     config_.renderer = &fake_renderer_;
+    config_.decoder_factory = &fake_decoder_factory_;
     VideoReceiveStream::Decoder fake_decoder;
     fake_decoder.payload_type = 99;
     fake_decoder.video_format = SdpVideoFormat("VP8");
-    fake_decoder.decoder_factory = &fake_decoder_factory_;
     config_.decoders.push_back(fake_decoder);
     clock_ = Clock::GetRealTimeClock();
     ReCreateReceiveStream(VideoReceiveStream::RecordingState());
@@ -467,10 +467,10 @@ class VideoReceiveStream2TestWithSimulatedClock : public ::testing::Test {
     config.rtp.remote_ssrc = 1111;
     config.rtp.local_ssrc = 2222;
     config.renderer = renderer;
+    config.decoder_factory = decoder_factory;
     VideoReceiveStream::Decoder fake_decoder;
     fake_decoder.payload_type = 99;
     fake_decoder.video_format = SdpVideoFormat("VP8");
-    fake_decoder.decoder_factory = decoder_factory;
     config.decoders.push_back(fake_decoder);
     return config;
   }

video/video_receive_stream_unittest.cc

@@ -104,12 +104,12 @@ class VideoReceiveStreamTest : public ::testing::Test {
     config_.rtp.remote_ssrc = 1111;
     config_.rtp.local_ssrc = 2222;
     config_.renderer = &fake_renderer_;
+    config_.decoder_factory = &h264_decoder_factory_;
     VideoReceiveStream::Decoder h264_decoder;
     h264_decoder.payload_type = 99;
     h264_decoder.video_format = SdpVideoFormat("H264");
     h264_decoder.video_format.parameters.insert(
         {"sprop-parameter-sets", "Z0IACpZTBYmI,aMljiA=="});
-    h264_decoder.decoder_factory = &h264_decoder_factory_;
     config_.decoders.push_back(h264_decoder);
 
     clock_ = Clock::GetRealTimeClock();
@@ -241,10 +241,10 @@ class VideoReceiveStreamTestWithFakeDecoder : public ::testing::Test {
     config_.rtp.remote_ssrc = 1111;
     config_.rtp.local_ssrc = 2222;
     config_.renderer = &fake_renderer_;
+    config_.decoder_factory = &fake_decoder_factory_;
     VideoReceiveStream::Decoder fake_decoder;
     fake_decoder.payload_type = 99;
     fake_decoder.video_format = SdpVideoFormat("VP8");
-    fake_decoder.decoder_factory = &fake_decoder_factory_;
     config_.decoders.push_back(fake_decoder);
     clock_ = Clock::GetRealTimeClock();
     ReCreateReceiveStream(VideoReceiveStream::RecordingState());
@@ -463,10 +463,10 @@ class VideoReceiveStreamTestWithSimulatedClock : public ::testing::Test {
     config.rtp.remote_ssrc = 1111;
     config.rtp.local_ssrc = 2222;
     config.renderer = renderer;
+    config.decoder_factory = decoder_factory;
     VideoReceiveStream::Decoder fake_decoder;
     fake_decoder.payload_type = 99;
     fake_decoder.video_format = SdpVideoFormat("VP8");
-    fake_decoder.decoder_factory = decoder_factory;
     config.decoders.push_back(fake_decoder);
     return config;
   }