Rename VideoReceiveStream to VideoReceiveStreamInterface

Bug: webrtc:7484
Change-Id: I653cfe46486e0396897dd333069a894d67e3c07b
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/262769
Commit-Queue: Tomas Gunnarsson <tommi@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36958}

call/bitrate_estimator_tests.cc

@@ -141,7 +141,8 @@ class BitrateEstimatorTest : public test::CallTest {
       test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
       SetVideoEncoderConfig(video_encoder_config);
 
-      receive_config_ = VideoReceiveStream::Config(receive_transport_.get());
+      receive_config_ =
+          VideoReceiveStreamInterface::Config(receive_transport_.get());
       // receive_config_.decoders will be set by every stream separately.
       receive_config_.rtp.remote_ssrc = GetVideoSendConfig()->rtp.ssrcs[0];
       receive_config_.rtp.local_ssrc = kReceiverLocalVideoSsrc;
@@ -195,7 +196,7 @@ class BitrateEstimatorTest : public test::CallTest {
                               DegradationPreference::MAINTAIN_FRAMERATE);
       send_stream_->Start();
 
-      VideoReceiveStream::Decoder decoder;
+      VideoReceiveStreamInterface::Decoder decoder;
       test_->receive_config_.decoder_factory = &decoder_factory_;
       decoder.payload_type = test_->GetVideoSendConfig()->rtp.payload_type;
       decoder.video_format =
@@ -237,7 +238,7 @@ class BitrateEstimatorTest : public test::CallTest {
     BitrateEstimatorTest* test_;
     bool is_sending_receiving_;
     VideoSendStream* send_stream_;
-    VideoReceiveStream* video_receive_stream_;
+    VideoReceiveStreamInterface* video_receive_stream_;
     std::unique_ptr<test::FrameGeneratorCapturer> frame_generator_capturer_;
 
     test::FunctionVideoDecoderFactory decoder_factory_;
@@ -246,7 +247,7 @@ class BitrateEstimatorTest : public test::CallTest {
   LogObserver receiver_log_;
   std::unique_ptr<test::DirectTransport> send_transport_;
   std::unique_ptr<test::DirectTransport> receive_transport_;
-  VideoReceiveStream::Config receive_config_;
+  VideoReceiveStreamInterface::Config receive_config_;
   std::vector<Stream*> streams_;
 };
 

call/call.cc

@@ -99,7 +99,7 @@ const int* FindKeyByValue(const std::map<int, int>& m, int v) {
 }
 
 std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig(
-    const VideoReceiveStream::Config& config) {
+    const VideoReceiveStreamInterface::Config& config) {
   auto rtclog_config = std::make_unique<rtclog::StreamConfig>();
   rtclog_config->remote_ssrc = config.rtp.remote_ssrc;
   rtclog_config->local_ssrc = config.rtp.local_ssrc;
@@ -231,10 +231,10 @@ class Call final : public webrtc::Call,
       std::unique_ptr<FecController> fec_controller) override;
   void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override;
 
-  webrtc::VideoReceiveStream* CreateVideoReceiveStream(
+  webrtc::VideoReceiveStreamInterface* CreateVideoReceiveStream(
-      webrtc::VideoReceiveStream::Config configuration) override;
+      webrtc::VideoReceiveStreamInterface::Config configuration) override;
   void DestroyVideoReceiveStream(
-      webrtc::VideoReceiveStream* receive_stream) override;
+      webrtc::VideoReceiveStreamInterface* receive_stream) override;
 
   FlexfecReceiveStream* CreateFlexfecReceiveStream(
       const FlexfecReceiveStream::Config config) override;
@@ -267,7 +267,7 @@ class Call final : public webrtc::Call,
 
   void OnLocalSsrcUpdated(webrtc::AudioReceiveStream& stream,
                           uint32_t local_ssrc) override;
-  void OnLocalSsrcUpdated(VideoReceiveStream& stream,
+  void OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream,
                           uint32_t local_ssrc) override;
   void OnLocalSsrcUpdated(FlexfecReceiveStream& stream,
                           uint32_t local_ssrc) override;
@@ -1139,8 +1139,8 @@ void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
   delete send_stream_impl;
 }
 
-webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
+webrtc::VideoReceiveStreamInterface* Call::CreateVideoReceiveStream(
-    webrtc::VideoReceiveStream::Config configuration) {
+    webrtc::VideoReceiveStreamInterface::Config configuration) {
   TRACE_EVENT0("webrtc", "Call::CreateVideoReceiveStream");
   RTC_DCHECK_RUN_ON(worker_thread_);
 
@@ -1183,7 +1183,7 @@ webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
 }
 
 void Call::DestroyVideoReceiveStream(
-    webrtc::VideoReceiveStream* receive_stream) {
+    webrtc::VideoReceiveStreamInterface* receive_stream) {
   TRACE_EVENT0("webrtc", "Call::DestroyVideoReceiveStream");
   RTC_DCHECK_RUN_ON(worker_thread_);
   RTC_DCHECK(receive_stream != nullptr);
@@ -1392,7 +1392,8 @@ void Call::OnLocalSsrcUpdated(webrtc::AudioReceiveStream& stream,
                                                                    : nullptr);
 }
 
-void Call::OnLocalSsrcUpdated(VideoReceiveStream& stream, uint32_t local_ssrc) {
+void Call::OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream,
+                              uint32_t local_ssrc) {
   RTC_DCHECK_RUN_ON(worker_thread_);
   static_cast<VideoReceiveStream2&>(stream).SetLocalSsrc(local_ssrc);
 }

call/call.h

@@ -119,12 +119,12 @@ class Call {
       std::unique_ptr<FecController> fec_controller);
   virtual void DestroyVideoSendStream(VideoSendStream* send_stream) = 0;
 
-  virtual VideoReceiveStream* CreateVideoReceiveStream(
+  virtual VideoReceiveStreamInterface* CreateVideoReceiveStream(
-      VideoReceiveStream::Config configuration) = 0;
+      VideoReceiveStreamInterface::Config configuration) = 0;
   virtual void DestroyVideoReceiveStream(
-      VideoReceiveStream* receive_stream) = 0;
+      VideoReceiveStreamInterface* receive_stream) = 0;
 
-  // In order for a created VideoReceiveStream to be aware that it is
+  // In order for a created VideoReceiveStreamInterface to be aware that it is
   // protected by a FlexfecReceiveStream, the latter should be created before
   // the former.
   virtual FlexfecReceiveStream* CreateFlexfecReceiveStream(
@@ -166,7 +166,7 @@ class Call {
   // send streams needs to be updated.
   virtual void OnLocalSsrcUpdated(AudioReceiveStream& stream,
                                   uint32_t local_ssrc) = 0;
-  virtual void OnLocalSsrcUpdated(VideoReceiveStream& stream,
+  virtual void OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream,
                                   uint32_t local_ssrc) = 0;
   virtual void OnLocalSsrcUpdated(FlexfecReceiveStream& stream,
                                   uint32_t local_ssrc) = 0;

call/call_perf_tests.cc

@@ -120,7 +120,7 @@ class VideoRtcpAndSyncObserver : public test::RtpRtcpObserver,
     if (!receive_stream_)
       return;
 
-    VideoReceiveStream::Stats stats = receive_stream_->GetStats();
+    VideoReceiveStreamInterface::Stats stats = receive_stream_->GetStats();
     if (stats.sync_offset_ms == std::numeric_limits<int>::max())
       return;
 
@@ -144,7 +144,7 @@ class VideoRtcpAndSyncObserver : public test::RtpRtcpObserver,
       sync_offset_ms_list_.push_back(stats.sync_offset_ms);
   }
 
-  void set_receive_stream(VideoReceiveStream* receive_stream) {
+  void set_receive_stream(VideoReceiveStreamInterface* receive_stream) {
     RTC_DCHECK_EQ(task_queue_, TaskQueueBase::Current());
     // Note that receive_stream may be nullptr.
     receive_stream_ = receive_stream;
@@ -160,7 +160,7 @@ class VideoRtcpAndSyncObserver : public test::RtpRtcpObserver,
   const std::string test_label_;
   const int64_t creation_time_ms_;
   int64_t first_time_in_sync_ = -1;
-  VideoReceiveStream* receive_stream_ = nullptr;
+  VideoReceiveStreamInterface* receive_stream_ = nullptr;
   std::vector<double> sync_offset_ms_list_;
   TaskQueueBase* const task_queue_;
 };
@@ -485,7 +485,7 @@ void CallPerfTest::TestCaptureNtpTime(
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       (*receive_configs)[0].renderer = this;
       // Enable the receiver side rtt calculation.
@@ -629,7 +629,7 @@ TEST_F(CallPerfTest, ReceivesCpuOveruseAndUnderuse) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {}
 
     void PerformTest() override {
@@ -702,9 +702,9 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
       return SEND_PACKET;
     }
 
-    void OnVideoStreamsCreated(
+    void OnVideoStreamsCreated(VideoSendStream* send_stream,
-        VideoSendStream* send_stream,
+                               const std::vector<VideoReceiveStreamInterface*>&
-        const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                   receive_streams) override {
       send_stream_ = send_stream;
     }
 
@@ -712,7 +712,7 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       if (pad_to_min_bitrate_) {
         encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps;
@@ -843,7 +843,7 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder_factory = &encoder_factory_;
       send_config->encoder_settings.bitrate_allocator_factory =
@@ -855,9 +855,9 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
       encoder_config_ = encoder_config->Copy();
     }
 
-    void OnVideoStreamsCreated(
+    void OnVideoStreamsCreated(VideoSendStream* send_stream,
-        VideoSendStream* send_stream,
+                               const std::vector<VideoReceiveStreamInterface*>&
-        const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                   receive_streams) override {
       send_stream_ = send_stream;
     }
 
@@ -1094,9 +1094,9 @@ void CallPerfTest::TestEncodeFramerate(VideoEncoderFactory* encoder_factory,
       bitrate_config->start_bitrate_bps = kMaxBitrate.bps() / 2;
     }
 
-    void OnVideoStreamsCreated(
+    void OnVideoStreamsCreated(VideoSendStream* send_stream,
-        VideoSendStream* send_stream,
+                               const std::vector<VideoReceiveStreamInterface*>&
-        const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                   receive_streams) override {
       send_stream_ = send_stream;
     }
 
@@ -1106,7 +1106,7 @@ void CallPerfTest::TestEncodeFramerate(VideoEncoderFactory* encoder_factory,
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder_factory = encoder_factory_;
       send_config->rtp.payload_name = payload_name_;

call/degraded_call.cc

@@ -237,13 +237,13 @@ void DegradedCall::DestroyVideoSendStream(VideoSendStream* send_stream) {
   video_send_transport_adapters_.erase(send_stream);
 }
 
-VideoReceiveStream* DegradedCall::CreateVideoReceiveStream(
+VideoReceiveStreamInterface* DegradedCall::CreateVideoReceiveStream(
-    VideoReceiveStream::Config configuration) {
+    VideoReceiveStreamInterface::Config configuration) {
   return call_->CreateVideoReceiveStream(std::move(configuration));
 }
 
 void DegradedCall::DestroyVideoReceiveStream(
-    VideoReceiveStream* receive_stream) {
+    VideoReceiveStreamInterface* receive_stream) {
   call_->DestroyVideoReceiveStream(receive_stream);
 }
 
@@ -305,7 +305,7 @@ void DegradedCall::OnLocalSsrcUpdated(AudioReceiveStream& stream,
   call_->OnLocalSsrcUpdated(stream, local_ssrc);
 }
 
-void DegradedCall::OnLocalSsrcUpdated(VideoReceiveStream& stream,
+void DegradedCall::OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream,
                                       uint32_t local_ssrc) {
   call_->OnLocalSsrcUpdated(stream, local_ssrc);
 }

call/degraded_call.h

@@ -74,9 +74,10 @@ class DegradedCall : public Call, private PacketReceiver {
       std::unique_ptr<FecController> fec_controller) override;
   void DestroyVideoSendStream(VideoSendStream* send_stream) override;
 
-  VideoReceiveStream* CreateVideoReceiveStream(
+  VideoReceiveStreamInterface* CreateVideoReceiveStream(
-      VideoReceiveStream::Config configuration) override;
+      VideoReceiveStreamInterface::Config configuration) override;
-  void DestroyVideoReceiveStream(VideoReceiveStream* receive_stream) override;
+  void DestroyVideoReceiveStream(
+      VideoReceiveStreamInterface* receive_stream) override;
 
   FlexfecReceiveStream* CreateFlexfecReceiveStream(
       const FlexfecReceiveStream::Config config) override;
@@ -101,7 +102,7 @@ class DegradedCall : public Call, private PacketReceiver {
       int transport_overhead_per_packet) override;
   void OnLocalSsrcUpdated(AudioReceiveStream& stream,
                           uint32_t local_ssrc) override;
-  void OnLocalSsrcUpdated(VideoReceiveStream& stream,
+  void OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream,
                           uint32_t local_ssrc) override;
   void OnLocalSsrcUpdated(FlexfecReceiveStream& stream,
                           uint32_t local_ssrc) override;

call/rampup_tests.cc

@@ -103,7 +103,7 @@ void RampUpTester::ModifySenderBitrateConfig(
 
 void RampUpTester::OnVideoStreamsCreated(
     VideoSendStream* send_stream,
-    const std::vector<VideoReceiveStream*>& receive_streams) {
+    const std::vector<VideoReceiveStreamInterface*>& receive_streams) {
   send_stream_ = send_stream;
 }
 
@@ -154,7 +154,7 @@ class RampUpTester::VideoStreamFactory
 
 void RampUpTester::ModifyVideoConfigs(
     VideoSendStream::Config* send_config,
-    std::vector<VideoReceiveStream::Config>* receive_configs,
+    std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
     VideoEncoderConfig* encoder_config) {
   send_config->suspend_below_min_bitrate = true;
   encoder_config->number_of_streams = num_video_streams_;
@@ -214,7 +214,7 @@ void RampUpTester::ModifyVideoConfigs(
   }
 
   size_t i = 0;
-  for (VideoReceiveStream::Config& recv_config : *receive_configs) {
+  for (VideoReceiveStreamInterface::Config& recv_config : *receive_configs) {
     recv_config.rtp.transport_cc = transport_cc;
     recv_config.rtp.extensions = send_config->rtp.extensions;
     recv_config.decoders.reserve(1);

call/rampup_tests.h

@@ -90,15 +90,15 @@ class RampUpTester : public test::EndToEndTest {
   class VideoStreamFactory;
 
   void ModifySenderBitrateConfig(BitrateConstraints* bitrate_config) override;
-  void OnVideoStreamsCreated(
+  void OnVideoStreamsCreated(VideoSendStream* send_stream,
-      VideoSendStream* send_stream,
+                             const std::vector<VideoReceiveStreamInterface*>&
-      const std::vector<VideoReceiveStream*>& receive_streams) override;
+                                 receive_streams) override;
   std::unique_ptr<test::PacketTransport> CreateSendTransport(
       TaskQueueBase* task_queue,
       Call* sender_call) override;
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override;
   void ModifyAudioConfigs(
       AudioSendStream::Config* send_config,

call/syncable.h

@@ -8,8 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-// Syncable is used by RtpStreamsSynchronizer in VideoReceiveStream, and
+// Syncable is used by RtpStreamsSynchronizer in VideoReceiveStreamInterface,
-// implemented by AudioReceiveStream.
+// and implemented by AudioReceiveStream.
 
 #ifndef CALL_SYNCABLE_H_
 #define CALL_SYNCABLE_H_

call/video_receive_stream.cc

@@ -14,19 +14,20 @@
 
 namespace webrtc {
 
-VideoReceiveStream::Decoder::Decoder(SdpVideoFormat video_format,
+VideoReceiveStreamInterface::Decoder::Decoder(SdpVideoFormat video_format,
-                                     int payload_type)
+                                              int payload_type)
     : video_format(std::move(video_format)), payload_type(payload_type) {}
-VideoReceiveStream::Decoder::Decoder() : video_format("Unset") {}
+VideoReceiveStreamInterface::Decoder::Decoder() : video_format("Unset") {}
-VideoReceiveStream::Decoder::Decoder(const Decoder&) = default;
+VideoReceiveStreamInterface::Decoder::Decoder(const Decoder&) = default;
-VideoReceiveStream::Decoder::~Decoder() = default;
+VideoReceiveStreamInterface::Decoder::~Decoder() = default;
 
-bool VideoReceiveStream::Decoder::operator==(const Decoder& other) const {
+bool VideoReceiveStreamInterface::Decoder::operator==(
+    const Decoder& other) const {
   return payload_type == other.payload_type &&
          video_format == other.video_format;
 }
 
-std::string VideoReceiveStream::Decoder::ToString() const {
+std::string VideoReceiveStreamInterface::Decoder::ToString() const {
   char buf[1024];
   rtc::SimpleStringBuilder ss(buf);
   ss << "{payload_type: " << payload_type;
@@ -45,13 +46,15 @@ std::string VideoReceiveStream::Decoder::ToString() const {
   return ss.str();
 }
 
-VideoReceiveStream::Stats::Stats() = default;
+VideoReceiveStreamInterface::Stats::Stats() = default;
-VideoReceiveStream::Stats::~Stats() = default;
+VideoReceiveStreamInterface::Stats::~Stats() = default;
 
-std::string VideoReceiveStream::Stats::ToString(int64_t time_ms) const {
+std::string VideoReceiveStreamInterface::Stats::ToString(
+    int64_t time_ms) const {
   char buf[2048];
   rtc::SimpleStringBuilder ss(buf);
-  ss << "VideoReceiveStream stats: " << time_ms << ", {ssrc: " << ssrc << ", ";
+  ss << "VideoReceiveStreamInterface stats: " << time_ms << ", {ssrc: " << ssrc
+     << ", ";
   ss << "total_bps: " << total_bitrate_bps << ", ";
   ss << "width: " << width << ", ";
   ss << "height: " << height << ", ";
@@ -80,18 +83,19 @@ std::string VideoReceiveStream::Stats::ToString(int64_t time_ms) const {
   return ss.str();
 }
 
-VideoReceiveStream::Config::Config(const Config&) = default;
+VideoReceiveStreamInterface::Config::Config(const Config&) = default;
-VideoReceiveStream::Config::Config(Config&&) = default;
+VideoReceiveStreamInterface::Config::Config(Config&&) = default;
-VideoReceiveStream::Config::Config(Transport* rtcp_send_transport,
+VideoReceiveStreamInterface::Config::Config(
-                                   VideoDecoderFactory* decoder_factory)
+    Transport* rtcp_send_transport,
+    VideoDecoderFactory* decoder_factory)
     : decoder_factory(decoder_factory),
       rtcp_send_transport(rtcp_send_transport) {}
 
-VideoReceiveStream::Config& VideoReceiveStream::Config::operator=(Config&&) =
+VideoReceiveStreamInterface::Config&
-    default;
+VideoReceiveStreamInterface::Config::operator=(Config&&) = default;
-VideoReceiveStream::Config::Config::~Config() = default;
+VideoReceiveStreamInterface::Config::Config::~Config() = default;
 
-std::string VideoReceiveStream::Config::ToString() const {
+std::string VideoReceiveStreamInterface::Config::ToString() const {
   char buf[4 * 1024];
   rtc::SimpleStringBuilder ss(buf);
   ss << "{decoders: [";
@@ -112,11 +116,11 @@ std::string VideoReceiveStream::Config::ToString() const {
   return ss.str();
 }
 
-VideoReceiveStream::Config::Rtp::Rtp() = default;
+VideoReceiveStreamInterface::Config::Rtp::Rtp() = default;
-VideoReceiveStream::Config::Rtp::Rtp(const Rtp&) = default;
+VideoReceiveStreamInterface::Config::Rtp::Rtp(const Rtp&) = default;
-VideoReceiveStream::Config::Rtp::~Rtp() = default;
+VideoReceiveStreamInterface::Config::Rtp::~Rtp() = default;
 
-std::string VideoReceiveStream::Config::Rtp::ToString() const {
+std::string VideoReceiveStreamInterface::Config::Rtp::ToString() const {
   char buf[2 * 1024];
   rtc::SimpleStringBuilder ss(buf);
   ss << "{remote_ssrc: " << remote_ssrc;

call/video_receive_stream.h

@@ -39,7 +39,7 @@ namespace webrtc {
 class RtpPacketSinkInterface;
 class VideoDecoderFactory;
 
-class VideoReceiveStream : public MediaReceiveStreamInterface {
+class VideoReceiveStreamInterface : public MediaReceiveStreamInterface {
  public:
   // Class for handling moving in/out recording state.
   struct RecordingState {
@@ -48,11 +48,11 @@ class VideoReceiveStream : public MediaReceiveStreamInterface {
         std::function<void(const RecordableEncodedFrame&)> callback)
         : callback(std::move(callback)) {}
 
-    // Callback stored from the VideoReceiveStream. The VideoReceiveStream
+    // Callback stored from the VideoReceiveStreamInterface. The
-    // client should not interpret the attribute.
+    // VideoReceiveStreamInterface client should not interpret the attribute.
     std::function<void(const RecordableEncodedFrame&)> callback;
-    // Memento of when a keyframe request was last sent. The VideoReceiveStream
+    // Memento of when a keyframe request was last sent. The
-    // client should not interpret the attribute.
+    // VideoReceiveStreamInterface client should not interpret the attribute.
     absl::optional<int64_t> last_keyframe_request_ms;
   };
 
@@ -290,9 +290,13 @@ class VideoReceiveStream : public MediaReceiveStreamInterface {
   virtual void GenerateKeyFrame() = 0;
 
  protected:
-  virtual ~VideoReceiveStream() {}
+  virtual ~VideoReceiveStreamInterface() {}
 };
 
+// TODO(bugs.webrtc.org/7484): Remove this once downstream usage of the
+// deprecated name is gone.
+using VideoReceiveStream [[deprecated]] = VideoReceiveStreamInterface;
+
 }  // namespace webrtc
 
 #endif  // CALL_VIDEO_RECEIVE_STREAM_H_

media/engine/fake_webrtc_call.cc

@@ -364,11 +364,11 @@ void FakeVideoSendStream::InjectVideoSinkWants(
 }
 
 FakeVideoReceiveStream::FakeVideoReceiveStream(
-    webrtc::VideoReceiveStream::Config config)
+    webrtc::VideoReceiveStreamInterface::Config config)
     : config_(std::move(config)), receiving_(false) {}
 
-const webrtc::VideoReceiveStream::Config& FakeVideoReceiveStream::GetConfig()
+const webrtc::VideoReceiveStreamInterface::Config&
-    const {
+FakeVideoReceiveStream::GetConfig() const {
   return config_;
 }
 
@@ -380,7 +380,8 @@ void FakeVideoReceiveStream::InjectFrame(const webrtc::VideoFrame& frame) {
   config_.renderer->OnFrame(frame);
 }
 
-webrtc::VideoReceiveStream::Stats FakeVideoReceiveStream::GetStats() const {
+webrtc::VideoReceiveStreamInterface::Stats FakeVideoReceiveStream::GetStats()
+    const {
   return stats_;
 }
 
@@ -403,7 +404,7 @@ void FakeVideoReceiveStream::Stop() {
 }
 
 void FakeVideoReceiveStream::SetStats(
-    const webrtc::VideoReceiveStream::Stats& stats) {
+    const webrtc::VideoReceiveStreamInterface::Stats& stats) {
   stats_ = stats;
 }
 
@@ -583,8 +584,8 @@ void FakeCall::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
   }
 }
 
-webrtc::VideoReceiveStream* FakeCall::CreateVideoReceiveStream(
+webrtc::VideoReceiveStreamInterface* FakeCall::CreateVideoReceiveStream(
-    webrtc::VideoReceiveStream::Config config) {
+    webrtc::VideoReceiveStreamInterface::Config config) {
   video_receive_streams_.push_back(
       new FakeVideoReceiveStream(std::move(config)));
   ++num_created_receive_streams_;
@@ -592,7 +593,7 @@ webrtc::VideoReceiveStream* FakeCall::CreateVideoReceiveStream(
 }
 
 void FakeCall::DestroyVideoReceiveStream(
-    webrtc::VideoReceiveStream* receive_stream) {
+    webrtc::VideoReceiveStreamInterface* receive_stream) {
   auto it = absl::c_find(video_receive_streams_,
                          static_cast<FakeVideoReceiveStream*>(receive_stream));
   if (it == video_receive_streams_.end()) {
@@ -714,7 +715,7 @@ void FakeCall::OnLocalSsrcUpdated(webrtc::AudioReceiveStream& stream,
   fake_stream.SetLocalSsrc(local_ssrc);
 }
 
-void FakeCall::OnLocalSsrcUpdated(webrtc::VideoReceiveStream& stream,
+void FakeCall::OnLocalSsrcUpdated(webrtc::VideoReceiveStreamInterface& stream,
                                   uint32_t local_ssrc) {
   auto& fake_stream = static_cast<FakeVideoReceiveStream&>(stream);
   fake_stream.SetLocalSsrc(local_ssrc);

media/engine/fake_webrtc_call.h

@@ -15,7 +15,7 @@
 //   webrtc::AudioSendStream
 //   webrtc::AudioReceiveStream
 //   webrtc::VideoSendStream
-//   webrtc::VideoReceiveStream
+//   webrtc::VideoReceiveStreamInterface
 
 #ifndef MEDIA_ENGINE_FAKE_WEBRTC_CALL_H_
 #define MEDIA_ENGINE_FAKE_WEBRTC_CALL_H_
@@ -231,17 +231,19 @@ class FakeVideoSendStream final
   int num_encoder_reconfigurations_ = 0;
 };
 
-class FakeVideoReceiveStream final : public webrtc::VideoReceiveStream {
+class FakeVideoReceiveStream final
+    : public webrtc::VideoReceiveStreamInterface {
  public:
-  explicit FakeVideoReceiveStream(webrtc::VideoReceiveStream::Config config);
+  explicit FakeVideoReceiveStream(
+      webrtc::VideoReceiveStreamInterface::Config config);
 
-  const webrtc::VideoReceiveStream::Config& GetConfig() const;
+  const webrtc::VideoReceiveStreamInterface::Config& GetConfig() const;
 
   bool IsReceiving() const;
 
   void InjectFrame(const webrtc::VideoFrame& frame);
 
-  void SetStats(const webrtc::VideoReceiveStream::Stats& stats);
+  void SetStats(const webrtc::VideoReceiveStreamInterface::Stats& stats);
 
   std::vector<webrtc::RtpSource> GetSources() const override {
     return std::vector<webrtc::RtpSource>();
@@ -269,7 +271,7 @@ class FakeVideoReceiveStream final : public webrtc::VideoReceiveStream {
   void GenerateKeyFrame() override {}
 
  private:
-  // webrtc::VideoReceiveStream implementation.
+  // webrtc::VideoReceiveStreamInterface implementation.
   void SetRtpExtensions(std::vector<webrtc::RtpExtension> extensions) override;
   webrtc::RtpHeaderExtensionMap GetRtpExtensionMap() const override;
   bool transport_cc() const override { return config_.rtp.transport_cc; }
@@ -277,7 +279,7 @@ class FakeVideoReceiveStream final : public webrtc::VideoReceiveStream {
   void Start() override;
   void Stop() override;
 
-  webrtc::VideoReceiveStream::Stats GetStats() const override;
+  webrtc::VideoReceiveStreamInterface::Stats GetStats() const override;
 
   bool SetBaseMinimumPlayoutDelayMs(int delay_ms) override {
     base_mininum_playout_delay_ms_ = delay_ms;
@@ -288,9 +290,9 @@ class FakeVideoReceiveStream final : public webrtc::VideoReceiveStream {
     return base_mininum_playout_delay_ms_;
   }
 
-  webrtc::VideoReceiveStream::Config config_;
+  webrtc::VideoReceiveStreamInterface::Config config_;
   bool receiving_;
-  webrtc::VideoReceiveStream::Stats stats_;
+  webrtc::VideoReceiveStreamInterface::Stats stats_;
 
   int base_mininum_playout_delay_ms_ = 0;
 };
@@ -385,10 +387,10 @@ class FakeCall final : public webrtc::Call, public webrtc::PacketReceiver {
       webrtc::VideoEncoderConfig encoder_config) override;
   void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override;
 
-  webrtc::VideoReceiveStream* CreateVideoReceiveStream(
+  webrtc::VideoReceiveStreamInterface* CreateVideoReceiveStream(
-      webrtc::VideoReceiveStream::Config config) override;
+      webrtc::VideoReceiveStreamInterface::Config config) override;
   void DestroyVideoReceiveStream(
-      webrtc::VideoReceiveStream* receive_stream) override;
+      webrtc::VideoReceiveStreamInterface* receive_stream) override;
 
   webrtc::FlexfecReceiveStream* CreateFlexfecReceiveStream(
       const webrtc::FlexfecReceiveStream::Config config) override;
@@ -420,7 +422,7 @@ class FakeCall final : public webrtc::Call, public webrtc::PacketReceiver {
       int transport_overhead_per_packet) override;
   void OnLocalSsrcUpdated(webrtc::AudioReceiveStream& stream,
                           uint32_t local_ssrc) override;
-  void OnLocalSsrcUpdated(webrtc::VideoReceiveStream& stream,
+  void OnLocalSsrcUpdated(webrtc::VideoReceiveStreamInterface& stream,
                           uint32_t local_ssrc) override;
   void OnLocalSsrcUpdated(webrtc::FlexfecReceiveStream& stream,
                           uint32_t local_ssrc) override;

media/engine/webrtc_video_engine.cc

@@ -1467,7 +1467,7 @@ bool WebRtcVideoChannel::AddRecvStream(const StreamParams& sp,
   for (uint32_t used_ssrc : sp.ssrcs)
     receive_ssrcs_.insert(used_ssrc);
 
-  webrtc::VideoReceiveStream::Config config(this, decoder_factory_);
+  webrtc::VideoReceiveStreamInterface::Config config(this, decoder_factory_);
   webrtc::FlexfecReceiveStream::Config flexfec_config(this);
   ConfigureReceiverRtp(&config, &flexfec_config, sp);
 
@@ -1489,7 +1489,7 @@ bool WebRtcVideoChannel::AddRecvStream(const StreamParams& sp,
 }
 
 void WebRtcVideoChannel::ConfigureReceiverRtp(
-    webrtc::VideoReceiveStream::Config* config,
+    webrtc::VideoReceiveStreamInterface::Config* config,
     webrtc::FlexfecReceiveStream::Config* flexfec_config,
     const StreamParams& sp) const {
   uint32_t ssrc = sp.first_ssrc();
@@ -2804,7 +2804,7 @@ WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
     WebRtcVideoChannel* channel,
     webrtc::Call* call,
     const StreamParams& sp,
-    webrtc::VideoReceiveStream::Config config,
+    webrtc::VideoReceiveStreamInterface::Config config,
     bool default_stream,
     const std::vector<VideoCodecSettings>& recv_codecs,
     const webrtc::FlexfecReceiveStream::Config& flexfec_config)
@@ -2832,7 +2832,7 @@ WebRtcVideoChannel::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() {
     call_->DestroyFlexfecReceiveStream(flexfec_stream_);
 }
 
-webrtc::VideoReceiveStream&
+webrtc::VideoReceiveStreamInterface&
 WebRtcVideoChannel::WebRtcVideoReceiveStream::stream() {
   RTC_DCHECK(stream_);
   return *stream_;
@@ -2878,7 +2878,7 @@ bool WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs(
 
   std::map<int, int> rtx_associated_payload_types;
   std::set<int> raw_payload_types;
-  std::vector<webrtc::VideoReceiveStream::Decoder> decoders;
+  std::vector<webrtc::VideoReceiveStreamInterface::Decoder> decoders;
   for (const auto& recv_codec : recv_codecs) {
     decoders.emplace_back(
         webrtc::SdpVideoFormat(recv_codec.codec.name, recv_codec.codec.params),
@@ -3028,11 +3028,12 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetRecvParameters(
 
 void WebRtcVideoChannel::WebRtcVideoReceiveStream::RecreateReceiveStream() {
   absl::optional<int> base_minimum_playout_delay_ms;
-  absl::optional<webrtc::VideoReceiveStream::RecordingState> recording_state;
+  absl::optional<webrtc::VideoReceiveStreamInterface::RecordingState>
+      recording_state;
   if (stream_) {
     base_minimum_playout_delay_ms = stream_->GetBaseMinimumPlayoutDelayMs();
     recording_state = stream_->SetAndGetRecordingState(
-        webrtc::VideoReceiveStream::RecordingState(),
+        webrtc::VideoReceiveStreamInterface::RecordingState(),
         /*generate_key_frame=*/false);
     call_->DestroyVideoReceiveStream(stream_);
     stream_ = nullptr;
@@ -3047,7 +3048,7 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::RecreateReceiveStream() {
     flexfec_stream_ = call_->CreateFlexfecReceiveStream(flexfec_config_);
   }
 
-  webrtc::VideoReceiveStream::Config config = config_.Copy();
+  webrtc::VideoReceiveStreamInterface::Config config = config_.Copy();
   config.rtp.protected_by_flexfec = (flexfec_stream_ != nullptr);
   config.rtp.packet_sink_ = flexfec_stream_;
   stream_ = call_->CreateVideoReceiveStream(std::move(config));
@@ -3079,7 +3080,8 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::OnFrame(
     estimated_remote_start_ntp_time_ms_ = frame.ntp_time_ms() - elapsed_time_ms;
 
   if (sink_ == NULL) {
-    RTC_LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoSink.";
+    RTC_LOG(LS_WARNING)
+        << "VideoReceiveStreamInterface not connected to a VideoSink.";
     return;
   }
 
@@ -3121,7 +3123,8 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetSink(
 std::string
 WebRtcVideoChannel::WebRtcVideoReceiveStream::GetCodecNameFromPayloadType(
     int payload_type) {
-  for (const webrtc::VideoReceiveStream::Decoder& decoder : config_.decoders) {
+  for (const webrtc::VideoReceiveStreamInterface::Decoder& decoder :
+       config_.decoders) {
     if (decoder.payload_type == payload_type) {
       return decoder.video_format.name;
     }
@@ -3135,7 +3138,7 @@ WebRtcVideoChannel::WebRtcVideoReceiveStream::GetVideoReceiverInfo(
   VideoReceiverInfo info;
   info.ssrc_groups = stream_params_.ssrc_groups;
   info.add_ssrc(config_.rtp.remote_ssrc);
-  webrtc::VideoReceiveStream::Stats stats = stream_->GetStats();
+  webrtc::VideoReceiveStreamInterface::Stats stats = stream_->GetStats();
   info.decoder_implementation_name = stats.decoder_implementation_name;
   if (stats.current_payload_type != -1) {
     info.codec_payload_type = stats.current_payload_type;
@@ -3218,7 +3221,8 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::
         std::function<void(const webrtc::RecordableEncodedFrame&)> callback) {
   if (stream_) {
     stream_->SetAndGetRecordingState(
-        webrtc::VideoReceiveStream::RecordingState(std::move(callback)),
+        webrtc::VideoReceiveStreamInterface::RecordingState(
+            std::move(callback)),
         /*generate_key_frame=*/true);
   } else {
     RTC_LOG(LS_ERROR) << "Absent receive stream; ignoring setting encoded "
@@ -3230,7 +3234,7 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::
     ClearRecordableEncodedFrameCallback() {
   if (stream_) {
     stream_->SetAndGetRecordingState(
-        webrtc::VideoReceiveStream::RecordingState(),
+        webrtc::VideoReceiveStreamInterface::RecordingState(),
         /*generate_key_frame=*/false);
   } else {
     RTC_LOG(LS_ERROR) << "Absent receive stream; ignoring clearing encoded "

media/engine/webrtc_video_engine.h

@@ -246,8 +246,8 @@ class WebRtcVideoChannel : public VideoMediaChannel,
  private:
   class WebRtcVideoReceiveStream;
 
-  // Finds VideoReceiveStream corresponding to ssrc. Aware of unsignalled ssrc
+  // Finds VideoReceiveStreamInterface corresponding to ssrc. Aware of
-  // handling.
+  // unsignalled ssrc handling.
   WebRtcVideoReceiveStream* FindReceiveStream(uint32_t ssrc)
       RTC_EXCLUSIVE_LOCKS_REQUIRED(thread_checker_);
 
@@ -289,7 +289,7 @@ class WebRtcVideoChannel : public VideoMediaChannel,
     absl::optional<std::vector<webrtc::RtpExtension>> rtp_header_extensions;
     // Keep track of the FlexFEC payload type separately from `codec_settings`.
     // This allows us to recreate the FlexfecReceiveStream separately from the
-    // VideoReceiveStream when the FlexFEC payload type is changed.
+    // VideoReceiveStreamInterface when the FlexFEC payload type is changed.
     absl::optional<int> flexfec_payload_type;
   };
 
@@ -302,7 +302,7 @@ class WebRtcVideoChannel : public VideoMediaChannel,
       RTC_EXCLUSIVE_LOCKS_REQUIRED(thread_checker_);
 
   void ConfigureReceiverRtp(
-      webrtc::VideoReceiveStream::Config* config,
+      webrtc::VideoReceiveStreamInterface::Config* config,
       webrtc::FlexfecReceiveStream::Config* flexfec_config,
       const StreamParams& sp) const
       RTC_EXCLUSIVE_LOCKS_REQUIRED(thread_checker_);
@@ -428,7 +428,7 @@ class WebRtcVideoChannel : public VideoMediaChannel,
   };
 
   // Wrapper for the receiver part, contains configs etc. that are needed to
-  // reconstruct the underlying VideoReceiveStream.
+  // reconstruct the underlying VideoReceiveStreamInterface.
   class WebRtcVideoReceiveStream
       : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
    public:
@@ -436,13 +436,13 @@ class WebRtcVideoChannel : public VideoMediaChannel,
         WebRtcVideoChannel* channel,
         webrtc::Call* call,
         const StreamParams& sp,
-        webrtc::VideoReceiveStream::Config config,
+        webrtc::VideoReceiveStreamInterface::Config config,
         bool default_stream,
         const std::vector<VideoCodecSettings>& recv_codecs,
         const webrtc::FlexfecReceiveStream::Config& flexfec_config);
     ~WebRtcVideoReceiveStream();
 
-    webrtc::VideoReceiveStream& stream();
+    webrtc::VideoReceiveStreamInterface& stream();
     // Return value may be nullptr.
     webrtc::FlexfecReceiveStream* flexfec_stream();
 
@@ -503,9 +503,9 @@ class WebRtcVideoChannel : public VideoMediaChannel,
     // Both `stream_` and `flexfec_stream_` are managed by `this`. They are
     // destroyed by calling call_->DestroyVideoReceiveStream and
     // call_->DestroyFlexfecReceiveStream, respectively.
-    webrtc::VideoReceiveStream* stream_;
+    webrtc::VideoReceiveStreamInterface* stream_;
     const bool default_stream_;
-    webrtc::VideoReceiveStream::Config config_;
+    webrtc::VideoReceiveStreamInterface::Config config_;
     webrtc::FlexfecReceiveStream::Config flexfec_config_;
     webrtc::FlexfecReceiveStream* flexfec_stream_;
 

media/engine/webrtc_video_engine_unittest.cc

@@ -153,15 +153,16 @@ const int* FindKeyByValue(const std::map<int, int>& m, int v) {
   return nullptr;
 }
 
-bool HasRtxReceiveAssociation(const webrtc::VideoReceiveStream::Config& config,
+bool HasRtxReceiveAssociation(
-                              int payload_type) {
+    const webrtc::VideoReceiveStreamInterface::Config& config,
+    int payload_type) {
   return FindKeyByValue(config.rtp.rtx_associated_payload_types,
                         payload_type) != nullptr;
 }
 
 // Check that there's an Rtx payload type for each decoder.
 bool VerifyRtxReceiveAssociations(
-    const webrtc::VideoReceiveStream::Config& config) {
+    const webrtc::VideoReceiveStreamInterface::Config& config) {
   for (const auto& decoder : config.decoders) {
     if (!HasRtxReceiveAssociation(config, decoder.payload_type))
       return false;
@@ -4098,7 +4099,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetDefaultRecvCodecsWithoutSsrc) {
       fake_call_->GetVideoReceiveStreams();
   ASSERT_EQ(1U, video_streams.size());
   const FakeVideoReceiveStream& video_stream = *video_streams.front();
-  const webrtc::VideoReceiveStream::Config& video_config =
+  const webrtc::VideoReceiveStreamInterface::Config& video_config =
       video_stream.GetConfig();
   EXPECT_FALSE(video_config.rtp.protected_by_flexfec);
   EXPECT_EQ(video_config.rtp.packet_sink_, nullptr);
@@ -4122,7 +4123,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetDefaultRecvCodecsWithSsrc) {
       fake_call_->GetVideoReceiveStreams();
   ASSERT_EQ(1U, video_streams.size());
   const FakeVideoReceiveStream& video_stream = *video_streams.front();
-  const webrtc::VideoReceiveStream::Config& video_config =
+  const webrtc::VideoReceiveStreamInterface::Config& video_config =
       video_stream.GetConfig();
   EXPECT_TRUE(video_config.rtp.protected_by_flexfec);
   EXPECT_NE(video_config.rtp.packet_sink_, nullptr);
@@ -4144,7 +4145,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest,
       fake_call_->GetVideoReceiveStreams();
   ASSERT_EQ(1U, video_streams.size());
   const FakeVideoReceiveStream* video_stream = video_streams.front();
-  const webrtc::VideoReceiveStream::Config* video_config =
+  const webrtc::VideoReceiveStreamInterface::Config* video_config =
       &video_stream->GetConfig();
   EXPECT_FALSE(video_config->rtp.protected_by_flexfec);
   EXPECT_EQ(video_config->rtp.packet_sink_, nullptr);
@@ -4159,7 +4160,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest,
       << "Enabling FlexFEC should create FlexfecReceiveStream.";
 
   EXPECT_EQ(1U, fake_call_->GetVideoReceiveStreams().size())
-      << "Enabling FlexFEC should not create VideoReceiveStream.";
+      << "Enabling FlexFEC should not create VideoReceiveStreamInterface.";
   EXPECT_EQ(1U, fake_call_->GetFlexfecReceiveStreams().size())
       << "Enabling FlexFEC should create a single FlexfecReceiveStream.";
   video_stream = video_streams.front();
@@ -4187,7 +4188,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest,
       fake_call_->GetVideoReceiveStreams();
   ASSERT_EQ(1U, video_streams.size());
   const FakeVideoReceiveStream* video_stream = video_streams.front();
-  const webrtc::VideoReceiveStream::Config* video_config =
+  const webrtc::VideoReceiveStreamInterface::Config* video_config =
       &video_stream->GetConfig();
   EXPECT_TRUE(video_config->rtp.protected_by_flexfec);
   EXPECT_NE(video_config->rtp.packet_sink_, nullptr);
@@ -4199,9 +4200,9 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest,
   // Now the count of created streams will be 3 since the video stream had to
   // be recreated on account of the flexfec stream being deleted.
   EXPECT_EQ(3, fake_call_->GetNumCreatedReceiveStreams())
-      << "Disabling FlexFEC should not recreate VideoReceiveStream.";
+      << "Disabling FlexFEC should not recreate VideoReceiveStreamInterface.";
   EXPECT_EQ(1U, fake_call_->GetVideoReceiveStreams().size())
-      << "Disabling FlexFEC should not destroy VideoReceiveStream.";
+      << "Disabling FlexFEC should not destroy VideoReceiveStreamInterface.";
   EXPECT_TRUE(fake_call_->GetFlexfecReceiveStreams().empty())
       << "Disabling FlexFEC should destroy FlexfecReceiveStream.";
   video_stream = video_streams.front();
@@ -4309,7 +4310,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvCodecsWithFec) {
   const std::vector<FakeVideoReceiveStream*>& video_streams =
       fake_call_->GetVideoReceiveStreams();
   const FakeVideoReceiveStream* video_stream = video_streams.front();
-  const webrtc::VideoReceiveStream::Config& video_stream_config =
+  const webrtc::VideoReceiveStreamInterface::Config& video_stream_config =
       video_stream->GetConfig();
   EXPECT_EQ(video_stream_config.rtp.local_ssrc,
             flexfec_stream_config.rtp.local_ssrc);
@@ -4840,7 +4841,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithPacketization) {
   AddRecvStream(params);
   ASSERT_THAT(fake_call_->GetVideoReceiveStreams(), testing::SizeIs(1));
 
-  const webrtc::VideoReceiveStream::Config& config =
+  const webrtc::VideoReceiveStreamInterface::Config& config =
       fake_call_->GetVideoReceiveStreams()[0]->GetConfig();
   ASSERT_THAT(config.rtp.raw_payload_types, testing::SizeIs(1));
   EXPECT_EQ(config.rtp.raw_payload_types.count(vp8_codec.id), 1U);
@@ -4917,7 +4918,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithChangedRtxPayloadType) {
   parameters.codecs.push_back(rtx_codec);
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
   ASSERT_EQ(1U, fake_call_->GetVideoReceiveStreams().size());
-  const webrtc::VideoReceiveStream::Config& config_before =
+  const webrtc::VideoReceiveStreamInterface::Config& config_before =
       fake_call_->GetVideoReceiveStreams()[0]->GetConfig();
   EXPECT_EQ(1U, config_before.rtp.rtx_associated_payload_types.size());
   const int* payload_type_before = FindKeyByValue(
@@ -4930,7 +4931,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithChangedRtxPayloadType) {
   parameters.codecs[1].id = kUnusedPayloadType2;
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
   ASSERT_EQ(1U, fake_call_->GetVideoReceiveStreams().size());
-  const webrtc::VideoReceiveStream::Config& config_after =
+  const webrtc::VideoReceiveStreamInterface::Config& config_after =
       fake_call_->GetVideoReceiveStreams()[0]->GetConfig();
   EXPECT_EQ(1U, config_after.rtp.rtx_associated_payload_types.size());
   const int* payload_type_after = FindKeyByValue(
@@ -4960,7 +4961,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRtxWithRtxTime) {
   parameters.codecs.push_back(rtx_codec);
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
   ASSERT_EQ(1U, fake_call_->GetVideoReceiveStreams().size());
-  const webrtc::VideoReceiveStream::Config& config =
+  const webrtc::VideoReceiveStreamInterface::Config& config =
       fake_call_->GetVideoReceiveStreams()[0]->GetConfig();
 
   const int kRtxTime = 343;
@@ -5023,7 +5024,8 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsAcceptDefaultCodecs) {
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 
   FakeVideoReceiveStream* stream = AddRecvStream();
-  const webrtc::VideoReceiveStream::Config& config = stream->GetConfig();
+  const webrtc::VideoReceiveStreamInterface::Config& config =
+      stream->GetConfig();
   EXPECT_EQ(engine_.recv_codecs()[0].name,
             config.decoders[0].video_format.name);
   EXPECT_EQ(engine_.recv_codecs()[0].id, config.decoders[0].payload_type);
@@ -6082,7 +6084,7 @@ TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesSendRtcpPacketTypesCorrectly) {
 TEST_F(WebRtcVideoChannelTest,
        GetStatsTranslatesReceiveRtcpPacketTypesCorrectly) {
   FakeVideoReceiveStream* stream = AddRecvStream();
-  webrtc::VideoReceiveStream::Stats stats;
+  webrtc::VideoReceiveStreamInterface::Stats stats;
   stats.rtcp_packet_type_counts.fir_packets = 2;
   stats.rtcp_packet_type_counts.nack_packets = 3;
   stats.rtcp_packet_type_counts.pli_packets = 4;
@@ -6100,7 +6102,7 @@ TEST_F(WebRtcVideoChannelTest,
 
 TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesDecodeStatsCorrectly) {
   FakeVideoReceiveStream* stream = AddRecvStream();
-  webrtc::VideoReceiveStream::Stats stats;
+  webrtc::VideoReceiveStreamInterface::Stats stats;
   stats.decoder_implementation_name = "decoder_implementation_name";
   stats.decode_ms = 2;
   stats.max_decode_ms = 3;
@@ -6157,7 +6159,7 @@ TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesDecodeStatsCorrectly) {
 TEST_F(WebRtcVideoChannelTest,
        GetStatsTranslatesInterFrameDelayStatsCorrectly) {
   FakeVideoReceiveStream* stream = AddRecvStream();
-  webrtc::VideoReceiveStream::Stats stats;
+  webrtc::VideoReceiveStreamInterface::Stats stats;
   stats.total_inter_frame_delay = 0.123;
   stats.total_squared_inter_frame_delay = 0.00456;
   stream->SetStats(stats);
@@ -6172,7 +6174,7 @@ TEST_F(WebRtcVideoChannelTest,
 
 TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesReceivePacketStatsCorrectly) {
   FakeVideoReceiveStream* stream = AddRecvStream();
-  webrtc::VideoReceiveStream::Stats stats;
+  webrtc::VideoReceiveStreamInterface::Stats stats;
   stats.rtp_stats.packet_counter.payload_bytes = 2;
   stats.rtp_stats.packet_counter.header_bytes = 3;
   stats.rtp_stats.packet_counter.padding_bytes = 4;
@@ -6374,7 +6376,7 @@ TEST_F(WebRtcVideoChannelTest, ReportsSsrcGroupsInStats) {
 
 TEST_F(WebRtcVideoChannelTest, MapsReceivedPayloadTypeToCodecName) {
   FakeVideoReceiveStream* stream = AddRecvStream();
-  webrtc::VideoReceiveStream::Stats stats;
+  webrtc::VideoReceiveStreamInterface::Stats stats;
   cricket::VideoMediaInfo info;
 
   // Report no codec name before receiving.
@@ -8489,7 +8491,8 @@ TEST_F(WebRtcVideoChannelTest, DISABLED_GetRtpReceiveFmtpSprop) {
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 
   FakeVideoReceiveStream* recv_stream = AddRecvStream();
-  const webrtc::VideoReceiveStream::Config& cfg = recv_stream->GetConfig();
+  const webrtc::VideoReceiveStreamInterface::Config& cfg =
+      recv_stream->GetConfig();
   webrtc::RtpParameters rtp_parameters =
       channel_->GetRtpReceiveParameters(last_ssrc_);
   ASSERT_EQ(2u, rtp_parameters.codecs.size());

modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc

@@ -654,7 +654,7 @@ DataRate AverageBitrateAfterCrossInducedLoss(std::string name) {
   // Querying the video stats from within the expected runtime environment
   // (i.e. the TQ that belongs to the CallClient, not the Scenario TQ that
   // we're currently on).
-  VideoReceiveStream::Stats video_receive_stats;
+  VideoReceiveStreamInterface::Stats video_receive_stats;
   auto* video_stream = video->receive();
   callee->SendTask([&video_stream, &video_receive_stats]() {
     video_receive_stats = video_stream->GetStats();

modules/video_coding/video_receiver2.h

@@ -45,7 +45,7 @@ class VideoReceiver2 {
   int32_t Decode(const webrtc::VCMEncodedFrame* frame);
 
   // Notification methods that are used to check our internal state and validate
-  // threading assumptions. These are called by VideoReceiveStream.
+  // threading assumptions. These are called by VideoReceiveStreamInterface.
   // See `IsDecoderThreadRunning()` for more details.
   void DecoderThreadStarting();
   void DecoderThreadStopped();

rtc_tools/video_replay.cc

@@ -388,7 +388,7 @@ class RtpReplayer final {
   struct StreamState {
     test::NullTransport transport;
     std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>> sinks;
-    std::vector<VideoReceiveStream*> receive_streams;
+    std::vector<VideoReceiveStreamInterface*> receive_streams;
     std::unique_ptr<VideoDecoderFactory> decoder_factory;
   };
 
@@ -455,7 +455,8 @@ class RtpReplayer final {
     stream_state->sinks.push_back(std::move(playback_video));
     stream_state->sinks.push_back(std::move(file_passthrough));
     // Setup the configuration from the flags.
-    VideoReceiveStream::Config receive_config(&(stream_state->transport));
+    VideoReceiveStreamInterface::Config receive_config(
+        &(stream_state->transport));
     receive_config.rtp.remote_ssrc = Ssrc();
     receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
     receive_config.rtp.rtx_ssrc = SsrcRtx();
@@ -477,7 +478,7 @@ class RtpReplayer final {
     receive_config.renderer = stream_state->sinks.back().get();
 
     // Setup the receiving stream
-    VideoReceiveStream::Decoder decoder;
+    VideoReceiveStreamInterface::Decoder decoder;
     decoder = test::CreateMatchingDecoder(MediaPayloadType(), Codec());
     if (!DecoderBitstreamFilename().empty()) {
       // Replace decoder with file writer if we're writing the bitstream to a

test/call_config_utils.cc

@@ -16,14 +16,15 @@
 namespace webrtc {
 namespace test {
 
-// Deserializes a JSON representation of the VideoReceiveStream::Config back
+// Deserializes a JSON representation of the VideoReceiveStreamInterface::Config
-// into a valid object. This will not initialize the decoders or the renderer.
+// back into a valid object. This will not initialize the decoders or the
-VideoReceiveStream::Config ParseVideoReceiveStreamJsonConfig(
+// renderer.
+VideoReceiveStreamInterface::Config ParseVideoReceiveStreamJsonConfig(
     webrtc::Transport* transport,
     const Json::Value& json) {
-  auto receive_config = VideoReceiveStream::Config(transport);
+  auto receive_config = VideoReceiveStreamInterface::Config(transport);
   for (const auto& decoder_json : json["decoders"]) {
-    VideoReceiveStream::Decoder decoder;
+    VideoReceiveStreamInterface::Decoder decoder;
     decoder.video_format =
         SdpVideoFormat(decoder_json["payload_name"].asString());
     decoder.payload_type = decoder_json["payload_type"].asInt64();
@@ -69,7 +70,7 @@ VideoReceiveStream::Config ParseVideoReceiveStreamJsonConfig(
 }
 
 Json::Value GenerateVideoReceiveStreamJsonConfig(
-    const VideoReceiveStream::Config& config) {
+    const VideoReceiveStreamInterface::Config& config) {
   Json::Value root_json;
 
   root_json["decoders"] = Json::Value(Json::arrayValue);

test/call_config_utils.h

@@ -17,15 +17,16 @@
 namespace webrtc {
 namespace test {
 
-// Deserializes a JSON representation of the VideoReceiveStream::Config back
+// Deserializes a JSON representation of the VideoReceiveStreamInterface::Config
-// into a valid object. This will not initialize the decoders or the renderer.
+// back into a valid object. This will not initialize the decoders or the
-VideoReceiveStream::Config ParseVideoReceiveStreamJsonConfig(
+// renderer.
+VideoReceiveStreamInterface::Config ParseVideoReceiveStreamJsonConfig(
     webrtc::Transport* transport,
     const Json::Value& json);
 
-// Serialize a VideoReceiveStream::Config into a Json object.
+// Serialize a VideoReceiveStreamInterface::Config into a Json object.
 Json::Value GenerateVideoReceiveStreamJsonConfig(
-    const VideoReceiveStream::Config& config);
+    const VideoReceiveStreamInterface::Config& config);
 
 }  // namespace test
 }  // namespace webrtc

test/call_config_utils_unittest.cc

@@ -17,9 +17,9 @@ namespace webrtc {
 namespace test {
 
 TEST(CallConfigUtils, MarshalUnmarshalProcessSameObject) {
-  VideoReceiveStream::Config recv_config(nullptr);
+  VideoReceiveStreamInterface::Config recv_config(nullptr);
 
-  VideoReceiveStream::Decoder decoder;
+  VideoReceiveStreamInterface::Decoder decoder;
   decoder.payload_type = 10;
   decoder.video_format.name = "test";
   decoder.video_format.parameters["99"] = "b";
@@ -37,7 +37,7 @@ TEST(CallConfigUtils, MarshalUnmarshalProcessSameObject) {
   recv_config.rtp.rtx_associated_payload_types[10] = 10;
   recv_config.rtp.extensions.emplace_back("uri", 128, true);
 
-  VideoReceiveStream::Config unmarshaled_config =
+  VideoReceiveStreamInterface::Config unmarshaled_config =
       ParseVideoReceiveStreamJsonConfig(
           nullptr, GenerateVideoReceiveStreamJsonConfig(recv_config));
 

test/call_test.cc

@@ -309,7 +309,7 @@ void CallTest::SetSendUlpFecConfig(VideoSendStream::Config* send_config) {
 }
 
 void CallTest::SetReceiveUlpFecConfig(
-    VideoReceiveStream::Config* receive_config) {
+    VideoReceiveStreamInterface::Config* receive_config) {
   receive_config->rtp.red_payload_type = kRedPayloadType;
   receive_config->rtp.ulpfec_payload_type = kUlpfecPayloadType;
   receive_config->rtp.rtx_associated_payload_types[kRtxRedPayloadType] =
@@ -353,7 +353,7 @@ void CallTest::CreateMatchingVideoReceiveConfigs(
 }
 
 void CallTest::AddMatchingVideoReceiveConfigs(
-    std::vector<VideoReceiveStream::Config>* receive_configs,
+    std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
     const VideoSendStream::Config& video_send_config,
     Transport* rtcp_send_transport,
     bool send_side_bwe,
@@ -362,7 +362,7 @@ void CallTest::AddMatchingVideoReceiveConfigs(
     bool receiver_reference_time_report,
     int rtp_history_ms) {
   RTC_DCHECK(!video_send_config.rtp.ssrcs.empty());
-  VideoReceiveStream::Config default_config(rtcp_send_transport);
+  VideoReceiveStreamInterface::Config default_config(rtcp_send_transport);
   default_config.rtp.transport_cc = send_side_bwe;
   default_config.rtp.local_ssrc = kReceiverLocalVideoSsrc;
   for (const RtpExtension& extension : video_send_config.rtp.extensions)
@@ -374,7 +374,8 @@ void CallTest::AddMatchingVideoReceiveConfigs(
   default_config.renderer = &fake_renderer_;
 
   for (size_t i = 0; i < video_send_config.rtp.ssrcs.size(); ++i) {
-    VideoReceiveStream::Config video_recv_config(default_config.Copy());
+    VideoReceiveStreamInterface::Config video_recv_config(
+        default_config.Copy());
     video_recv_config.decoders.clear();
     if (!video_send_config.rtp.rtx.ssrcs.empty()) {
       video_recv_config.rtp.rtx_ssrc = video_send_config.rtp.rtx.ssrcs[i];
@@ -382,7 +383,7 @@ void CallTest::AddMatchingVideoReceiveConfigs(
           video_send_config.rtp.payload_type;
     }
     video_recv_config.rtp.remote_ssrc = video_send_config.rtp.ssrcs[i];
-    VideoReceiveStream::Decoder decoder;
+    VideoReceiveStreamInterface::Decoder decoder;
 
     decoder.payload_type = video_send_config.rtp.payload_type;
     decoder.video_format = SdpVideoFormat(video_send_config.rtp.payload_name);
@@ -592,7 +593,7 @@ void CallTest::Start() {
 void CallTest::StartVideoStreams() {
   for (VideoSendStream* video_send_stream : video_send_streams_)
     video_send_stream->Start();
-  for (VideoReceiveStream* video_recv_stream : video_receive_streams_)
+  for (VideoReceiveStreamInterface* video_recv_stream : video_receive_streams_)
     video_recv_stream->Start();
 }
 
@@ -608,7 +609,7 @@ void CallTest::Stop() {
 void CallTest::StopVideoStreams() {
   for (VideoSendStream* video_send_stream : video_send_streams_)
     video_send_stream->Stop();
-  for (VideoReceiveStream* video_recv_stream : video_receive_streams_)
+  for (VideoReceiveStreamInterface* video_recv_stream : video_receive_streams_)
     video_recv_stream->Stop();
 }
 
@@ -621,7 +622,7 @@ void CallTest::DestroyStreams() {
 
   DestroyVideoSendStreams();
 
-  for (VideoReceiveStream* video_recv_stream : video_receive_streams_)
+  for (VideoReceiveStreamInterface* video_recv_stream : video_receive_streams_)
     receiver_call_->DestroyVideoReceiveStream(video_recv_stream);
 
   for (FlexfecReceiveStream* flexfec_recv_stream : flexfec_receive_streams_)
@@ -781,7 +782,7 @@ size_t BaseTest::GetNumFlexfecStreams() const {
 
 void BaseTest::ModifyVideoConfigs(
     VideoSendStream::Config* send_config,
-    std::vector<VideoReceiveStream::Config>* receive_configs,
+    std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
     VideoEncoderConfig* encoder_config) {}
 
 void BaseTest::ModifyVideoCaptureStartResolution(int* width,
@@ -793,7 +794,7 @@ void BaseTest::ModifyVideoDegradationPreference(
 
 void BaseTest::OnVideoStreamsCreated(
     VideoSendStream* send_stream,
-    const std::vector<VideoReceiveStream*>& receive_streams) {}
+    const std::vector<VideoReceiveStreamInterface*>& receive_streams) {}
 
 void BaseTest::ModifyAudioConfigs(
     AudioSendStream::Config* send_config,

test/call_test.h

@@ -99,7 +99,8 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
 
   void SetSendFecConfig(std::vector<uint32_t> video_send_ssrcs);
   void SetSendUlpFecConfig(VideoSendStream::Config* send_config);
-  void SetReceiveUlpFecConfig(VideoReceiveStream::Config* receive_config);
+  void SetReceiveUlpFecConfig(
+      VideoReceiveStreamInterface::Config* receive_config);
   void CreateSendConfig(size_t num_video_streams,
                         size_t num_audio_streams,
                         size_t num_flexfec_streams,
@@ -117,7 +118,7 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
       bool receiver_reference_time_report,
       int rtp_history_ms);
   void AddMatchingVideoReceiveConfigs(
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       const VideoSendStream::Config& video_send_config,
       Transport* rtcp_send_transport,
       bool send_side_bwe,
@@ -195,8 +196,8 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
 
   std::unique_ptr<Call> receiver_call_;
   std::unique_ptr<PacketTransport> receive_transport_;
-  std::vector<VideoReceiveStream::Config> video_receive_configs_;
+  std::vector<VideoReceiveStreamInterface::Config> video_receive_configs_;
-  std::vector<VideoReceiveStream*> video_receive_streams_;
+  std::vector<VideoReceiveStreamInterface*> video_receive_streams_;
   std::vector<AudioReceiveStream::Config> audio_receive_configs_;
   std::vector<AudioReceiveStream*> audio_receive_streams_;
   std::vector<FlexfecReceiveStream::Config> flexfec_receive_configs_;
@@ -274,7 +275,7 @@ class BaseTest : public RtpRtcpObserver {
 
   virtual void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config);
   virtual void ModifyVideoCaptureStartResolution(int* width,
                                                  int* heigt,
@@ -284,7 +285,7 @@ class BaseTest : public RtpRtcpObserver {
 
   virtual void OnVideoStreamsCreated(
       VideoSendStream* send_stream,
-      const std::vector<VideoReceiveStream*>& receive_streams);
+      const std::vector<VideoReceiveStreamInterface*>& receive_streams);
 
   virtual void ModifyAudioConfigs(
       AudioSendStream::Config* send_config,

test/encoder_settings.cc

@@ -131,16 +131,16 @@ void FillEncoderConfiguration(VideoCodecType codec_type,
   }
 }
 
-VideoReceiveStream::Decoder CreateMatchingDecoder(
+VideoReceiveStreamInterface::Decoder CreateMatchingDecoder(
     int payload_type,
     const std::string& payload_name) {
-  VideoReceiveStream::Decoder decoder;
+  VideoReceiveStreamInterface::Decoder decoder;
   decoder.payload_type = payload_type;
   decoder.video_format = SdpVideoFormat(payload_name);
   return decoder;
 }
 
-VideoReceiveStream::Decoder CreateMatchingDecoder(
+VideoReceiveStreamInterface::Decoder CreateMatchingDecoder(
     const VideoSendStream::Config& config) {
   return CreateMatchingDecoder(config.rtp.payload_type,
                                config.rtp.payload_name);

test/encoder_settings.h

@@ -53,11 +53,11 @@ void FillEncoderConfiguration(VideoCodecType codec_type,
                               size_t num_streams,
                               VideoEncoderConfig* configuration);
 
-VideoReceiveStream::Decoder CreateMatchingDecoder(
+VideoReceiveStreamInterface::Decoder CreateMatchingDecoder(
     int payload_type,
     const std::string& payload_name);
 
-VideoReceiveStream::Decoder CreateMatchingDecoder(
+VideoReceiveStreamInterface::Decoder CreateMatchingDecoder(
     const VideoSendStream::Config& config);
 }  // namespace test
 }  // namespace webrtc

test/fuzzers/utils/rtp_replayer.cc

@@ -34,7 +34,7 @@ void RtpReplayer::Replay(const std::string& replay_config_filepath,
                          const uint8_t* rtp_dump_data,
                          size_t rtp_dump_size) {
   auto stream_state = std::make_unique<StreamState>();
-  std::vector<VideoReceiveStream::Config> receive_stream_configs =
+  std::vector<VideoReceiveStreamInterface::Config> receive_stream_configs =
       ReadConfigFromFile(replay_config_filepath, &(stream_state->transport));
   return Replay(std::move(stream_state), std::move(receive_stream_configs),
                 rtp_dump_data, rtp_dump_size);
@@ -42,7 +42,7 @@ void RtpReplayer::Replay(const std::string& replay_config_filepath,
 
 void RtpReplayer::Replay(
     std::unique_ptr<StreamState> stream_state,
-    std::vector<VideoReceiveStream::Config> receive_stream_configs,
+    std::vector<VideoReceiveStreamInterface::Config> receive_stream_configs,
     const uint8_t* rtp_dump_data,
     size_t rtp_dump_size) {
   RunLoop loop;
@@ -83,9 +83,9 @@ void RtpReplayer::Replay(
   }
 }
 
-std::vector<VideoReceiveStream::Config> RtpReplayer::ReadConfigFromFile(
+std::vector<VideoReceiveStreamInterface::Config>
-    const std::string& replay_config,
+RtpReplayer::ReadConfigFromFile(const std::string& replay_config,
-    Transport* transport) {
+                                Transport* transport) {
   Json::CharReaderBuilder factory;
   std::unique_ptr<Json::CharReader> json_reader =
       absl::WrapUnique(factory.newCharReader());
@@ -99,7 +99,7 @@ std::vector<VideoReceiveStream::Config> RtpReplayer::ReadConfigFromFile(
     return {};
   }
 
-  std::vector<VideoReceiveStream::Config> receive_stream_configs;
+  std::vector<VideoReceiveStreamInterface::Config> receive_stream_configs;
   receive_stream_configs.reserve(json_configs.size());
   for (const auto& json : json_configs) {
     receive_stream_configs.push_back(
@@ -109,7 +109,7 @@ std::vector<VideoReceiveStream::Config> RtpReplayer::ReadConfigFromFile(
 }
 
 void RtpReplayer::SetupVideoStreams(
-    std::vector<VideoReceiveStream::Config>* receive_stream_configs,
+    std::vector<VideoReceiveStreamInterface::Config>* receive_stream_configs,
     StreamState* stream_state,
     Call* call) {
   stream_state->decoder_factory = std::make_unique<InternalDecoderFactory>();

test/fuzzers/utils/rtp_replayer.h

@@ -44,7 +44,7 @@ class RtpReplayer final {
   struct StreamState {
     test::NullTransport transport;
     std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>> sinks;
-    std::vector<VideoReceiveStream*> receive_streams;
+    std::vector<VideoReceiveStreamInterface*> receive_streams;
     std::unique_ptr<VideoDecoderFactory> decoder_factory;
   };
 
@@ -53,23 +53,24 @@ class RtpReplayer final {
                      const uint8_t* rtp_dump_data,
                      size_t rtp_dump_size);
 
-  // Construct an RtpReplayer from  a set of VideoReceiveStream::Configs. Note
+  // Construct an RtpReplayer from  a set of
-  // the stream_state.transport must be set for each receiver stream.
+  // VideoReceiveStreamInterface::Configs. Note the stream_state.transport must
+  // be set for each receiver stream.
   static void Replay(
       std::unique_ptr<StreamState> stream_state,
-      std::vector<VideoReceiveStream::Config> receive_stream_config,
+      std::vector<VideoReceiveStreamInterface::Config> receive_stream_config,
       const uint8_t* rtp_dump_data,
       size_t rtp_dump_size);
 
  private:
   // Reads the replay configuration from Json.
-  static std::vector<VideoReceiveStream::Config> ReadConfigFromFile(
+  static std::vector<VideoReceiveStreamInterface::Config> ReadConfigFromFile(
       const std::string& replay_config,
       Transport* transport);
 
   // Configures the stream state based on the receiver configurations.
   static void SetupVideoStreams(
-      std::vector<VideoReceiveStream::Config>* receive_stream_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_stream_configs,
       StreamState* stream_state,
       Call* call);
 

test/fuzzers/vp8_replay_fuzzer.cc

@@ -19,9 +19,9 @@ namespace webrtc {
 
 void FuzzOneInput(const uint8_t* data, size_t size) {
   auto stream_state = std::make_unique<test::RtpReplayer::StreamState>();
-  VideoReceiveStream::Config vp8_config(&(stream_state->transport));
+  VideoReceiveStreamInterface::Config vp8_config(&(stream_state->transport));
 
-  VideoReceiveStream::Decoder vp8_decoder;
+  VideoReceiveStreamInterface::Decoder vp8_decoder;
   vp8_decoder.video_format = SdpVideoFormat("VP8");
   vp8_decoder.payload_type = 125;
   vp8_config.decoders.push_back(std::move(vp8_decoder));
@@ -33,7 +33,7 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
   vp8_config.rtp.nack.rtp_history_ms = 1000;
   vp8_config.rtp.lntf.enabled = true;
 
-  std::vector<VideoReceiveStream::Config> replay_configs;
+  std::vector<VideoReceiveStreamInterface::Config> replay_configs;
   replay_configs.push_back(std::move(vp8_config));
 
   test::RtpReplayer::Replay(std::move(stream_state), std::move(replay_configs),

test/fuzzers/vp9_replay_fuzzer.cc

@@ -19,9 +19,9 @@ namespace webrtc {
 
 void FuzzOneInput(const uint8_t* data, size_t size) {
   auto stream_state = std::make_unique<test::RtpReplayer::StreamState>();
-  VideoReceiveStream::Config vp9_config(&(stream_state->transport));
+  VideoReceiveStreamInterface::Config vp9_config(&(stream_state->transport));
 
-  VideoReceiveStream::Decoder vp9_decoder;
+  VideoReceiveStreamInterface::Decoder vp9_decoder;
   vp9_decoder.video_format = SdpVideoFormat("VP9");
   vp9_decoder.payload_type = 124;
   vp9_config.decoders.push_back(std::move(vp9_decoder));
@@ -32,7 +32,7 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
   vp9_config.rtp.transport_cc = true;
   vp9_config.rtp.nack.rtp_history_ms = 1000;
 
-  std::vector<VideoReceiveStream::Config> replay_configs;
+  std::vector<VideoReceiveStreamInterface::Config> replay_configs;
   replay_configs.push_back(std::move(vp9_config));
 
   test::RtpReplayer::Replay(std::move(stream_state), std::move(replay_configs),

test/scenario/stats_collection.cc

@@ -174,7 +174,8 @@ void VideoSendStatsCollector::AddStats(VideoSendStream::Stats sample,
   last_update_ = at_time;
 }
 
-void VideoReceiveStatsCollector::AddStats(VideoReceiveStream::Stats sample) {
+void VideoReceiveStatsCollector::AddStats(
+    VideoReceiveStreamInterface::Stats sample) {
   if (sample.decode_ms > 0)
     stats_.decode_time.AddSampleMs(sample.decode_ms);
   if (sample.max_decode_ms > 0)

test/scenario/stats_collection.h

@@ -90,7 +90,7 @@ class VideoSendStatsCollector {
 };
 class VideoReceiveStatsCollector {
  public:
-  void AddStats(VideoReceiveStream::Stats sample);
+  void AddStats(VideoReceiveStreamInterface::Stats sample);
   CollectedVideoReceiveStats& stats() { return stats_; }
 
  private:

test/scenario/stats_collection_unittest.cc

@@ -45,7 +45,7 @@ void CreateAnalyzedStream(Scenario* s,
     // Querying the video stats from within the expected runtime environment
     // (i.e. the TQ that belongs to the CallClient, not the Scenario TQ that
     // we're currently on).
-    VideoReceiveStream::Stats video_receive_stats;
+    VideoReceiveStreamInterface::Stats video_receive_stats;
     auto* video_stream = video->receive();
     callee->SendTask([&video_stream, &video_receive_stats]() {
       video_receive_stats = video_stream->GetStats();

test/scenario/video_stream.cc

@@ -317,16 +317,16 @@ std::unique_ptr<FrameGeneratorInterface> CreateFrameGenerator(
   }
 }
 
-VideoReceiveStream::Config CreateVideoReceiveStreamConfig(
+VideoReceiveStreamInterface::Config CreateVideoReceiveStreamConfig(
     VideoStreamConfig config,
     Transport* feedback_transport,
     VideoDecoderFactory* decoder_factory,
-    VideoReceiveStream::Decoder decoder,
+    VideoReceiveStreamInterface::Decoder decoder,
     rtc::VideoSinkInterface<VideoFrame>* renderer,
     uint32_t local_ssrc,
     uint32_t ssrc,
     uint32_t rtx_ssrc) {
-  VideoReceiveStream::Config recv(feedback_transport);
+  VideoReceiveStreamInterface::Config recv(feedback_transport);
   recv.rtp.transport_cc = config.stream.packet_feedback;
   recv.rtp.local_ssrc = local_ssrc;
   recv.rtp.extensions = GetVideoRtpExtensions(config);
@@ -546,7 +546,7 @@ ReceiveVideoStream::ReceiveVideoStream(CallClient* receiver,
     decoder_factory_ = std::make_unique<InternalDecoderFactory>();
   }
 
-  VideoReceiveStream::Decoder decoder =
+  VideoReceiveStreamInterface::Decoder decoder =
       CreateMatchingDecoder(CodecTypeToPayloadType(config.encoder.codec),
                             CodecTypeToPayloadString(config.encoder.codec));
   size_t num_streams = 1;
@@ -611,9 +611,9 @@ void ReceiveVideoStream::Stop() {
   });
 }
 
-VideoReceiveStream::Stats ReceiveVideoStream::GetStats() const {
+VideoReceiveStreamInterface::Stats ReceiveVideoStream::GetStats() const {
   if (receive_streams_.empty())
-    return VideoReceiveStream::Stats();
+    return VideoReceiveStreamInterface::Stats();
   // TODO(srte): Handle multiple receive streams.
   return receive_streams_.back()->GetStats();
 }

test/scenario/video_stream.h

@@ -81,7 +81,7 @@ class ReceiveVideoStream {
 
   void Start();
   void Stop();
-  VideoReceiveStream::Stats GetStats() const;
+  VideoReceiveStreamInterface::Stats GetStats() const;
 
  private:
   friend class Scenario;
@@ -93,7 +93,7 @@ class ReceiveVideoStream {
                      Transport* feedback_transport,
                      VideoFrameMatcher* matcher);
 
-  std::vector<VideoReceiveStream*> receive_streams_;
+  std::vector<VideoReceiveStreamInterface*> receive_streams_;
   FlexfecReceiveStream* flecfec_stream_ = nullptr;
   FakeVideoRenderer fake_renderer_;
   std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>>

video/cpu_scaling_tests.cc

@@ -102,7 +102,7 @@ void CpuOveruseTest::RunTestAndCheckForAdaptation(
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       EXPECT_FALSE(encoder_config->simulcast_layers.empty());
       encoder_config->simulcast_layers[0].max_framerate = kFps;

video/end_to_end_tests/bandwidth_tests.cc

@@ -50,7 +50,7 @@ TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->rtp.extensions.clear();
       send_config->rtp.extensions.push_back(
@@ -100,7 +100,7 @@ class BandwidthStatsTest : public test::EndToEndTest {
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     send_config->rtp.extensions.clear();
     if (!send_side_bwe_) {
@@ -226,7 +226,7 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       ASSERT_EQ(1u, send_config->rtp.ssrcs.size());
       sender_ssrc_ = send_config->rtp.ssrcs[0];
@@ -328,15 +328,15 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
               CreateBuiltinVideoBitrateAllocatorFactory()),
           bitrate_kbps_(0) {}
 
-    void OnVideoStreamsCreated(
+    void OnVideoStreamsCreated(VideoSendStream* send_stream,
-        VideoSendStream* send_stream,
+                               const std::vector<VideoReceiveStreamInterface*>&
-        const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                   receive_streams) override {
       send_stream_ = send_stream;
     }
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder_factory = &encoder_factory_;
       send_config->encoder_settings.bitrate_allocator_factory =

video/end_to_end_tests/codec_tests.cc

@@ -71,7 +71,7 @@ class CodecObserver : public test::EndToEndTest,
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
     send_config->encoder_settings.encoder_factory = encoder_factory_;

video/end_to_end_tests/config_tests.cc

@@ -73,7 +73,7 @@ TEST_F(ConfigEndToEndTest, VerifyDefaultSendConfigParameters) {
 }
 
 TEST_F(ConfigEndToEndTest, VerifyDefaultVideoReceiveConfigParameters) {
-  VideoReceiveStream::Config default_receive_config(nullptr);
+  VideoReceiveStreamInterface::Config default_receive_config(nullptr);
   EXPECT_EQ(RtcpMode::kCompound, default_receive_config.rtp.rtcp_mode)
       << "Reduced-size RTCP require rtcp-rsize to be negotiated.";
   EXPECT_FALSE(default_receive_config.rtp.lntf.enabled)

video/end_to_end_tests/extended_reports_tests.cc

@@ -173,7 +173,7 @@ class RtcpXrObserver : public test::EndToEndTest {
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     if (enable_zero_target_bitrate_) {
       // Configure VP8 to be able to use simulcast.

video/end_to_end_tests/fec_tests.cc

@@ -110,7 +110,7 @@ TEST_F(FecEndToEndTest, ReceivesUlpfec) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       // Use VP8 instead of FAKE, since the latter does not have PictureID
       // in the packetization headers.
@@ -118,7 +118,7 @@ TEST_F(FecEndToEndTest, ReceivesUlpfec) {
       send_config->rtp.payload_name = "VP8";
       send_config->rtp.payload_type = kVideoSendPayloadType;
       encoder_config->codec_type = kVideoCodecVP8;
-      VideoReceiveStream::Decoder decoder =
+      VideoReceiveStreamInterface::Decoder decoder =
           test::CreateMatchingDecoder(*send_config);
       (*receive_configs)[0].decoder_factory = &decoder_factory_;
       (*receive_configs)[0].decoders.clear();
@@ -287,7 +287,7 @@ class FlexfecRenderObserver : public test::EndToEndTest,
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     (*receive_configs)[0].rtp.local_ssrc = kVideoLocalSsrc;
     (*receive_configs)[0].renderer = this;
@@ -465,7 +465,7 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       // Configure hybrid NACK/FEC.
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;

video/end_to_end_tests/frame_encryption_tests.cc

@@ -35,7 +35,7 @@ class DecryptedFrameObserver : public test::EndToEndTest,
  private:
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     // Use VP8 instead of FAKE.
     send_config->encoder_settings.encoder_factory = &encoder_factory_;
@@ -44,7 +44,7 @@ class DecryptedFrameObserver : public test::EndToEndTest,
     send_config->frame_encryptor = new FakeFrameEncryptor();
     send_config->crypto_options.sframe.require_frame_encryption = true;
     encoder_config->codec_type = kVideoCodecVP8;
-    VideoReceiveStream::Decoder decoder =
+    VideoReceiveStreamInterface::Decoder decoder =
         test::CreateMatchingDecoder(*send_config);
     for (auto& recv_config : *receive_configs) {
       recv_config.decoder_factory = &decoder_factory_;

video/end_to_end_tests/histogram_tests.cc

@@ -89,7 +89,7 @@ void HistogramTest::VerifyHistogramStats(bool use_rtx,
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       // NACK
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;

video/end_to_end_tests/multi_codec_receive_tests.cc

@@ -186,8 +186,10 @@ void MultiCodecReceiveTest::ConfigureDecoders(
   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(
+      VideoReceiveStreamInterface::Decoder decoder =
-          PayloadNameToPayloadType(config.payload_name), config.payload_name);
+          test::CreateMatchingDecoder(
+              PayloadNameToPayloadType(config.payload_name),
+              config.payload_name);
 
       video_receive_configs_[0].decoders.push_back(decoder);
     }

video/end_to_end_tests/multi_stream_tester.cc

@@ -59,7 +59,7 @@ void MultiStreamTester::RunTest() {
   std::unique_ptr<test::DirectTransport> receiver_transport;
 
   VideoSendStream* send_streams[kNumStreams];
-  VideoReceiveStream* receive_streams[kNumStreams];
+  VideoReceiveStreamInterface* receive_streams[kNumStreams];
   test::FrameGeneratorCapturer* frame_generators[kNumStreams];
   test::FunctionVideoEncoderFactory encoder_factory(
       []() { return VP8Encoder::Create(); });
@@ -99,11 +99,12 @@ void MultiStreamTester::RunTest() {
           send_config.Copy(), encoder_config.Copy());
       send_streams[i]->Start();
 
-      VideoReceiveStream::Config receive_config(receiver_transport.get());
+      VideoReceiveStreamInterface::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 =
+      VideoReceiveStreamInterface::Decoder decoder =
           test::CreateMatchingDecoder(send_config);
       receive_config.decoders.push_back(decoder);
 
@@ -152,7 +153,7 @@ void MultiStreamTester::UpdateSendConfig(
 
 void MultiStreamTester::UpdateReceiveConfig(
     size_t stream_index,
-    VideoReceiveStream::Config* receive_config) {}
+    VideoReceiveStreamInterface::Config* receive_config) {}
 
 std::unique_ptr<test::DirectTransport> MultiStreamTester::CreateSendTransport(
     TaskQueueBase* task_queue,

video/end_to_end_tests/multi_stream_tester.h

@@ -50,8 +50,9 @@ class MultiStreamTester {
                                 VideoSendStream::Config* send_config,
                                 VideoEncoderConfig* encoder_config,
                                 test::FrameGeneratorCapturer** frame_generator);
-  virtual void UpdateReceiveConfig(size_t stream_index,
+  virtual void UpdateReceiveConfig(
-                                   VideoReceiveStream::Config* receive_config);
+      size_t stream_index,
+      VideoReceiveStreamInterface::Config* receive_config);
   virtual std::unique_ptr<test::DirectTransport> CreateSendTransport(
       TaskQueueBase* task_queue,
       Call* sender_call);

video/end_to_end_tests/multi_stream_tests.cc

@@ -79,7 +79,7 @@ TEST(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
 
     void UpdateReceiveConfig(
         size_t stream_index,
-        VideoReceiveStream::Config* receive_config) override {
+        VideoReceiveStreamInterface::Config* receive_config) override {
       receive_config->renderer = observers_[stream_index].get();
     }
 

video/end_to_end_tests/network_state_tests.cc

@@ -223,7 +223,7 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder_factory = &encoder_factory_;
     }

video/end_to_end_tests/resolution_bitrate_limits_tests.cc

@@ -126,7 +126,7 @@ class InitEncodeTest : public test::EndToEndTest,
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     send_config->encoder_settings.encoder_factory = &encoder_factory_;
     send_config->rtp.payload_name = payload_name_;

video/end_to_end_tests/retransmission_tests.cc

@@ -105,7 +105,7 @@ TEST_F(RetransmissionEndToEndTest, ReceivesAndRetransmitsNack) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
@@ -209,9 +209,9 @@ TEST_F(RetransmissionEndToEndTest,
     explicit KeyframeRequestObserver(TaskQueueBase* task_queue)
         : clock_(Clock::GetRealTimeClock()), task_queue_(task_queue) {}
 
-    void OnVideoStreamsCreated(
+    void OnVideoStreamsCreated(VideoSendStream* send_stream,
-        VideoSendStream* send_stream,
+                               const std::vector<VideoReceiveStreamInterface*>&
-        const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                   receive_streams) override {
       RTC_DCHECK_EQ(1, receive_streams.size());
       send_stream_ = send_stream;
       receive_stream_ = receive_streams[0];
@@ -265,7 +265,7 @@ TEST_F(RetransmissionEndToEndTest,
    private:
     Clock* const clock_;
     VideoSendStream* send_stream_;
-    VideoReceiveStream* receive_stream_;
+    VideoReceiveStreamInterface* receive_stream_;
     TaskQueueBase* const task_queue_;
     rtc::Event test_done_;
     bool frame_decoded_ = false;
@@ -331,7 +331,7 @@ void RetransmissionEndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->rtp.nack.rtp_history_ms = rtp_history_ms_;
       (*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms_;
@@ -438,7 +438,7 @@ void RetransmissionEndToEndTest::DecodesRetransmittedFrame(bool enable_rtx,
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
 

video/end_to_end_tests/rtp_rtcp_tests.cc

@@ -91,7 +91,7 @@ void RtpRtcpEndToEndTest::RespectsRtcpMode(RtcpMode rtcp_mode) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;

video/end_to_end_tests/ssrc_tests.cc

@@ -176,7 +176,7 @@ void SsrcEndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       // Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
       encoder_config->max_bitrate_bps = 50000;
@@ -190,9 +190,9 @@ void SsrcEndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
         encoder_config->number_of_streams = 1;
     }
 
-    void OnVideoStreamsCreated(
+    void OnVideoStreamsCreated(VideoSendStream* send_stream,
-        VideoSendStream* send_stream,
+                               const std::vector<VideoReceiveStreamInterface*>&
-        const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                   receive_streams) override {
       send_stream_ = send_stream;
     }
 
@@ -278,7 +278,7 @@ TEST_F(SsrcEndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       // Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
       encoder_config->max_bitrate_bps = 50000;

video/end_to_end_tests/stats_tests.cc

@@ -88,7 +88,8 @@ TEST_F(StatsEndToEndTest, GetStats) {
 
     bool CheckReceiveStats() {
       for (size_t i = 0; i < receive_streams_.size(); ++i) {
-        VideoReceiveStream::Stats stats = receive_streams_[i]->GetStats();
+        VideoReceiveStreamInterface::Stats stats =
+            receive_streams_[i]->GetStats();
         EXPECT_EQ(expected_receive_ssrcs_[i], stats.ssrc);
 
         // Make sure all fields have been populated.
@@ -243,7 +244,7 @@ TEST_F(StatsEndToEndTest, GetStats) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       // Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
       encoder_config->max_bitrate_bps = 50000;
@@ -281,9 +282,9 @@ TEST_F(StatsEndToEndTest, GetStats) {
 
     size_t GetNumVideoStreams() const override { return kNumSimulcastStreams; }
 
-    void OnVideoStreamsCreated(
+    void OnVideoStreamsCreated(VideoSendStream* send_stream,
-        VideoSendStream* send_stream,
+                               const std::vector<VideoReceiveStreamInterface*>&
-        const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                   receive_streams) override {
       send_stream_ = send_stream;
       receive_streams_ = receive_streams;
       task_queue_ = TaskQueueBase::Current();
@@ -327,7 +328,7 @@ TEST_F(StatsEndToEndTest, GetStats) {
     }
 
     test::FunctionVideoEncoderFactory encoder_factory_;
-    std::vector<VideoReceiveStream*> receive_streams_;
+    std::vector<VideoReceiveStreamInterface*> receive_streams_;
     std::map<std::string, bool> receive_stats_filled_;
 
     VideoSendStream* send_stream_ = nullptr;
@@ -353,7 +354,7 @@ TEST_F(StatsEndToEndTest, TimingFramesAreReported) {
    private:
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->rtp.extensions.clear();
       send_config->rtp.extensions.push_back(
@@ -365,9 +366,9 @@ TEST_F(StatsEndToEndTest, TimingFramesAreReported) {
       }
     }
 
-    void OnVideoStreamsCreated(
+    void OnVideoStreamsCreated(VideoSendStream* send_stream,
-        VideoSendStream* send_stream,
+                               const std::vector<VideoReceiveStreamInterface*>&
-        const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                   receive_streams) override {
       receive_streams_ = receive_streams;
       task_queue_ = TaskQueueBase::Current();
     }
@@ -389,7 +390,7 @@ TEST_F(StatsEndToEndTest, TimingFramesAreReported) {
       });
     }
 
-    std::vector<VideoReceiveStream*> receive_streams_;
+    std::vector<VideoReceiveStreamInterface*> receive_streams_;
     TaskQueueBase* task_queue_ = nullptr;
   } test;
 
@@ -404,9 +405,9 @@ TEST_F(StatsEndToEndTest, TestReceivedRtpPacketStats) {
         : EndToEndTest(kDefaultTimeoutMs), task_queue_(task_queue) {}
 
    private:
-    void OnVideoStreamsCreated(
+    void OnVideoStreamsCreated(VideoSendStream* send_stream,
-        VideoSendStream* send_stream,
+                               const std::vector<VideoReceiveStreamInterface*>&
-        const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                   receive_streams) override {
       receive_stream_ = receive_streams[0];
     }
 
@@ -416,7 +417,8 @@ TEST_F(StatsEndToEndTest, TestReceivedRtpPacketStats) {
       if (sent_rtp_ >= kNumRtpPacketsToSend) {
         // Need to check the stats on the correct thread.
         task_queue_->PostTask(ToQueuedTask(task_safety_flag_, [this]() {
-          VideoReceiveStream::Stats stats = receive_stream_->GetStats();
+          VideoReceiveStreamInterface::Stats stats =
+              receive_stream_->GetStats();
           if (kNumRtpPacketsToSend == stats.rtp_stats.packet_counter.packets) {
             observation_complete_.Set();
           }
@@ -432,7 +434,7 @@ TEST_F(StatsEndToEndTest, TestReceivedRtpPacketStats) {
           << "Timed out while verifying number of received RTP packets.";
     }
 
-    VideoReceiveStream* receive_stream_ = nullptr;
+    VideoReceiveStreamInterface* receive_stream_ = nullptr;
     uint32_t sent_rtp_ = 0;
     TaskQueueBase* const task_queue_;
     rtc::scoped_refptr<PendingTaskSafetyFlag> task_safety_flag_ =
@@ -627,7 +629,7 @@ TEST_F(StatsEndToEndTest, VerifyNackStats) {
             stream_stats.rtcp_packet_type_counts.nack_packets;
       }
       for (const auto& receive_stream : receive_streams_) {
-        VideoReceiveStream::Stats stats = receive_stream->GetStats();
+        VideoReceiveStreamInterface::Stats stats = receive_stream->GetStats();
         receive_stream_nack_packets +=
             stats.rtcp_packet_type_counts.nack_packets;
       }
@@ -649,15 +651,15 @@ TEST_F(StatsEndToEndTest, VerifyNackStats) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
     }
 
-    void OnVideoStreamsCreated(
+    void OnVideoStreamsCreated(VideoSendStream* send_stream,
-        VideoSendStream* send_stream,
+                               const std::vector<VideoReceiveStreamInterface*>&
-        const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                   receive_streams) override {
       send_stream_ = send_stream;
       receive_streams_ = receive_streams;
     }
@@ -672,7 +674,7 @@ TEST_F(StatsEndToEndTest, VerifyNackStats) {
     uint64_t sent_rtp_packets_ RTC_GUARDED_BY(&mutex_) = 0;
     uint16_t dropped_rtp_packet_ RTC_GUARDED_BY(&mutex_) = 0;
     bool dropped_rtp_packet_requested_ RTC_GUARDED_BY(&mutex_) = false;
-    std::vector<VideoReceiveStream*> receive_streams_;
+    std::vector<VideoReceiveStreamInterface*> receive_streams_;
     VideoSendStream* send_stream_ = nullptr;
     absl::optional<int64_t> start_runtime_ms_;
     TaskQueueBase* const task_queue_;

video/end_to_end_tests/transport_feedback_tests.cc

@@ -201,7 +201,7 @@ TEST(TransportFeedbackMultiStreamTest, AssignsTransportSequenceNumbers) {
 
     void UpdateReceiveConfig(
         size_t stream_index,
-        VideoReceiveStream::Config* receive_config) override {
+        VideoReceiveStreamInterface::Config* receive_config) override {
       receive_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       receive_config->rtp.extensions.clear();
       receive_config->rtp.extensions.push_back(
@@ -292,7 +292,7 @@ class TransportFeedbackTester : public test::EndToEndTest {
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     (*receive_configs)[0].rtp.transport_cc = feedback_enabled_;
   }

video/frame_buffer_proxy.cc

@@ -166,10 +166,10 @@ Timestamp ReceiveTime(const EncodedFrame& frame) {
   return *ts;
 }
 
-// Encapsulates use of the new frame buffer for use in VideoReceiveStream. This
+// Encapsulates use of the new frame buffer for use in
-// behaves the same as the FrameBuffer2Proxy but uses frame_buffer instead.
+// VideoReceiveStreamInterface. This behaves the same as the FrameBuffer2Proxy
-// Responsibilities from frame_buffer2, like stats, jitter and frame timing
+// but uses frame_buffer instead. Responsibilities from frame_buffer2, like
-// accounting are moved into this pro
+// stats, jitter and frame timing accounting are moved into this pro
 class FrameBuffer3Proxy : public FrameBufferProxy {
  public:
   FrameBuffer3Proxy(

video/quality_scaling_tests.cc

@@ -119,7 +119,7 @@ class ScalingObserver : public test::SendTest {
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     send_config->encoder_settings.encoder_factory = &encoder_factory_;
     send_config->rtp.payload_name = payload_name_;

video/receive_statistics_proxy.cc

@@ -627,7 +627,7 @@ ReceiveStatisticsProxy::GetCurrentEstimatedPlayoutNtpTimestampMs(
   return *last_estimated_playout_ntp_timestamp_ms_ + elapsed_ms;
 }
 
-VideoReceiveStream::Stats ReceiveStatisticsProxy::GetStats() const {
+VideoReceiveStreamInterface::Stats ReceiveStatisticsProxy::GetStats() const {
   MutexLock lock(&mutex_);
   // Get current frame rates here, as only updating them on new frames prevents
   // us from ever correctly displaying frame rate of 0.

video/receive_statistics_proxy.h

@@ -48,7 +48,7 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback,
                          const FieldTrialsView* field_trials = nullptr);
   ~ReceiveStatisticsProxy() = default;
 
-  VideoReceiveStream::Stats GetStats() const;
+  VideoReceiveStreamInterface::Stats GetStats() const;
 
   void OnDecodedFrame(const VideoFrame& frame,
                       absl::optional<uint8_t> qp,
@@ -94,7 +94,7 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback,
   void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;
 
   // Notification methods that are used to check our internal state and validate
-  // threading assumptions. These are called by VideoReceiveStream.
+  // threading assumptions. These are called by VideoReceiveStreamInterface.
   void DecoderThreadStarting();
   void DecoderThreadStopped();
 
@@ -153,7 +153,7 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback,
   int num_bad_states_ RTC_GUARDED_BY(mutex_);
   int num_certain_states_ RTC_GUARDED_BY(mutex_);
   // Note: The `stats_.rtp_stats` member is not used or populated by this class.
-  mutable VideoReceiveStream::Stats stats_ RTC_GUARDED_BY(mutex_);
+  mutable VideoReceiveStreamInterface::Stats stats_ RTC_GUARDED_BY(mutex_);
   RateStatistics decode_fps_estimator_ RTC_GUARDED_BY(mutex_);
   RateStatistics renders_fps_estimator_ RTC_GUARDED_BY(mutex_);
   rtc::RateTracker render_fps_tracker_ RTC_GUARDED_BY(mutex_);

video/receive_statistics_proxy2.cc

@@ -652,11 +652,11 @@ ReceiveStatisticsProxy::GetCurrentEstimatedPlayoutNtpTimestampMs(
   return *last_estimated_playout_ntp_timestamp_ms_ + elapsed_ms;
 }
 
-VideoReceiveStream::Stats ReceiveStatisticsProxy::GetStats() const {
+VideoReceiveStreamInterface::Stats ReceiveStatisticsProxy::GetStats() const {
   RTC_DCHECK_RUN_ON(&main_thread_);
 
-  // Like VideoReceiveStream::GetStats, called on the worker thread from
+  // Like VideoReceiveStreamInterface::GetStats, called on the worker thread
-  // StatsCollector::ExtractMediaInfo via worker_thread()->Invoke().
+  // from StatsCollector::ExtractMediaInfo via worker_thread()->Invoke().
   // WebRtcVideoChannel::GetStats(), GetVideoReceiverInfo.
 
   // Get current frame rates here, as only updating them on new frames prevents

video/receive_statistics_proxy2.h

@@ -55,7 +55,7 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback,
                          const FieldTrialsView& field_trials);
   ~ReceiveStatisticsProxy() override;
 
-  VideoReceiveStream::Stats GetStats() const;
+  VideoReceiveStreamInterface::Stats GetStats() const;
 
   void OnDecodedFrame(const VideoFrame& frame,
                       absl::optional<uint8_t> qp,
@@ -111,7 +111,7 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback,
   void OnRttUpdate(int64_t avg_rtt_ms);
 
   // Notification methods that are used to check our internal state and validate
-  // threading assumptions. These are called by VideoReceiveStream.
+  // threading assumptions. These are called by VideoReceiveStreamInterface.
   void DecoderThreadStarting();
   void DecoderThreadStopped();
 
@@ -168,7 +168,8 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback,
   int num_bad_states_ RTC_GUARDED_BY(main_thread_);
   int num_certain_states_ RTC_GUARDED_BY(main_thread_);
   // Note: The `stats_.rtp_stats` member is not used or populated by this class.
-  mutable VideoReceiveStream::Stats stats_ RTC_GUARDED_BY(main_thread_);
+  mutable VideoReceiveStreamInterface::Stats stats_
+      RTC_GUARDED_BY(main_thread_);
   // Same as stats_.ssrc, but const (no lock required).
   const uint32_t remote_ssrc_;
   RateStatistics decode_fps_estimator_ RTC_GUARDED_BY(main_thread_);

video/receive_statistics_proxy2_unittest.cc

@@ -54,7 +54,7 @@ class ReceiveStatisticsProxy2Test : public ::testing::Test {
 
  protected:
   // Convenience method to avoid too many explict flushes.
-  VideoReceiveStream::Stats FlushAndGetStats() {
+  VideoReceiveStreamInterface::Stats FlushAndGetStats() {
     loop_.Flush();
     return statistics_proxy_->GetStats();
   }
@@ -431,7 +431,7 @@ TEST_F(ReceiveStatisticsProxy2Test, ReportInterframeDelayInWindow) {
 TEST_F(ReceiveStatisticsProxy2Test, ReportsFreezeMetrics) {
   const int64_t kFreezeDurationMs = 1000;
 
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(0u, stats.freeze_count);
   EXPECT_FALSE(stats.total_freezes_duration_ms);
 
@@ -452,7 +452,7 @@ TEST_F(ReceiveStatisticsProxy2Test, ReportsFreezeMetrics) {
 }
 
 TEST_F(ReceiveStatisticsProxy2Test, ReportsPauseMetrics) {
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   ASSERT_EQ(0u, stats.pause_count);
   ASSERT_EQ(0u, stats.total_pauses_duration_ms);
 
@@ -470,7 +470,7 @@ TEST_F(ReceiveStatisticsProxy2Test, ReportsPauseMetrics) {
 }
 
 TEST_F(ReceiveStatisticsProxy2Test, PauseBeforeFirstAndAfterLastFrameIgnored) {
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   ASSERT_EQ(0u, stats.pause_count);
   ASSERT_EQ(0u, stats.total_pauses_duration_ms);
 
@@ -493,7 +493,7 @@ TEST_F(ReceiveStatisticsProxy2Test, PauseBeforeFirstAndAfterLastFrameIgnored) {
 }
 
 TEST_F(ReceiveStatisticsProxy2Test, ReportsFramesDuration) {
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   ASSERT_EQ(0u, stats.total_frames_duration_ms);
 
   webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
@@ -513,7 +513,7 @@ TEST_F(ReceiveStatisticsProxy2Test, ReportsFramesDuration) {
 }
 
 TEST_F(ReceiveStatisticsProxy2Test, ReportsSumSquaredFrameDurations) {
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   ASSERT_EQ(0u, stats.sum_squared_frame_durations);
 
   webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
@@ -580,7 +580,7 @@ TEST_F(ReceiveStatisticsProxy2Test, GetStatsReportsOnCompleteFrame) {
   const int kFrameSizeBytes = 1000;
   statistics_proxy_->OnCompleteFrame(true, kFrameSizeBytes,
                                      VideoContentType::UNSPECIFIED);
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(1, stats.network_frame_rate);
   EXPECT_EQ(1, stats.frame_counts.key_frames);
   EXPECT_EQ(0, stats.frame_counts.delta_frames);
@@ -592,7 +592,7 @@ TEST_F(ReceiveStatisticsProxy2Test, GetStatsReportsOnDroppedFrame) {
     statistics_proxy_->OnDroppedFrames(i);
     dropped_frames += i;
   }
-  VideoReceiveStream::Stats stats = FlushAndGetStats();
+  VideoReceiveStreamInterface::Stats stats = FlushAndGetStats();
   EXPECT_EQ(dropped_frames, stats.frames_dropped);
 }
 
@@ -608,7 +608,7 @@ TEST_F(ReceiveStatisticsProxy2Test, GetStatsReportsDecodeTimingStats) {
   statistics_proxy_->OnFrameBufferTimingsUpdated(
       kMaxDecodeMs, kCurrentDelayMs, kTargetDelayMs, kJitterBufferMs,
       kMinPlayoutDelayMs, kRenderDelayMs);
-  VideoReceiveStream::Stats stats = FlushAndGetStats();
+  VideoReceiveStreamInterface::Stats stats = FlushAndGetStats();
   EXPECT_EQ(kMaxDecodeMs, stats.max_decode_ms);
   EXPECT_EQ(kCurrentDelayMs, stats.current_delay_ms);
   EXPECT_EQ(kTargetDelayMs, stats.target_delay_ms);
@@ -626,7 +626,7 @@ TEST_F(ReceiveStatisticsProxy2Test, GetStatsReportsRtcpPacketTypeCounts) {
   counter.pli_packets = kPliPackets;
   counter.nack_packets = kNackPackets;
   statistics_proxy_->RtcpPacketTypesCounterUpdated(kRemoteSsrc, counter);
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(kFirPackets, stats.rtcp_packet_type_counts.fir_packets);
   EXPECT_EQ(kPliPackets, stats.rtcp_packet_type_counts.pli_packets);
   EXPECT_EQ(kNackPackets, stats.rtcp_packet_type_counts.nack_packets);
@@ -651,7 +651,7 @@ TEST_F(ReceiveStatisticsProxy2Test, GetStatsReportsFrameCounts) {
     statistics_proxy_->OnCompleteFrame(false, 0, VideoContentType::UNSPECIFIED);
   }
 
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(kKeyFrames, stats.frame_counts.key_frames);
   EXPECT_EQ(kDeltaFrames, stats.frame_counts.delta_frames);
 }
@@ -1275,7 +1275,7 @@ INSTANTIATE_TEST_SUITE_P(_,
                                            kFreezeDetectionCond2NotFreeze));
 
 TEST_P(ReceiveStatisticsProxy2TestWithFreezeDuration, FreezeDetection) {
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(0u, stats.freeze_count);
   webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
 

video/receive_statistics_proxy_unittest.cc

@@ -52,8 +52,8 @@ class ReceiveStatisticsProxyTest : public ::testing::Test {
         config_.rtp.remote_ssrc, &fake_clock_, &field_trials_));
   }
 
-  VideoReceiveStream::Config GetTestConfig() {
+  VideoReceiveStreamInterface::Config GetTestConfig() {
-    VideoReceiveStream::Config config(nullptr);
+    VideoReceiveStreamInterface::Config config(nullptr);
     config.rtp.local_ssrc = kLocalSsrc;
     config.rtp.remote_ssrc = kRemoteSsrc;
     return config;
@@ -81,7 +81,7 @@ class ReceiveStatisticsProxyTest : public ::testing::Test {
 
   test::ScopedKeyValueConfig field_trials_;
   SimulatedClock fake_clock_;
-  const VideoReceiveStream::Config config_;
+  const VideoReceiveStreamInterface::Config config_;
   std::unique_ptr<ReceiveStatisticsProxy> statistics_proxy_;
 };
 
@@ -313,7 +313,7 @@ TEST_F(ReceiveStatisticsProxyTest, ReportInterframeDelayInWindow) {
 TEST_F(ReceiveStatisticsProxyTest, ReportsFreezeMetrics) {
   const int64_t kFreezeDurationMs = 1000;
 
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(0u, stats.freeze_count);
   EXPECT_FALSE(stats.total_freezes_duration_ms);
 
@@ -334,7 +334,7 @@ TEST_F(ReceiveStatisticsProxyTest, ReportsFreezeMetrics) {
 }
 
 TEST_F(ReceiveStatisticsProxyTest, ReportsPauseMetrics) {
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   ASSERT_EQ(0u, stats.pause_count);
   ASSERT_EQ(0u, stats.total_pauses_duration_ms);
 
@@ -352,7 +352,7 @@ TEST_F(ReceiveStatisticsProxyTest, ReportsPauseMetrics) {
 }
 
 TEST_F(ReceiveStatisticsProxyTest, PauseBeforeFirstAndAfterLastFrameIgnored) {
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   ASSERT_EQ(0u, stats.pause_count);
   ASSERT_EQ(0u, stats.total_pauses_duration_ms);
 
@@ -375,7 +375,7 @@ TEST_F(ReceiveStatisticsProxyTest, PauseBeforeFirstAndAfterLastFrameIgnored) {
 }
 
 TEST_F(ReceiveStatisticsProxyTest, ReportsFramesDuration) {
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   ASSERT_EQ(0u, stats.total_frames_duration_ms);
 
   webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
@@ -395,7 +395,7 @@ TEST_F(ReceiveStatisticsProxyTest, ReportsFramesDuration) {
 }
 
 TEST_F(ReceiveStatisticsProxyTest, ReportsSumSquaredFrameDurations) {
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   ASSERT_EQ(0u, stats.sum_squared_frame_durations);
 
   webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
@@ -460,7 +460,7 @@ TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsOnCompleteFrame) {
   const int kFrameSizeBytes = 1000;
   statistics_proxy_->OnCompleteFrame(true, kFrameSizeBytes,
                                      VideoContentType::UNSPECIFIED);
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(1, stats.network_frame_rate);
   EXPECT_EQ(1, stats.frame_counts.key_frames);
   EXPECT_EQ(0, stats.frame_counts.delta_frames);
@@ -472,7 +472,7 @@ TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsOnDroppedFrame) {
     statistics_proxy_->OnDroppedFrames(i);
     dropped_frames += i;
   }
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(dropped_frames, stats.frames_dropped);
 }
 
@@ -488,7 +488,7 @@ TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsDecodeTimingStats) {
   statistics_proxy_->OnFrameBufferTimingsUpdated(
       kMaxDecodeMs, kCurrentDelayMs, kTargetDelayMs, kJitterBufferMs,
       kMinPlayoutDelayMs, kRenderDelayMs);
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(kMaxDecodeMs, stats.max_decode_ms);
   EXPECT_EQ(kCurrentDelayMs, stats.current_delay_ms);
   EXPECT_EQ(kTargetDelayMs, stats.target_delay_ms);
@@ -506,7 +506,7 @@ TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsRtcpPacketTypeCounts) {
   counter.pli_packets = kPliPackets;
   counter.nack_packets = kNackPackets;
   statistics_proxy_->RtcpPacketTypesCounterUpdated(kRemoteSsrc, counter);
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(kFirPackets, stats.rtcp_packet_type_counts.fir_packets);
   EXPECT_EQ(kPliPackets, stats.rtcp_packet_type_counts.pli_packets);
   EXPECT_EQ(kNackPackets, stats.rtcp_packet_type_counts.nack_packets);
@@ -531,7 +531,7 @@ TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsFrameCounts) {
     statistics_proxy_->OnCompleteFrame(false, 0, VideoContentType::UNSPECIFIED);
   }
 
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(kKeyFrames, stats.frame_counts.key_frames);
   EXPECT_EQ(kDeltaFrames, stats.frame_counts.delta_frames);
 }
@@ -1150,7 +1150,7 @@ INSTANTIATE_TEST_SUITE_P(_,
                                            kFreezeDetectionCond2NotFreeze));
 
 TEST_P(ReceiveStatisticsProxyTestWithFreezeDuration, FreezeDetection) {
-  VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
+  VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(0u, stats.freeze_count);
   webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
 

video/rtp_video_stream_receiver.cc

@@ -203,7 +203,7 @@ RtpVideoStreamReceiver::RtpVideoStreamReceiver(
     Transport* transport,
     RtcpRttStats* rtt_stats,
     PacketRouter* packet_router,
-    const VideoReceiveStream::Config* config,
+    const VideoReceiveStreamInterface::Config* config,
     ReceiveStatistics* rtp_receive_statistics,
     ReceiveStatisticsProxy* receive_stats_proxy,
     ProcessThread* process_thread,
@@ -234,7 +234,7 @@ RtpVideoStreamReceiver::RtpVideoStreamReceiver(
     Transport* transport,
     RtcpRttStats* rtt_stats,
     PacketRouter* packet_router,
-    const VideoReceiveStream::Config* config,
+    const VideoReceiveStreamInterface::Config* config,
     ReceiveStatistics* rtp_receive_statistics,
     RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
     RtcpCnameCallback* rtcp_cname_callback,

video/rtp_video_stream_receiver.h

@@ -90,7 +90,7 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
       // stream is registered as a candidate for sending REMB and transport
       // feedback.
       PacketRouter* packet_router,
-      const VideoReceiveStream::Config* config,
+      const VideoReceiveStreamInterface::Config* config,
       ReceiveStatistics* rtp_receive_statistics,
       ReceiveStatisticsProxy* receive_stats_proxy,
       ProcessThread* process_thread,
@@ -111,7 +111,7 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
       // stream is registered as a candidate for sending REMB and transport
       // feedback.
       PacketRouter* packet_router,
-      const VideoReceiveStream::Config* config,
+      const VideoReceiveStreamInterface::Config* config,
       ReceiveStatistics* rtp_receive_statistics,
       RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
       RtcpCnameCallback* rtcp_cname_callback,
@@ -201,7 +201,7 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
   void SetDepacketizerToDecoderFrameTransformer(
       rtc::scoped_refptr<FrameTransformerInterface> frame_transformer);
 
-  // Called by VideoReceiveStream when stats are updated.
+  // Called by VideoReceiveStreamInterface when stats are updated.
   void UpdateRtt(int64_t max_rtt_ms);
 
   absl::optional<int64_t> LastReceivedPacketMs() const;
@@ -322,8 +322,9 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
   FieldTrialBasedConfig owned_field_trials_;
 
   Clock* const clock_;
-  // Ownership of this object lies with VideoReceiveStream, which owns `this`.
+  // Ownership of this object lies with VideoReceiveStreamInterface, which owns
-  const VideoReceiveStream::Config& config_;
+  // `this`.
+  const VideoReceiveStreamInterface::Config& config_;
   PacketRouter* const packet_router_;
   ProcessThread* const process_thread_;
 

video/rtp_video_stream_receiver2.cc

@@ -105,7 +105,7 @@ std::unique_ptr<ModuleRtpRtcpImpl2> CreateRtpRtcpModule(
 std::unique_ptr<NackRequester> MaybeConstructNackModule(
     TaskQueueBase* current_queue,
     NackPeriodicProcessor* nack_periodic_processor,
-    const VideoReceiveStream::Config& config,
+    const VideoReceiveStreamInterface::Config& config,
     Clock* clock,
     NackSender* nack_sender,
     KeyFrameRequestSender* keyframe_request_sender,
@@ -208,7 +208,7 @@ RtpVideoStreamReceiver2::RtpVideoStreamReceiver2(
     Transport* transport,
     RtcpRttStats* rtt_stats,
     PacketRouter* packet_router,
-    const VideoReceiveStream::Config* config,
+    const VideoReceiveStreamInterface::Config* config,
     ReceiveStatistics* rtp_receive_statistics,
     RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
     RtcpCnameCallback* rtcp_cname_callback,

video/rtp_video_stream_receiver2.h

@@ -85,7 +85,7 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
       // stream is registered as a candidate for sending REMB and transport
       // feedback.
       PacketRouter* packet_router,
-      const VideoReceiveStream::Config* config,
+      const VideoReceiveStreamInterface::Config* config,
       ReceiveStatistics* rtp_receive_statistics,
       RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
       RtcpCnameCallback* rtcp_cname_callback,
@@ -181,7 +181,7 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
   void SetRtpExtensions(const std::vector<RtpExtension>& extensions);
   const RtpHeaderExtensionMap& GetRtpExtensions() const;
 
-  // Called by VideoReceiveStream when stats are updated.
+  // Called by VideoReceiveStreamInterface when stats are updated.
   void UpdateRtt(int64_t max_rtt_ms);
 
   // Called when the local_ssrc is changed to match with a sender.
@@ -293,8 +293,9 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
 
   const FieldTrialsView& field_trials_;
   Clock* const clock_;
-  // Ownership of this object lies with VideoReceiveStream, which owns `this`.
+  // Ownership of this object lies with VideoReceiveStreamInterface, which owns
-  const VideoReceiveStream::Config& config_;
+  // `this`.
+  const VideoReceiveStreamInterface::Config& config_;
   PacketRouter* const packet_router_;
 
   RemoteNtpTimeEstimator ntp_estimator_;

video/rtp_video_stream_receiver2_unittest.cc

@@ -215,8 +215,8 @@ class RtpVideoStreamReceiver2Test : public ::testing::Test,
   }
 
  protected:
-  VideoReceiveStream::Config CreateConfig() {
+  VideoReceiveStreamInterface::Config CreateConfig() {
-    VideoReceiveStream::Config config(nullptr);
+    VideoReceiveStreamInterface::Config config(nullptr);
     config.rtp.remote_ssrc = 1111;
     config.rtp.local_ssrc = 2222;
     config.rtp.red_payload_type = kRedPayloadType;
@@ -229,7 +229,7 @@ class RtpVideoStreamReceiver2Test : public ::testing::Test,
   TokenTaskQueue::CurrentTaskQueueSetter task_queue_setter_;
 
   webrtc::test::ScopedKeyValueConfig field_trials_;
-  VideoReceiveStream::Config config_;
+  VideoReceiveStreamInterface::Config config_;
   NackPeriodicProcessor nack_periodic_processor_;
   MockNackSender mock_nack_sender_;
   MockKeyFrameRequestSender mock_key_frame_request_sender_;

video/rtp_video_stream_receiver_unittest.cc

@@ -202,8 +202,8 @@ class RtpVideoStreamReceiverTest : public ::testing::Test {
   }
 
  protected:
-  static VideoReceiveStream::Config CreateConfig() {
+  static VideoReceiveStreamInterface::Config CreateConfig() {
-    VideoReceiveStream::Config config(nullptr);
+    VideoReceiveStreamInterface::Config config(nullptr);
     config.rtp.remote_ssrc = 1111;
     config.rtp.local_ssrc = 2222;
     config.rtp.red_payload_type = kRedPayloadType;
@@ -211,7 +211,7 @@ class RtpVideoStreamReceiverTest : public ::testing::Test {
   }
 
   webrtc::test::ScopedKeyValueConfig field_trials_;
-  VideoReceiveStream::Config config_;
+  VideoReceiveStreamInterface::Config config_;
   MockNackSender mock_nack_sender_;
   MockKeyFrameRequestSender mock_key_frame_request_sender_;
   MockTransport mock_transport_;

video/video_analyzer.cc

@@ -188,7 +188,7 @@ void VideoAnalyzer::SetSendStream(VideoSendStream* stream) {
   send_stream_ = stream;
 }
 
-void VideoAnalyzer::SetReceiveStream(VideoReceiveStream* stream) {
+void VideoAnalyzer::SetReceiveStream(VideoReceiveStreamInterface* stream) {
   MutexLock lock(&lock_);
   RTC_DCHECK(!receive_stream_);
   receive_stream_ = stream;
@@ -490,7 +490,8 @@ void VideoAnalyzer::PollStats() {
   last_fec_bytes_ = fec_bytes;
 
   if (receive_stream_ != nullptr) {
-    VideoReceiveStream::Stats receive_stats = receive_stream_->GetStats();
+    VideoReceiveStreamInterface::Stats receive_stats =
+        receive_stream_->GetStats();
     // `total_decode_time_ms` gives a good estimate of the mean decode time,
     // `decode_ms` is used to keep track of the standard deviation.
     if (receive_stats.frames_decoded > 0)

video/video_analyzer.h

@@ -61,7 +61,7 @@ class VideoAnalyzer : public PacketReceiver,
                  bool respect_sink_wants);
   void SetCall(Call* call);
   void SetSendStream(VideoSendStream* stream);
-  void SetReceiveStream(VideoReceiveStream* stream);
+  void SetReceiveStream(VideoReceiveStreamInterface* stream);
   void SetAudioReceiveStream(AudioReceiveStream* recv_stream);
 
   rtc::VideoSinkInterface<VideoFrame>* InputInterface();
@@ -221,7 +221,7 @@ class VideoAnalyzer : public PacketReceiver,
 
   Call* call_;
   VideoSendStream* send_stream_;
-  VideoReceiveStream* receive_stream_;
+  VideoReceiveStreamInterface* receive_stream_;
   AudioReceiveStream* audio_receive_stream_;
   CapturedFrameForwarder captured_frame_forwarder_;
   const std::string test_label_;

video/video_quality_test.cc

@@ -1011,7 +1011,7 @@ void VideoQualityTest::DestroyThumbnailStreams() {
     receiver_call_->DestroyVideoSendStream(thumbnail_send_stream);
   }
   thumbnail_send_streams_.clear();
-  for (VideoReceiveStream* thumbnail_receive_stream :
+  for (VideoReceiveStreamInterface* thumbnail_receive_stream :
        thumbnail_receive_streams_) {
     sender_call_->DestroyVideoReceiveStream(thumbnail_receive_stream);
   }
@@ -1152,12 +1152,12 @@ void VideoQualityTest::StartAudioStreams() {
 void VideoQualityTest::StartThumbnails() {
   for (VideoSendStream* send_stream : thumbnail_send_streams_)
     send_stream->Start();
-  for (VideoReceiveStream* receive_stream : thumbnail_receive_streams_)
+  for (VideoReceiveStreamInterface* receive_stream : thumbnail_receive_streams_)
     receive_stream->Start();
 }
 
 void VideoQualityTest::StopThumbnails() {
-  for (VideoReceiveStream* receive_stream : thumbnail_receive_streams_)
+  for (VideoReceiveStreamInterface* receive_stream : thumbnail_receive_streams_)
     receive_stream->Stop();
   for (VideoSendStream* send_stream : thumbnail_send_streams_)
     send_stream->Stop();

video/video_quality_test.h

@@ -97,7 +97,7 @@ class VideoQualityTest : public test::CallTest,
                              bool use_real_adm);
   void SetupAudio(Transport* transport);
 
-  void StartEncodedFrameLogs(VideoReceiveStream* stream);
+  void StartEncodedFrameLogs(VideoReceiveStreamInterface* stream);
 
   virtual std::unique_ptr<test::LayerFilteringTransport> CreateSendTransport();
   virtual std::unique_ptr<test::DirectTransport> CreateReceiveTransport();
@@ -118,8 +118,8 @@ class VideoQualityTest : public test::CallTest,
   std::vector<VideoSendStream::Config> thumbnail_send_configs_;
   std::vector<VideoEncoderConfig> thumbnail_encoder_configs_;
   std::vector<VideoSendStream*> thumbnail_send_streams_;
-  std::vector<VideoReceiveStream::Config> thumbnail_receive_configs_;
+  std::vector<VideoReceiveStreamInterface::Config> thumbnail_receive_configs_;
-  std::vector<VideoReceiveStream*> thumbnail_receive_streams_;
+  std::vector<VideoReceiveStreamInterface*> thumbnail_receive_streams_;
 
   int receive_logs_;
   int send_logs_;

video/video_receive_stream2.cc

@@ -184,8 +184,9 @@ constexpr TimeDelta kInactiveStreamThreshold = TimeDelta::Minutes(10);
 
 }  // namespace
 
-TimeDelta DetermineMaxWaitForFrame(const VideoReceiveStream::Config& config,
+TimeDelta DetermineMaxWaitForFrame(
-                                   bool is_keyframe) {
+    const VideoReceiveStreamInterface::Config& config,
+    bool is_keyframe) {
   // A (arbitrary) conversion factor between the remotely signalled NACK buffer
   // time (if not present defaults to 1000ms) and the maximum time we wait for a
   // remote frame. Chosen to not change existing defaults when using not
@@ -206,7 +207,7 @@ VideoReceiveStream2::VideoReceiveStream2(
     Call* call,
     int num_cpu_cores,
     PacketRouter* packet_router,
-    VideoReceiveStream::Config config,
+    VideoReceiveStreamInterface::Config config,
     CallStats* call_stats,
     Clock* clock,
     std::unique_ptr<VCMTiming> timing,
@@ -532,7 +533,7 @@ void VideoReceiveStream2::CreateAndRegisterExternalDecoder(
                                           decoder.payload_type);
 }
 
-VideoReceiveStream::Stats VideoReceiveStream2::GetStats() const {
+VideoReceiveStreamInterface::Stats VideoReceiveStream2::GetStats() const {
   RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
   VideoReceiveStream2::Stats stats = stats_proxy_.GetStats();
   stats.total_bitrate_bps = 0;

video/video_receive_stream2.h

@@ -79,7 +79,7 @@ struct VideoFrameMetaData {
 };
 
 class VideoReceiveStream2
-    : public webrtc::VideoReceiveStream,
+    : public webrtc::VideoReceiveStreamInterface,
       public rtc::VideoSinkInterface<VideoFrame>,
       public NackSender,
       public RtpVideoStreamReceiver2::OnCompleteFrameCallback,
@@ -95,7 +95,7 @@ class VideoReceiveStream2
                       Call* call,
                       int num_cpu_cores,
                       PacketRouter* packet_router,
-                      VideoReceiveStream::Config config,
+                      VideoReceiveStreamInterface::Config config,
                       CallStats* call_stats,
                       Clock* clock,
                       std::unique_ptr<VCMTiming> timing,
@@ -135,7 +135,7 @@ class VideoReceiveStream2
   // sender has been created, changed or removed.
   void SetLocalSsrc(uint32_t local_ssrc);
 
-  // Implements webrtc::VideoReceiveStream.
+  // Implements webrtc::VideoReceiveStreamInterface.
   void Start() override;
   void Stop() override;
 
@@ -143,7 +143,7 @@ class VideoReceiveStream2
   RtpHeaderExtensionMap GetRtpExtensionMap() const override;
   bool transport_cc() const override { return config_.rtp.transport_cc; }
 
-  webrtc::VideoReceiveStream::Stats GetStats() const override;
+  webrtc::VideoReceiveStreamInterface::Stats GetStats() const override;
 
   // SetBaseMinimumPlayoutDelayMs and GetBaseMinimumPlayoutDelayMs are called
   // from webrtc/api level and requested by user code. For e.g. blink/js layer
@@ -225,7 +225,7 @@ class VideoReceiveStream2
   TaskQueueFactory* const task_queue_factory_;
 
   TransportAdapter transport_adapter_;
-  const VideoReceiveStream::Config config_;
+  const VideoReceiveStreamInterface::Config config_;
   const int num_cpu_cores_;
   Call* const call_;
   Clock* const clock_;

video/video_receive_stream2_unittest.cc

@@ -226,12 +226,12 @@ class VideoReceiveStream2Test : public ::testing::TestWithParam<bool> {
     config_.rtp.remote_ssrc = 1111;
     config_.rtp.local_ssrc = 2222;
     config_.renderer = &fake_renderer_;
-    VideoReceiveStream::Decoder h264_decoder;
+    VideoReceiveStreamInterface::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=="});
-    VideoReceiveStream::Decoder h265_decoder;
+    VideoReceiveStreamInterface::Decoder h265_decoder;
     h265_decoder.payload_type = 100;
     h265_decoder.video_format = SdpVideoFormat("H265");
 
@@ -240,8 +240,9 @@ class VideoReceiveStream2Test : public ::testing::TestWithParam<bool> {
     RecreateReceiveStream();
   }
 
-  void RecreateReceiveStream(absl::optional<VideoReceiveStream::RecordingState>
+  void RecreateReceiveStream(
-                                 state = absl::nullopt) {
+      absl::optional<VideoReceiveStreamInterface::RecordingState> state =
+          absl::nullopt) {
     if (video_receive_stream_) {
       video_receive_stream_->UnregisterFromTransport();
       video_receive_stream_ = nullptr;
@@ -266,7 +267,7 @@ class VideoReceiveStream2Test : public ::testing::TestWithParam<bool> {
   test::RunLoop loop_;
   NackPeriodicProcessor nack_periodic_processor_;
   testing::NiceMock<MockVideoDecoderFactory> mock_h264_decoder_factory_;
-  VideoReceiveStream::Config config_;
+  VideoReceiveStreamInterface::Config config_;
   internal::CallStats call_stats_;
   testing::NiceMock<MockVideoDecoder> mock_decoder_;
   FakeVideoRenderer fake_renderer_;
@@ -600,7 +601,8 @@ TEST_P(VideoReceiveStream2Test, PassesFrameWhenEncodedFramesCallbackSet) {
   EXPECT_CALL(mock_transport_, SendRtcp);
   EXPECT_CALL(callback, Call);
   video_receive_stream_->SetAndGetRecordingState(
-      VideoReceiveStream::RecordingState(callback.AsStdFunction()), true);
+      VideoReceiveStreamInterface::RecordingState(callback.AsStdFunction()),
+      true);
   video_receive_stream_->OnCompleteFrame(
       MakeFrame(VideoFrameType::kVideoFrameKey, 0));
   EXPECT_TRUE(fake_renderer_.WaitForFrame(kDefaultTimeOut));
@@ -613,11 +615,12 @@ TEST_P(VideoReceiveStream2Test, MovesEncodedFrameDispatchStateWhenReCreating) {
   // Expect a key frame request over RTCP.
   EXPECT_CALL(mock_transport_, SendRtcp).Times(1);
   video_receive_stream_->SetAndGetRecordingState(
-      VideoReceiveStream::RecordingState(callback.AsStdFunction()), true);
+      VideoReceiveStreamInterface::RecordingState(callback.AsStdFunction()),
+      true);
   video_receive_stream_->Stop();
-  VideoReceiveStream::RecordingState old_state =
+  VideoReceiveStreamInterface::RecordingState old_state =
       video_receive_stream_->SetAndGetRecordingState(
-          VideoReceiveStream::RecordingState(), false);
+          VideoReceiveStreamInterface::RecordingState(), false);
   RecreateReceiveStream(std::move(old_state));
   video_receive_stream_->Stop();
 }
@@ -671,7 +674,7 @@ TEST_P(VideoReceiveStream2Test,
   video_receive_stream_->Start();
   testing::MockFunction<void(const RecordableEncodedFrame&)> callback;
   video_receive_stream_->SetAndGetRecordingState(
-      VideoReceiveStream::RecordingState(callback.AsStdFunction()),
+      VideoReceiveStreamInterface::RecordingState(callback.AsStdFunction()),
       /*generate_key_frame=*/false);
 
   InSequence s;
@@ -694,7 +697,7 @@ TEST_P(VideoReceiveStream2Test,
   video_receive_stream_->Start();
   testing::MockFunction<void(const RecordableEncodedFrame&)> callback;
   video_receive_stream_->SetAndGetRecordingState(
-      VideoReceiveStream::RecordingState(callback.AsStdFunction()),
+      VideoReceiveStreamInterface::RecordingState(callback.AsStdFunction()),
       /*generate_key_frame=*/false);
 
   InSequence s;

video/video_send_stream_tests.cc

@@ -189,7 +189,7 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->rtp.c_name = kCName;
     }
@@ -233,7 +233,7 @@ TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->rtp.extensions.clear();
       send_config->rtp.extensions.push_back(
@@ -279,7 +279,7 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder_factory = &encoder_factory_;
       send_config->rtp.extensions.clear();
@@ -326,7 +326,7 @@ TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder_factory = &encoder_factory_;
     }
@@ -362,7 +362,7 @@ TEST_F(VideoSendStreamTest, SupportsVideoRotation) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->rtp.extensions.clear();
       send_config->rtp.extensions.push_back(RtpExtension(
@@ -411,7 +411,7 @@ TEST_F(VideoSendStreamTest, SupportsVideoContentType) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->rtp.extensions.clear();
       send_config->rtp.extensions.push_back(RtpExtension(
@@ -455,7 +455,7 @@ TEST_F(VideoSendStreamTest, SupportsVideoTimingFrames) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->rtp.extensions.clear();
       send_config->rtp.extensions.push_back(
@@ -606,7 +606,7 @@ class UlpfecObserver : public test::EndToEndTest {
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     if (use_nack_) {
       send_config->rtp.nack.rtp_history_ms =
@@ -820,7 +820,7 @@ class FlexfecObserver : public test::EndToEndTest {
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     if (use_nack_) {
       send_config->rtp.nack.rtp_history_ms =
@@ -1020,7 +1020,7 @@ void VideoSendStreamTest::TestNackRetransmission(
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       transport_adapter_.reset(
           new internal::TransportAdapter(send_config->send_transport));
@@ -1224,7 +1224,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       transport_adapter_.reset(
           new internal::TransportAdapter(send_config->send_transport));
@@ -1357,7 +1357,7 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       // Make sure padding is sent if encoder is not producing media.
       encoder_config->min_transmit_bitrate_bps = 50000;
@@ -1436,7 +1436,7 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       // Turn on RTX.
       send_config->rtp.rtx.payload_type = kFakeVideoSendPayloadType;
@@ -1525,9 +1525,9 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
       return DROP_PACKET;
     }
 
-    void OnVideoStreamsCreated(
+    void OnVideoStreamsCreated(VideoSendStream* send_stream,
-        VideoSendStream* send_stream,
+                               const std::vector<VideoReceiveStreamInterface*>&
-        const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                   receive_streams) override {
       stream_ = send_stream;
       RtpRtcpInterface::Configuration config;
       config.clock = Clock::GetRealTimeClock();
@@ -1539,7 +1539,7 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       feedback_transport_.reset(
           new internal::TransportAdapter(send_config->send_transport));
@@ -1595,7 +1595,7 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       RTC_DCHECK_RUN_ON(&task_queue_thread_);
       send_config->rtp.extensions.clear();
@@ -1814,7 +1814,7 @@ TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->rtp.max_packet_size = kMaxRtpPacketSize;
     }
@@ -1886,7 +1886,7 @@ class MaxPaddingSetTest : public test::SendTest {
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     RTC_DCHECK_RUN_ON(&task_queue_thread_);
     RTC_DCHECK_EQ(1, encoder_config->number_of_streams);
@@ -2299,15 +2299,15 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
       EXPECT_TRUE(IsReadyForEncode());
     }
 
-    void OnVideoStreamsCreated(
+    void OnVideoStreamsCreated(VideoSendStream* send_stream,
-        VideoSendStream* send_stream,
+                               const std::vector<VideoReceiveStreamInterface*>&
-        const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                   receive_streams) override {
       stream_ = send_stream;
     }
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder_factory = &encoder_factory_;
       encoder_config_ = encoder_config->Copy();
@@ -2367,7 +2367,7 @@ class VideoCodecConfigObserver : public test::SendTest,
  private:
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     send_config->encoder_settings.encoder_factory = &encoder_factory_;
     send_config->rtp.payload_name = CodecTypeToPayloadString(video_codec_type_);
@@ -2380,9 +2380,9 @@ class VideoCodecConfigObserver : public test::SendTest,
     encoder_config_ = encoder_config->Copy();
   }
 
-  void OnVideoStreamsCreated(
+  void OnVideoStreamsCreated(VideoSendStream* send_stream,
-      VideoSendStream* send_stream,
+                             const std::vector<VideoReceiveStreamInterface*>&
-      const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                 receive_streams) override {
     stream_ = send_stream;
   }
 
@@ -2650,7 +2650,7 @@ TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder_factory = &encoder_factory_;
       EXPECT_EQ(1u, encoder_config->number_of_streams);
@@ -2792,7 +2792,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder_factory = &encoder_factory_;
       send_config->encoder_settings.bitrate_allocator_factory = this;
@@ -2809,9 +2809,9 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
       call_ = sender_call;
     }
 
-    void OnVideoStreamsCreated(
+    void OnVideoStreamsCreated(VideoSendStream* send_stream,
-        VideoSendStream* send_stream,
+                               const std::vector<VideoReceiveStreamInterface*>&
-        const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                   receive_streams) override {
       send_stream_ = send_stream;
     }
 
@@ -2930,7 +2930,7 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
     }
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder_factory = &encoder_factory_;
       EXPECT_EQ(kNumStreams, encoder_config->number_of_streams);
@@ -2957,9 +2957,9 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
       }
     }
 
-    void OnVideoStreamsCreated(
+    void OnVideoStreamsCreated(VideoSendStream* send_stream,
-        VideoSendStream* send_stream,
+                               const std::vector<VideoReceiveStreamInterface*>&
-        const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                   receive_streams) override {
       send_stream_ = send_stream;
     }
 
@@ -2982,7 +2982,7 @@ class Vp9HeaderObserver : public test::SendTest {
 
   virtual void ModifyVideoConfigsHook(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) {}
 
   virtual void InspectHeader(const RTPVideoHeaderVP9& vp9) = 0;
@@ -2992,7 +2992,7 @@ class Vp9HeaderObserver : public test::SendTest {
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     send_config->encoder_settings.encoder_factory = &encoder_factory_;
     send_config->rtp.payload_name = "VP9";
@@ -3390,7 +3390,7 @@ void VideoSendStreamTest::TestVp9NonFlexMode(
 
     void ModifyVideoConfigsHook(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       encoder_config->codec_type = kVideoCodecVP9;
       int bitrate_bps = 0;
@@ -3498,7 +3498,7 @@ TEST_F(VideoSendStreamTest, Vp9NonFlexModeSmallResolution) {
    private:
     void ModifyVideoConfigsHook(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       encoder_config->codec_type = kVideoCodecVP9;
       vp9_settings_.flexibleMode = false;
@@ -3546,7 +3546,7 @@ TEST_F(VideoSendStreamTest, MAYBE_Vp9FlexModeRefCount) {
    private:
     void ModifyVideoConfigsHook(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       encoder_config->codec_type = kVideoCodecVP9;
       encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
@@ -3626,7 +3626,7 @@ TEST_F(VideoSendStreamTest, EncoderConfigMaxFramerateReportedToSource) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       encoder_config->simulcast_layers[0].max_framerate = kMaxFps;
     }
@@ -3674,7 +3674,7 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->rtp.max_packet_size = 1200;
       send_config->encoder_settings.encoder_factory = &encoder_factory_;
@@ -3734,7 +3734,7 @@ class PacingFactorObserver : public test::SendTest {
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     // Check if send-side bwe extension is already present, and remove it if
     // it is not desired.
@@ -3766,9 +3766,9 @@ class PacingFactorObserver : public test::SendTest {
     encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
   }
 
-  void OnVideoStreamsCreated(
+  void OnVideoStreamsCreated(VideoSendStream* send_stream,
-      VideoSendStream* send_stream,
+                             const std::vector<VideoReceiveStreamInterface*>&
-      const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                 receive_streams) override {
     auto internal_send_peer = test::VideoSendStreamPeer(send_stream);
     // Video streams created, check that pacing factor is correctly configured.
     EXPECT_EQ(expected_pacing_factor_,
@@ -3835,16 +3835,16 @@ class ContentSwitchTest : public test::SendTest {
     RTC_DCHECK(stream_resetter_);
   }
 
-  void OnVideoStreamsCreated(
+  void OnVideoStreamsCreated(VideoSendStream* send_stream,
-      VideoSendStream* send_stream,
+                             const std::vector<VideoReceiveStreamInterface*>&
-      const std::vector<VideoReceiveStream*>& receive_streams) override {
+                                 receive_streams) override {
     MutexLock lock(&mutex_);
     send_stream_ = send_stream;
   }
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStream::Config>* receive_configs,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     RTC_DCHECK_EQ(1, encoder_config->number_of_streams);
     encoder_config->min_transmit_bitrate_bps = 0;
@@ -4017,7 +4017,7 @@ void VideoSendStreamTest::TestTemporalLayers(
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder_factory = encoder_factory_;
       send_config->rtp.payload_name = payload_name_;