From 4e434c313e49e2d6eaa210301dd885a191b2b9c1 Mon Sep 17 00:00:00 2001 From: Florent Castelli Date: Tue, 20 Jun 2023 18:30:03 +0000 Subject: [PATCH] Remove MediaChannel usage from webrtc_video_engine_unittest Bug: webrtc:13931 Change-Id: Ie45a25c6b204b38b749381ef5e9403cf036b8126 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/309660 Reviewed-by: Harald Alvestrand Commit-Queue: Florent Castelli Cr-Commit-Position: refs/heads/main@{#40323} --- media/base/fake_network_interface.h | 4 +- media/base/media_channel.h | 8 + media/base/media_channel_impl.h | 9 - media/engine/webrtc_video_engine_unittest.cc | 1216 +++++++++--------- 4 files changed, 644 insertions(+), 593 deletions(-) diff --git a/media/base/fake_network_interface.h b/media/base/fake_network_interface.h index 993c6e1aff..d0763fe533 100644 --- a/media/base/fake_network_interface.h +++ b/media/base/fake_network_interface.h @@ -43,7 +43,7 @@ class FakeNetworkInterface : public MediaChannelNetworkInterface { recvbuf_size_(-1), dscp_(rtc::DSCP_NO_CHANGE) {} - void SetDestination(MediaChannel* dest) { dest_ = dest; } + void SetDestination(MediaReceiveChannelInterface* dest) { dest_ = dest; } // Conference mode is a mode where instead of simply forwarding the packets, // the transport will send multiple copies of the packet with the specified @@ -207,7 +207,7 @@ class FakeNetworkInterface : public MediaChannelNetworkInterface { } webrtc::TaskQueueBase* thread_; - MediaChannel* dest_; + MediaReceiveChannelInterface* dest_; bool conf_; // The ssrcs used in sending out packets in conference mode. std::vector conf_sent_ssrcs_; diff --git a/media/base/media_channel.h b/media/base/media_channel.h index e18e1d312e..99197020cb 100644 --- a/media/base/media_channel.h +++ b/media/base/media_channel.h @@ -948,6 +948,14 @@ class VideoMediaSendChannelInterface : public MediaSendChannelInterface { // Enable network condition based codec switching. virtual void SetVideoCodecSwitchingEnabled(bool enabled) = 0; virtual bool GetStats(VideoMediaSendInfo* stats) = 0; + // This fills the "bitrate parts" (rtx, video bitrate) of the + // BandwidthEstimationInfo, since that part that isn't possible to get + // through webrtc::Call::GetStats, as they are statistics of the send + // streams. + // TODO(holmer): We should change this so that either BWE graphs doesn't + // need access to bitrates of the streams, or change the (RTC)StatsCollector + // so that it's getting the send stream stats separately by calling + // GetStats(), and merges with BandwidthEstimationInfo by itself. virtual void FillBitrateInfo(BandwidthEstimationInfo* bwe_info) = 0; // Information queries to support SetReceiverFeedbackParameters virtual webrtc::RtcpMode SendCodecRtcpMode() const = 0; diff --git a/media/base/media_channel_impl.h b/media/base/media_channel_impl.h index 33007d07ee..31040e81ae 100644 --- a/media/base/media_channel_impl.h +++ b/media/base/media_channel_impl.h @@ -271,15 +271,6 @@ class VideoMediaChannel : public MediaChannel, webrtc::VideoEncoderFactory::EncoderSelectorInterface* encoder_selector) override {} - // This fills the "bitrate parts" (rtx, video bitrate) of the - // BandwidthEstimationInfo, since that part that isn't possible to get - // through webrtc::Call::GetStats, as they are statistics of the send - // streams. - // TODO(holmer): We should change this so that either BWE graphs doesn't - // need access to bitrates of the streams, or change the (RTC)StatsCollector - // so that it's getting the send stream stats separately by calling - // GetStats(), and merges with BandwidthEstimationInfo by itself. - void FillBitrateInfo(BandwidthEstimationInfo* bwe_info) override = 0; // Gets quality stats for the channel. virtual bool GetSendStats(VideoMediaSendInfo* info) = 0; virtual bool GetReceiveStats(VideoMediaReceiveInfo* info) = 0; diff --git a/media/engine/webrtc_video_engine_unittest.cc b/media/engine/webrtc_video_engine_unittest.cc index 784d6147d6..568cc67377 100644 --- a/media/engine/webrtc_video_engine_unittest.cc +++ b/media/engine/webrtc_video_engine_unittest.cc @@ -1607,31 +1607,32 @@ class WebRtcVideoChannelEncodedFrameCallbackTest : public ::testing::Test { std::make_unique( []() { return std::make_unique(); }, kSdpVideoFormats), - field_trials_), - channel_(absl::WrapUnique(engine_.CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, - call_.get(), - cricket::MediaConfig(), - cricket::VideoOptions(), - webrtc::CryptoOptions(), - video_bitrate_allocator_factory_.get()))) { - send_channel_ = channel_->AsVideoSendChannel(); - receive_channel_ = channel_->AsVideoReceiveChannel(); + field_trials_) { + send_channel_ = engine_.CreateSendChannel( + call_.get(), cricket::MediaConfig(), cricket::VideoOptions(), + webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get()); + receive_channel_ = engine_.CreateReceiveChannel( + call_.get(), cricket::MediaConfig(), cricket::VideoOptions(), + webrtc::CryptoOptions()); - network_interface_.SetDestination(channel_.get()); - channel_->SetInterface(&network_interface_); + network_interface_.SetDestination(receive_channel_.get()); + send_channel_->SetInterface(&network_interface_); + receive_channel_->SetInterface(&network_interface_); cricket::VideoRecvParameters parameters; parameters.codecs = engine_.recv_codecs(); - channel_->SetRecvParameters(parameters); + receive_channel_->SetRecvParameters(parameters); receive_channel_->SetReceive(true); } ~WebRtcVideoChannelEncodedFrameCallbackTest() override { - channel_->SetInterface(nullptr); + send_channel_->SetInterface(nullptr); + receive_channel_->SetInterface(nullptr); + send_channel_.reset(); + receive_channel_.reset(); } void DeliverKeyFrame(uint32_t ssrc) { - channel_->OnPacketReceived(BuildVp8KeyFrame(ssrc, 96)); + receive_channel_->OnPacketReceived(BuildVp8KeyFrame(ssrc, 96)); } void DeliverKeyFrameAndWait(uint32_t ssrc) { @@ -1650,9 +1651,8 @@ class WebRtcVideoChannelEncodedFrameCallbackTest : public ::testing::Test { std::unique_ptr video_bitrate_allocator_factory_; WebRtcVideoEngine engine_; - std::unique_ptr channel_; - VideoMediaSendChannelInterface* send_channel_; - VideoMediaReceiveChannelInterface* receive_channel_; + std::unique_ptr send_channel_; + std::unique_ptr receive_channel_; cricket::FakeNetworkInterface network_interface_; cricket::FakeVideoRenderer renderer_; }; @@ -1665,11 +1665,11 @@ TEST_F(WebRtcVideoChannelEncodedFrameCallbackTest, SetEncodedFrameBufferFunction_DefaultStream) { testing::MockFunction callback; EXPECT_CALL(callback, Call); - EXPECT_TRUE(channel_->AddDefaultRecvStreamForTesting( + EXPECT_TRUE(receive_channel_->AddDefaultRecvStreamForTesting( cricket::StreamParams::CreateLegacy(kSsrc))); - channel_->SetRecordableEncodedFrameCallback(/*ssrc=*/0, - callback.AsStdFunction()); - EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_)); + receive_channel_->SetRecordableEncodedFrameCallback(/*ssrc=*/0, + callback.AsStdFunction()); + EXPECT_TRUE(receive_channel_->SetSink(kSsrc, &renderer_)); DeliverKeyFrame(kSsrc); time_controller_.AdvanceTime(kFrameDuration); EXPECT_EQ(renderer_.num_rendered_frames(), 1); @@ -1680,10 +1680,11 @@ TEST_F(WebRtcVideoChannelEncodedFrameCallbackTest, SetEncodedFrameBufferFunction_MatchSsrcWithDefaultStream) { testing::MockFunction callback; EXPECT_CALL(callback, Call); - EXPECT_TRUE(channel_->AddDefaultRecvStreamForTesting( + EXPECT_TRUE(receive_channel_->AddDefaultRecvStreamForTesting( cricket::StreamParams::CreateLegacy(kSsrc))); - EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_)); - channel_->SetRecordableEncodedFrameCallback(kSsrc, callback.AsStdFunction()); + EXPECT_TRUE(receive_channel_->SetSink(kSsrc, &renderer_)); + receive_channel_->SetRecordableEncodedFrameCallback(kSsrc, + callback.AsStdFunction()); DeliverKeyFrame(kSsrc); time_controller_.AdvanceTime(kFrameDuration); EXPECT_EQ(renderer_.num_rendered_frames(), 1); @@ -1694,10 +1695,11 @@ TEST_F(WebRtcVideoChannelEncodedFrameCallbackTest, SetEncodedFrameBufferFunction_MatchSsrc) { testing::MockFunction callback; EXPECT_CALL(callback, Call); - EXPECT_TRUE( - channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc))); - EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_)); - channel_->SetRecordableEncodedFrameCallback(kSsrc, callback.AsStdFunction()); + EXPECT_TRUE(receive_channel_->AddRecvStream( + cricket::StreamParams::CreateLegacy(kSsrc))); + EXPECT_TRUE(receive_channel_->SetSink(kSsrc, &renderer_)); + receive_channel_->SetRecordableEncodedFrameCallback(kSsrc, + callback.AsStdFunction()); DeliverKeyFrame(kSsrc); time_controller_.AdvanceTime(kFrameDuration); EXPECT_EQ(renderer_.num_rendered_frames(), 1); @@ -1709,10 +1711,11 @@ TEST_F(WebRtcVideoChannelEncodedFrameCallbackTest, testing::StrictMock< testing::MockFunction> callback; - EXPECT_TRUE( - channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc + 1))); - EXPECT_TRUE(channel_->SetSink(kSsrc + 1, &renderer_)); - channel_->SetRecordableEncodedFrameCallback(kSsrc, callback.AsStdFunction()); + EXPECT_TRUE(receive_channel_->AddRecvStream( + cricket::StreamParams::CreateLegacy(kSsrc + 1))); + EXPECT_TRUE(receive_channel_->SetSink(kSsrc + 1, &renderer_)); + receive_channel_->SetRecordableEncodedFrameCallback(kSsrc, + callback.AsStdFunction()); DeliverKeyFrame(kSsrc); // Expected to not cause function to fire. DeliverKeyFrameAndWait(kSsrc + 1); receive_channel_->RemoveRecvStream(kSsrc + 1); @@ -1723,11 +1726,12 @@ TEST_F(WebRtcVideoChannelEncodedFrameCallbackTest, testing::StrictMock< testing::MockFunction> callback; - EXPECT_TRUE(channel_->AddDefaultRecvStreamForTesting( + EXPECT_TRUE(receive_channel_->AddDefaultRecvStreamForTesting( cricket::StreamParams::CreateLegacy(kSsrc + 1))); - EXPECT_TRUE(channel_->SetSink(kSsrc + 1, &renderer_)); - channel_->SetRecordableEncodedFrameCallback(kSsrc, callback.AsStdFunction()); - channel_->SetDefaultSink(&renderer_); + EXPECT_TRUE(receive_channel_->SetSink(kSsrc + 1, &renderer_)); + receive_channel_->SetRecordableEncodedFrameCallback(kSsrc, + callback.AsStdFunction()); + receive_channel_->SetDefaultSink(&renderer_); DeliverKeyFrame(kSsrc); // Expected to not cause function to fire. DeliverKeyFrameAndWait(kSsrc + 1); receive_channel_->RemoveRecvStream(kSsrc + 1); @@ -1736,11 +1740,11 @@ TEST_F(WebRtcVideoChannelEncodedFrameCallbackTest, TEST_F(WebRtcVideoChannelEncodedFrameCallbackTest, DoesNotDecodeWhenDisabled) { testing::MockFunction callback; EXPECT_CALL(callback, Call); - EXPECT_TRUE(channel_->AddDefaultRecvStreamForTesting( + EXPECT_TRUE(receive_channel_->AddDefaultRecvStreamForTesting( cricket::StreamParams::CreateLegacy(kSsrc))); - channel_->SetRecordableEncodedFrameCallback(/*ssrc=*/0, - callback.AsStdFunction()); - EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_)); + receive_channel_->SetRecordableEncodedFrameCallback(/*ssrc=*/0, + callback.AsStdFunction()); + EXPECT_TRUE(receive_channel_->SetSink(kSsrc, &renderer_)); receive_channel_->SetReceive(false); DeliverKeyFrame(kSsrc); time_controller_.AdvanceTime(kFrameDuration); @@ -1791,34 +1795,33 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test { // needs to be disabled, otherwise, tests which check the size of received // frames become flaky. media_config.video.enable_cpu_adaptation = false; - channel_.reset(engine_.CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, call_.get(), media_config, - cricket::VideoOptions(), webrtc::CryptoOptions(), - video_bitrate_allocator_factory_.get())); - send_channel_ = channel_->AsVideoSendChannel(); - receive_channel_ = channel_->AsVideoReceiveChannel(); + send_channel_ = engine_.CreateSendChannel( + call_.get(), media_config, cricket::VideoOptions(), + webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get()); + receive_channel_ = engine_.CreateReceiveChannel(call_.get(), media_config, + cricket::VideoOptions(), + webrtc::CryptoOptions()); send_channel_->OnReadyToSend(true); receive_channel_->SetReceive(true); - EXPECT_TRUE(channel_.get() != NULL); - network_interface_.SetDestination(channel_.get()); - channel_->SetInterface(&network_interface_); + network_interface_.SetDestination(receive_channel_.get()); + send_channel_->SetInterface(&network_interface_); + receive_channel_->SetInterface(&network_interface_); cricket::VideoRecvParameters parameters; parameters.codecs = engine_.send_codecs(); - channel_->SetRecvParameters(parameters); + receive_channel_->SetRecvParameters(parameters); EXPECT_TRUE(send_channel_->AddSendStream(DefaultSendStreamParams())); frame_forwarder_ = std::make_unique(); frame_source_ = std::make_unique( 640, 480, rtc::kNumMicrosecsPerSec / kFramerate); - EXPECT_TRUE(channel_->SetVideoSend(kSsrc, nullptr, frame_forwarder_.get())); + EXPECT_TRUE( + send_channel_->SetVideoSend(kSsrc, nullptr, frame_forwarder_.get())); } // Returns pointer to implementation of the send channel. WebRtcVideoSendChannel* SendImpl() { // Note that this function requires intimate knowledge of how the channel // was created. - return static_cast( - static_cast(channel_.get()) - ->SendImplForTesting()); + return static_cast(send_channel_.get()); } // Utility method to setup an additional stream to send and receive video. @@ -1829,7 +1832,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test { EXPECT_TRUE(receive_channel_->AddRecvStream( cricket::StreamParams::CreateLegacy(kSsrc + 2))); // Make the second renderer available for use by a new stream. - EXPECT_TRUE(channel_->SetSink(kSsrc + 2, &renderer2_)); + EXPECT_TRUE(receive_channel_->SetSink(kSsrc + 2, &renderer2_)); } // Setup an additional stream just to send video. Defer add recv stream. @@ -1838,7 +1841,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test { // SetUp() already added kSsrc make sure duplicate SSRCs cant be added. EXPECT_TRUE(receive_channel_->AddRecvStream( cricket::StreamParams::CreateLegacy(kSsrc))); - EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_)); + EXPECT_TRUE(receive_channel_->SetSink(kSsrc, &renderer_)); EXPECT_FALSE(send_channel_->AddSendStream( cricket::StreamParams::CreateLegacy(kSsrc))); EXPECT_TRUE(send_channel_->AddSendStream( @@ -1847,13 +1850,15 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test { // Setup the receive and renderer for second stream after send. frame_forwarder_2_ = std::make_unique(); - EXPECT_TRUE( - channel_->SetVideoSend(kSsrc + 2, nullptr, frame_forwarder_2_.get())); + EXPECT_TRUE(send_channel_->SetVideoSend(kSsrc + 2, nullptr, + frame_forwarder_2_.get())); } void TearDown() override { - channel_->SetInterface(nullptr); - channel_.reset(); + send_channel_->SetInterface(nullptr); + receive_channel_->SetInterface(nullptr); + send_channel_.reset(); + receive_channel_.reset(); } void ResetTest() { @@ -1872,14 +1877,14 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test { if (success) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(codec); - success = channel_->SetSendParameters(parameters); + success = send_channel_->SetSendParameters(parameters); } if (success) { success = SetSend(sending); } return success; } - bool SetSend(bool send) { return channel_->SetSend(send); } + bool SetSend(bool send) { return send_channel_->SetSend(send); } void SendFrame() { if (frame_forwarder_2_) { frame_forwarder_2_->IncomingCapturedFrame(frame_source_->GetFrame()); @@ -1914,7 +1919,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test { void SendAndReceive(const cricket::VideoCodec& codec) { EXPECT_TRUE(SetOneCodec(codec)); EXPECT_TRUE(SetSend(true)); - channel_->SetDefaultSink(&renderer_); + receive_channel_->SetDefaultSink(&renderer_); EXPECT_EQ(0, renderer_.num_rendered_frames()); SendFrame(); EXPECT_FRAME(1, kVideoWidth, kVideoHeight); @@ -1926,7 +1931,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test { int fps) { EXPECT_TRUE(SetOneCodec(codec)); EXPECT_TRUE(SetSend(true)); - channel_->SetDefaultSink(&renderer_); + receive_channel_->SetDefaultSink(&renderer_); EXPECT_EQ(0, renderer_.num_rendered_frames()); for (int i = 0; i < duration_sec; ++i) { for (int frame = 1; frame <= fps; ++frame) { @@ -1939,13 +1944,13 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test { cricket::VideoSenderInfo GetSenderStats(size_t i) { VideoMediaSendInfo send_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); return send_info.senders[i]; } cricket::VideoReceiverInfo GetReceiverStats(size_t i) { cricket::VideoMediaReceiveInfo info; - EXPECT_TRUE(channel_->GetReceiveStats(&info)); + EXPECT_TRUE(receive_channel_->GetStats(&info)); return info.receivers[i]; } @@ -1993,9 +1998,8 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test { std::unique_ptr frame_forwarder_; std::unique_ptr frame_forwarder_2_; - std::unique_ptr channel_; - VideoMediaSendChannelInterface* send_channel_; - VideoMediaReceiveChannelInterface* receive_channel_; + std::unique_ptr send_channel_; + std::unique_ptr receive_channel_; cricket::FakeNetworkInterface network_interface_; cricket::FakeVideoRenderer renderer_; @@ -2006,7 +2010,8 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test { // Test that SetSend works. TEST_F(WebRtcVideoChannelBaseTest, SetSend) { EXPECT_FALSE(SendImpl()->sending()); - EXPECT_TRUE(channel_->SetVideoSend(kSsrc, nullptr, frame_forwarder_.get())); + EXPECT_TRUE( + send_channel_->SetVideoSend(kSsrc, nullptr, frame_forwarder_.get())); EXPECT_TRUE(SetOneCodec(DefaultCodec())); EXPECT_FALSE(SendImpl()->sending()); EXPECT_TRUE(SetSend(true)); @@ -2041,8 +2046,8 @@ TEST_F(WebRtcVideoChannelBaseTest, GetStats) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); ASSERT_EQ(1U, send_info.senders.size()); // TODO(whyuan): bytes_sent and bytes_received are different. Are both @@ -2101,14 +2106,14 @@ TEST_F(WebRtcVideoChannelBaseTest, GetStatsMultipleRecvStreams) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(DefaultCodec()); parameters.conference_mode = true; - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); EXPECT_TRUE(SetSend(true)); EXPECT_TRUE( receive_channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); EXPECT_TRUE( receive_channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); - EXPECT_TRUE(channel_->SetSink(1, &renderer1)); - EXPECT_TRUE(channel_->SetSink(2, &renderer2)); + EXPECT_TRUE(receive_channel_->SetSink(1, &renderer1)); + EXPECT_TRUE(receive_channel_->SetSink(2, &renderer2)); EXPECT_EQ(0, renderer1.num_rendered_frames()); EXPECT_EQ(0, renderer2.num_rendered_frames()); std::vector ssrcs; @@ -2119,12 +2124,12 @@ TEST_F(WebRtcVideoChannelBaseTest, GetStatsMultipleRecvStreams) { EXPECT_FRAME_ON_RENDERER(renderer1, 1, kVideoWidth, kVideoHeight); EXPECT_FRAME_ON_RENDERER(renderer2, 1, kVideoWidth, kVideoHeight); - EXPECT_TRUE(channel_->SetSend(false)); + EXPECT_TRUE(send_channel_->SetSend(false)); cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); ASSERT_EQ(1U, send_info.senders.size()); // TODO(whyuan): bytes_sent and bytes_received are different. Are both @@ -2155,10 +2160,10 @@ TEST_F(WebRtcVideoChannelBaseTest, GetStatsMultipleSendStreams) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(DefaultCodec()); parameters.conference_mode = true; - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); EXPECT_TRUE(receive_channel_->AddRecvStream( cricket::StreamParams::CreateLegacy(kSsrc))); - EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_)); + EXPECT_TRUE(receive_channel_->SetSink(kSsrc, &renderer_)); EXPECT_TRUE(SetSend(true)); SendFrame(); EXPECT_GT(NumRtpPackets(), 0); @@ -2173,17 +2178,17 @@ TEST_F(WebRtcVideoChannelBaseTest, GetStatsMultipleSendStreams) { rtc::kNumMicrosecsPerSec / 5); EXPECT_TRUE( send_channel_->AddSendStream(cricket::StreamParams::CreateLegacy(5678))); - EXPECT_TRUE(channel_->SetVideoSend(5678, nullptr, &frame_forwarder)); + EXPECT_TRUE(send_channel_->SetVideoSend(5678, nullptr, &frame_forwarder)); EXPECT_TRUE(receive_channel_->AddRecvStream( cricket::StreamParams::CreateLegacy(5678))); - EXPECT_TRUE(channel_->SetSink(5678, &renderer2)); + EXPECT_TRUE(receive_channel_->SetSink(5678, &renderer2)); frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame()); time_controller_.AdvanceTime(kFrameDuration); EXPECT_FRAME_ON_RENDERER(renderer2, 1, kTestWidth, kTestHeight); // Get stats, and make sure they are correct for two senders cricket::VideoMediaSendInfo send_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); ASSERT_EQ(2U, send_info.senders.size()); @@ -2198,7 +2203,7 @@ TEST_F(WebRtcVideoChannelBaseTest, GetStatsMultipleSendStreams) { EXPECT_EQ(kTestWidth, send_info.senders[1].send_frame_width); EXPECT_EQ(kTestHeight, send_info.senders[1].send_frame_height); // The capturer must be unregistered here as it runs out of it's scope next. - channel_->SetVideoSend(5678, nullptr, nullptr); + send_channel_->SetVideoSend(5678, nullptr, nullptr); } // Test that we can set the bandwidth. @@ -2206,9 +2211,9 @@ TEST_F(WebRtcVideoChannelBaseTest, SetSendBandwidth) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(DefaultCodec()); parameters.max_bandwidth_bps = -1; // <= 0 means unlimited. - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); parameters.max_bandwidth_bps = 128 * 1024; - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); } // Test that we can set the SSRC for the default send source. @@ -2237,7 +2242,8 @@ TEST_F(WebRtcVideoChannelBaseTest, SetSendSsrcAfterSetCodecs) { EXPECT_TRUE(SetDefaultCodec()); EXPECT_TRUE( send_channel_->AddSendStream(cricket::StreamParams::CreateLegacy(999))); - EXPECT_TRUE(channel_->SetVideoSend(999u, nullptr, frame_forwarder_.get())); + EXPECT_TRUE( + send_channel_->SetVideoSend(999u, nullptr, frame_forwarder_.get())); EXPECT_TRUE(SetSend(true)); EXPECT_TRUE(WaitAndSendFrame(0)); EXPECT_GT(NumRtpPackets(), 0); @@ -2258,12 +2264,12 @@ TEST_F(WebRtcVideoChannelBaseTest, SetSendSsrcAfterSetCodecs) { TEST_F(WebRtcVideoChannelBaseTest, SetSink) { RtpPacketReceived packet; packet.SetSsrc(kSsrc); - channel_->SetDefaultSink(NULL); + receive_channel_->SetDefaultSink(NULL); EXPECT_TRUE(SetDefaultCodec()); EXPECT_TRUE(SetSend(true)); EXPECT_EQ(0, renderer_.num_rendered_frames()); - channel_->SetDefaultSink(&renderer_); - channel_->OnPacketReceived(packet); + receive_channel_->SetDefaultSink(&renderer_); + receive_channel_->OnPacketReceived(packet); SendFrame(); EXPECT_FRAME(1, kVideoWidth, kVideoHeight); } @@ -2272,7 +2278,7 @@ TEST_F(WebRtcVideoChannelBaseTest, SetSink) { TEST_F(WebRtcVideoChannelBaseTest, AddRemoveSendStreams) { EXPECT_TRUE(SetOneCodec(DefaultCodec())); EXPECT_TRUE(SetSend(true)); - channel_->SetDefaultSink(&renderer_); + receive_channel_->SetDefaultSink(&renderer_); SendFrame(); EXPECT_FRAME(1, kVideoWidth, kVideoHeight); EXPECT_GT(NumRtpPackets(), 0); @@ -2287,7 +2293,8 @@ TEST_F(WebRtcVideoChannelBaseTest, AddRemoveSendStreams) { EXPECT_TRUE( send_channel_->AddSendStream(cricket::StreamParams::CreateLegacy(789u))); - EXPECT_TRUE(channel_->SetVideoSend(789u, nullptr, frame_forwarder_.get())); + EXPECT_TRUE( + send_channel_->SetVideoSend(789u, nullptr, frame_forwarder_.get())); EXPECT_EQ(rtp_packets, NumRtpPackets()); // Wait 30ms to guarantee the engine does not drop the frame. EXPECT_TRUE(WaitAndSendFrame(30)); @@ -2305,14 +2312,14 @@ TEST_F(WebRtcVideoChannelBaseTest, SimulateConference) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(DefaultCodec()); parameters.conference_mode = true; - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); EXPECT_TRUE(SetSend(true)); EXPECT_TRUE( receive_channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); EXPECT_TRUE( receive_channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); - EXPECT_TRUE(channel_->SetSink(1, &renderer1)); - EXPECT_TRUE(channel_->SetSink(2, &renderer2)); + EXPECT_TRUE(receive_channel_->SetSink(1, &renderer1)); + EXPECT_TRUE(receive_channel_->SetSink(2, &renderer2)); EXPECT_EQ(0, renderer1.num_rendered_frames()); EXPECT_EQ(0, renderer2.num_rendered_frames()); std::vector ssrcs; @@ -2343,7 +2350,7 @@ TEST_F(WebRtcVideoChannelBaseTest, DISABLED_AddRemoveCapturer) { const int time_between_send_ms = VideoFormat::FpsToInterval(kFramerate); EXPECT_TRUE(SetOneCodec(codec)); EXPECT_TRUE(SetSend(true)); - channel_->SetDefaultSink(&renderer_); + receive_channel_->SetDefaultSink(&renderer_); EXPECT_EQ(0, renderer_.num_rendered_frames()); SendFrame(); EXPECT_FRAME(1, kVideoWidth, kVideoHeight); @@ -2357,11 +2364,11 @@ TEST_F(WebRtcVideoChannelBaseTest, DISABLED_AddRemoveCapturer) { // test which is related to screencast logic. VideoOptions video_options; video_options.is_screencast = true; - channel_->SetVideoSend(kSsrc, &video_options, nullptr); + send_channel_->SetVideoSend(kSsrc, &video_options, nullptr); int captured_frames = 1; for (int iterations = 0; iterations < 2; ++iterations) { - EXPECT_TRUE(channel_->SetVideoSend(kSsrc, nullptr, &frame_forwarder)); + EXPECT_TRUE(send_channel_->SetVideoSend(kSsrc, nullptr, &frame_forwarder)); time_controller_.AdvanceTime(TimeDelta::Millis(time_between_send_ms)); frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame()); @@ -2375,7 +2382,7 @@ TEST_F(WebRtcVideoChannelBaseTest, DISABLED_AddRemoveCapturer) { EXPECT_EQ(360, renderer_.height()); captured_frames = renderer_.num_rendered_frames() + 1; EXPECT_FALSE(renderer_.black_frame()); - EXPECT_TRUE(channel_->SetVideoSend(kSsrc, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(kSsrc, nullptr, nullptr)); // Make sure a black frame was generated. // The black frame should have the resolution of the previous frame to // prevent expensive encoder reconfigurations. @@ -2401,7 +2408,7 @@ TEST_F(WebRtcVideoChannelBaseTest, DISABLED_AddRemoveCapturer) { TEST_F(WebRtcVideoChannelBaseTest, RemoveCapturerWithoutAdd) { EXPECT_TRUE(SetOneCodec(DefaultCodec())); EXPECT_TRUE(SetSend(true)); - channel_->SetDefaultSink(&renderer_); + receive_channel_->SetDefaultSink(&renderer_); EXPECT_EQ(0, renderer_.num_rendered_frames()); SendFrame(); EXPECT_FRAME(1, kVideoWidth, kVideoHeight); @@ -2409,10 +2416,10 @@ TEST_F(WebRtcVideoChannelBaseTest, RemoveCapturerWithoutAdd) { // tightly. time_controller_.AdvanceTime(kFrameDuration); // Remove the capturer. - EXPECT_TRUE(channel_->SetVideoSend(kSsrc, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(kSsrc, nullptr, nullptr)); // No capturer was added, so this SetVideoSend shouldn't do anything. - EXPECT_TRUE(channel_->SetVideoSend(kSsrc, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(kSsrc, nullptr, nullptr)); time_controller_.AdvanceTime(TimeDelta::Millis(300)); // Verify no more frames were sent. EXPECT_EQ(1, renderer_.num_rendered_frames()); @@ -2423,16 +2430,16 @@ TEST_F(WebRtcVideoChannelBaseTest, AddRemoveCapturerMultipleSources) { // Set up the stream associated with the engine. EXPECT_TRUE(receive_channel_->AddRecvStream( cricket::StreamParams::CreateLegacy(kSsrc))); - EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_)); + EXPECT_TRUE(receive_channel_->SetSink(kSsrc, &renderer_)); cricket::VideoFormat capture_format( kVideoWidth, kVideoHeight, cricket::VideoFormat::FpsToInterval(kFramerate), cricket::FOURCC_I420); // Set up additional stream 1. cricket::FakeVideoRenderer renderer1; - EXPECT_FALSE(channel_->SetSink(1, &renderer1)); + EXPECT_FALSE(receive_channel_->SetSink(1, &renderer1)); EXPECT_TRUE( receive_channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); - EXPECT_TRUE(channel_->SetSink(1, &renderer1)); + EXPECT_TRUE(receive_channel_->SetSink(1, &renderer1)); EXPECT_TRUE( send_channel_->AddSendStream(cricket::StreamParams::CreateLegacy(1))); @@ -2442,10 +2449,10 @@ TEST_F(WebRtcVideoChannelBaseTest, AddRemoveCapturerMultipleSources) { // Set up additional stream 2. cricket::FakeVideoRenderer renderer2; - EXPECT_FALSE(channel_->SetSink(2, &renderer2)); + EXPECT_FALSE(receive_channel_->SetSink(2, &renderer2)); EXPECT_TRUE( receive_channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); - EXPECT_TRUE(channel_->SetSink(2, &renderer2)); + EXPECT_TRUE(receive_channel_->SetSink(2, &renderer2)); EXPECT_TRUE( send_channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2))); webrtc::test::FrameForwarder frame_forwarder2; @@ -2455,8 +2462,8 @@ TEST_F(WebRtcVideoChannelBaseTest, AddRemoveCapturerMultipleSources) { // A limitation in the lmi implementation requires that SetVideoSend() is // called after SetOneCodec(). // TODO(hellner): this seems like an unnecessary constraint, fix it. - EXPECT_TRUE(channel_->SetVideoSend(1, nullptr, &frame_forwarder1)); - EXPECT_TRUE(channel_->SetVideoSend(2, nullptr, &frame_forwarder2)); + EXPECT_TRUE(send_channel_->SetVideoSend(1, nullptr, &frame_forwarder1)); + EXPECT_TRUE(send_channel_->SetVideoSend(2, nullptr, &frame_forwarder2)); EXPECT_TRUE(SetSend(true)); // Test capturer associated with engine. const int kTestWidth = 160; @@ -2473,11 +2480,11 @@ TEST_F(WebRtcVideoChannelBaseTest, AddRemoveCapturerMultipleSources) { time_controller_.AdvanceTime(kFrameDuration); EXPECT_FRAME_ON_RENDERER(renderer2, 1, kTestWidth, kTestHeight); // Successfully remove the capturer. - EXPECT_TRUE(channel_->SetVideoSend(kSsrc, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(kSsrc, nullptr, nullptr)); // The capturers must be unregistered here as it runs out of it's scope // next. - EXPECT_TRUE(channel_->SetVideoSend(1, nullptr, nullptr)); - EXPECT_TRUE(channel_->SetVideoSend(2, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(1, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(2, nullptr, nullptr)); } // Tests empty StreamParams is rejected. @@ -2537,7 +2544,7 @@ TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderFallback) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); absl::optional codec = send_channel_->GetSendCodec(); ASSERT_TRUE(codec); @@ -2563,7 +2570,7 @@ TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderSwitchDefaultFallback) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); absl::optional codec = send_channel_->GetSendCodec(); ASSERT_TRUE(codec); @@ -2589,7 +2596,7 @@ TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderSwitchStrictPreference) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(vp9); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); absl::optional codec = send_channel_->GetSendCodec(); ASSERT_TRUE(codec); @@ -2621,8 +2628,8 @@ TEST_F(WebRtcVideoChannelBaseTest, SendCodecIsMovedToFrontInRtpParameters) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); - channel_->SetVideoCodecSwitchingEnabled(true); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + send_channel_->SetVideoCodecSwitchingEnabled(true); auto send_codecs = send_channel_->GetRtpSendParameters(kSsrc).codecs; ASSERT_EQ(send_codecs.size(), 2u); @@ -2655,23 +2662,36 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { #endif fake_call_.reset(new FakeCall(&field_trials_)); - channel_.reset(engine_.CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, fake_call_.get(), GetMediaConfig(), - VideoOptions(), webrtc::CryptoOptions(), - video_bitrate_allocator_factory_.get())); - send_channel_ = channel_->AsVideoSendChannel(); - receive_channel_ = channel_->AsVideoReceiveChannel(); + send_channel_ = engine_.CreateSendChannel( + fake_call_.get(), GetMediaConfig(), VideoOptions(), + webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get()); + receive_channel_ = + engine_.CreateReceiveChannel(fake_call_.get(), GetMediaConfig(), + VideoOptions(), webrtc::CryptoOptions()); + send_channel_->SetSsrcListChangedCallback( + [receive_channel = + receive_channel_.get()](const std::set& choices) { + receive_channel->ChooseReceiverReportSsrc(choices); + }); + send_channel_->SetSendCodecChangedCallback([this]() { + receive_channel_->SetReceiverFeedbackParameters( + send_channel_->SendCodecHasLntf(), send_channel_->SendCodecHasNack(), + send_channel_->SendCodecRtcpMode(), + send_channel_->SendCodecRtxTime()); + }); send_channel_->OnReadyToSend(true); receive_channel_->SetReceive(true); last_ssrc_ = 123; send_parameters_.codecs = engine_.send_codecs(); recv_parameters_.codecs = engine_.recv_codecs(); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); } void TearDown() override { - channel_->SetInterface(nullptr); - channel_ = nullptr; + send_channel_->SetInterface(nullptr); + receive_channel_->SetInterface(nullptr); + send_channel_.reset(); + receive_channel_.reset(); fake_call_ = nullptr; } @@ -2684,9 +2704,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { WebRtcVideoSendChannel* SendImpl() { // Note that this function requires intimate knowledge of how the channel // was created. - return static_cast( - static_cast(channel_.get()) - ->SendImplForTesting()); + return static_cast(send_channel_.get()); } // Casts a shim channel to a webrtc::Transport. Used once. @@ -2763,7 +2781,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps; codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps; codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps; - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); } void ExpectSetBitrateParameters(int min_bitrate_bps, @@ -2789,7 +2807,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { EXPECT_TRUE(send_channel_->AddSendStream( cricket::StreamParams::CreateLegacy(kSsrc))); send_parameters_.extmap_allow_mixed = extmap_allow_mixed; - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); const webrtc::VideoSendStream::Config& config = fake_call_->GetVideoSendStreams()[0]->GetConfig(); EXPECT_EQ(extmap_allow_mixed, config.rtp.extmap_allow_mixed); @@ -2811,7 +2829,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { const int id = 1; cricket::VideoSendParameters parameters = send_parameters_; parameters.extensions.push_back(RtpExtension(ext_uri, id)); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* send_stream = AddSendStream(cricket::StreamParams::CreateLegacy(123)); @@ -2820,17 +2838,17 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id); EXPECT_EQ(ext_uri, send_stream->GetConfig().rtp.extensions[0].uri); // Verify call with same set of extensions returns true. - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); // Verify that existing RTP header extensions can be removed. - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size()); send_stream = fake_call_->GetVideoSendStreams()[0]; EXPECT_TRUE(send_stream->GetConfig().rtp.extensions.empty()); // Verify that adding receive RTP header extensions adds them for existing // streams. - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); send_stream = fake_call_->GetVideoSendStreams()[0]; ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size()); EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id); @@ -2842,14 +2860,15 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { const int id = 1; cricket::VideoRecvParameters parameters = recv_parameters_; parameters.extensions.push_back(RtpExtension(ext_uri, id)); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); AddRecvStream(cricket::StreamParams::CreateLegacy(123)); - EXPECT_THAT(channel_->GetRtpReceiveParameters(123).header_extensions, - ElementsAre(RtpExtension(ext_uri, id))); + EXPECT_THAT( + receive_channel_->GetRtpReceiveParameters(123).header_extensions, + ElementsAre(RtpExtension(ext_uri, id))); // Verify call with same set of extensions returns true. - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for // senders. @@ -2858,14 +2877,15 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { .rtp.extensions.empty()); // Verify that existing RTP header extensions can be removed. - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); - EXPECT_THAT(channel_->GetRtpReceiveParameters(123).header_extensions, - IsEmpty()); + EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); + EXPECT_THAT( + receive_channel_->GetRtpReceiveParameters(123).header_extensions, + IsEmpty()); // Verify that adding receive RTP header extensions adds them for existing // streams. - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); - EXPECT_EQ(channel_->GetRtpReceiveParameters(123).header_extensions, + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_EQ(receive_channel_->GetRtpReceiveParameters(123).header_extensions, parameters.extensions); } @@ -2875,8 +2895,8 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { cricket::VideoSendParameters parameters; parameters.codecs = engine_.send_codecs(); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); - EXPECT_TRUE(channel_->SetSend(true)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSend(true)); // Send side. FakeVideoSendStream* send_stream = @@ -2899,7 +2919,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { expected_id = id; parameters.extensions.push_back(RtpExtension(extension, id++)); } - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* send_stream = AddSendStream(cricket::StreamParams::CreateLegacy(123)); @@ -2925,7 +2945,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { bool enabled) { cricket::VideoOptions options; options.video_noise_reduction = enabled; - EXPECT_TRUE(channel_->SetVideoSend(ssrc, &options, frame_forwarder)); + EXPECT_TRUE(send_channel_->SetVideoSend(ssrc, &options, frame_forwarder)); // Options only take effect on the next frame. frame_forwarder->IncomingCapturedFrame(frame_source_.GetFrame()); @@ -2966,7 +2986,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { int expected_encoder_bitrate) { VideoSendParameters limited_send_params = send_parameters_; limited_send_params.max_bandwidth_bps = global_max; - EXPECT_TRUE(channel_->SetSendParameters(limited_send_params)); + EXPECT_TRUE(send_channel_->SetSendParameters(limited_send_params)); webrtc::RtpParameters parameters = send_channel_->GetRtpSendParameters(last_ssrc_); EXPECT_EQ(1UL, parameters.encodings.size()); @@ -2998,9 +3018,8 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { cricket::FakeFrameSource frame_source_; std::unique_ptr fake_call_; - std::unique_ptr channel_; - VideoMediaSendChannelInterface* send_channel_; - VideoMediaReceiveChannelInterface* receive_channel_; + std::unique_ptr send_channel_; + std::unique_ptr receive_channel_; cricket::VideoSendParameters send_parameters_; cricket::VideoRecvParameters recv_parameters_; uint32_t last_ssrc_; @@ -3023,10 +3042,10 @@ TEST_F(WebRtcVideoChannelTest, SetsSyncGroupFromSyncLabel) { TEST_F(WebRtcVideoChannelTest, RecvStreamWithSimAndRtx) { cricket::VideoSendParameters parameters; parameters.codecs = engine_.send_codecs(); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); - EXPECT_TRUE(channel_->SetSend(true)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSend(true)); parameters.conference_mode = true; - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); // Send side. const std::vector ssrcs = MAKE_VECTOR(kSsrcs1); @@ -3160,7 +3179,7 @@ TEST_F(WebRtcVideoChannelTest, IdenticalSendExtensionsDoesntRecreateStream) { send_parameters_.extensions.push_back( RtpExtension(RtpExtension::kVideoRotationUri, kVideoRotationId)); - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); FakeVideoSendStream* send_stream = AddSendStream(cricket::StreamParams::CreateLegacy(123)); @@ -3170,13 +3189,13 @@ TEST_F(WebRtcVideoChannelTest, IdenticalSendExtensionsDoesntRecreateStream) { // Setting the same extensions (even if in different order) shouldn't // reallocate the stream. absl::c_reverse(send_parameters_.extensions); - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); // Setting different extensions should recreate the stream. send_parameters_.extensions.resize(1); - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams()); } @@ -3190,7 +3209,7 @@ TEST_F(WebRtcVideoChannelTest, RtpExtension(kUnsupportedExtensionName, kUnsupportedId)); send_parameters_.extensions.push_back( RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId)); - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); FakeVideoSendStream* send_stream = AddSendStream(cricket::StreamParams::CreateLegacy(123)); @@ -3210,7 +3229,7 @@ TEST_F(WebRtcVideoChannelTest, RtpExtension(kUnsupportedExtensionName, kUnsupportedId)); recv_parameters_.extensions.push_back( RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId)); - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); AddRecvStream(cricket::StreamParams::CreateLegacy(123)); // Only timestamp offset extension is set to receive stream, @@ -3228,7 +3247,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendRtpHeaderExtensionsRejectsIncorrectIds) { for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) { send_parameters_.extensions.push_back( RtpExtension(RtpExtension::kTimestampOffsetUri, kIncorrectIds[i])); - EXPECT_FALSE(channel_->SetSendParameters(send_parameters_)) + EXPECT_FALSE(send_channel_->SetSendParameters(send_parameters_)) << "Bad extension id '" << kIncorrectIds[i] << "' accepted."; } } @@ -3238,7 +3257,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvRtpHeaderExtensionsRejectsIncorrectIds) { for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) { recv_parameters_.extensions.push_back( RtpExtension(RtpExtension::kTimestampOffsetUri, kIncorrectIds[i])); - EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_)) + EXPECT_FALSE(receive_channel_->SetRecvParameters(recv_parameters_)) << "Bad extension id '" << kIncorrectIds[i] << "' accepted."; } } @@ -3249,14 +3268,14 @@ TEST_F(WebRtcVideoChannelTest, SetSendRtpHeaderExtensionsRejectsDuplicateIds) { RtpExtension(RtpExtension::kTimestampOffsetUri, id)); send_parameters_.extensions.push_back( RtpExtension(RtpExtension::kAbsSendTimeUri, id)); - EXPECT_FALSE(channel_->SetSendParameters(send_parameters_)); + EXPECT_FALSE(send_channel_->SetSendParameters(send_parameters_)); // Duplicate entries are also not supported. send_parameters_.extensions.clear(); send_parameters_.extensions.push_back( RtpExtension(RtpExtension::kTimestampOffsetUri, id)); send_parameters_.extensions.push_back(send_parameters_.extensions.back()); - EXPECT_FALSE(channel_->SetSendParameters(send_parameters_)); + EXPECT_FALSE(send_channel_->SetSendParameters(send_parameters_)); } TEST_F(WebRtcVideoChannelTest, SetRecvRtpHeaderExtensionsRejectsDuplicateIds) { @@ -3265,21 +3284,21 @@ TEST_F(WebRtcVideoChannelTest, SetRecvRtpHeaderExtensionsRejectsDuplicateIds) { RtpExtension(RtpExtension::kTimestampOffsetUri, id)); recv_parameters_.extensions.push_back( RtpExtension(RtpExtension::kAbsSendTimeUri, id)); - EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_)); + EXPECT_FALSE(receive_channel_->SetRecvParameters(recv_parameters_)); // Duplicate entries are also not supported. recv_parameters_.extensions.clear(); recv_parameters_.extensions.push_back( RtpExtension(RtpExtension::kTimestampOffsetUri, id)); recv_parameters_.extensions.push_back(recv_parameters_.extensions.back()); - EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_)); + EXPECT_FALSE(receive_channel_->SetRecvParameters(recv_parameters_)); } TEST_F(WebRtcVideoChannelTest, OnPacketReceivedIdentifiesExtensions) { cricket::VideoRecvParameters parameters = recv_parameters_; parameters.extensions.push_back( RtpExtension(RtpExtension::kVideoRotationUri, /*id=*/1)); - ASSERT_TRUE(channel_->SetRecvParameters(parameters)); + ASSERT_TRUE(receive_channel_->SetRecvParameters(parameters)); webrtc::RtpHeaderExtensionMap extension_map(parameters.extensions); RtpPacketReceived reference_packet(&extension_map); reference_packet.SetExtension( @@ -3329,8 +3348,8 @@ TEST_F(WebRtcVideoChannelTest, LossNotificationCanBeEnabledAndDisabled) { { cricket::VideoSendParameters parameters; parameters.codecs = engine_.send_codecs(); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); - EXPECT_TRUE(channel_->SetSend(true)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSend(true)); } // Start with LNTF enabled. @@ -3345,7 +3364,7 @@ TEST_F(WebRtcVideoChannelTest, LossNotificationCanBeEnabledAndDisabled) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8"))); EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); recv_stream = fake_call_->GetVideoReceiveStreams()[0]; EXPECT_FALSE(recv_stream->GetConfig().rtp.lntf.enabled); send_stream = fake_call_->GetVideoSendStreams()[0]; @@ -3353,7 +3372,7 @@ TEST_F(WebRtcVideoChannelTest, LossNotificationCanBeEnabledAndDisabled) { // Setting the default codecs again, including VP8, turns LNTF back on. parameters.codecs = engine_.send_codecs(); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); recv_stream = fake_call_->GetVideoReceiveStreams()[0]; EXPECT_TRUE(recv_stream->GetConfig().rtp.lntf.enabled); send_stream = fake_call_->GetVideoSendStreams()[0]; @@ -3366,8 +3385,8 @@ TEST_F(WebRtcVideoChannelTest, NackIsEnabledByDefault) { cricket::VideoSendParameters parameters; parameters.codecs = engine_.send_codecs(); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); - EXPECT_TRUE(channel_->SetSend(true)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSend(true)); // Send side. FakeVideoSendStream* send_stream = @@ -3395,7 +3414,7 @@ TEST_F(WebRtcVideoChannelTest, NackCanBeEnabledAndDisabled) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8"))); EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); recv_stream = fake_call_->GetVideoReceiveStreams()[0]; EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms); send_stream = fake_call_->GetVideoSendStreams()[0]; @@ -3404,7 +3423,7 @@ TEST_F(WebRtcVideoChannelTest, NackCanBeEnabledAndDisabled) { // Verify that NACK is turned on when setting default codecs since the // default codecs have NACK enabled. parameters.codecs = engine_.send_codecs(); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); recv_stream = fake_call_->GetVideoReceiveStreams()[0]; EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0); send_stream = fake_call_->GetVideoSendStreams()[0]; @@ -3419,8 +3438,8 @@ TEST_F(WebRtcVideoChannelTest, NackCanBeEnabledAndDisabled) { TEST_F(WebRtcVideoChannelTest, ReconfiguresEncodersWhenNotSending) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); - channel_->SetSend(false); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + send_channel_->SetSend(false); FakeVideoSendStream* stream = AddSendStream(); @@ -3433,7 +3452,8 @@ TEST_F(WebRtcVideoChannelTest, ReconfiguresEncodersWhenNotSending) { cricket::FakeFrameSource frame_source(1280, 720, rtc::kNumMicrosecsPerSec / 30); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame()); // Frame entered, should be reconfigured to new dimensions. @@ -3441,7 +3461,7 @@ TEST_F(WebRtcVideoChannelTest, ReconfiguresEncodersWhenNotSending) { EXPECT_EQ(rtc::checked_cast(1280), streams[0].width); EXPECT_EQ(rtc::checked_cast(720), streams[0].height); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, UsesCorrectSettingsForScreencast) { @@ -3449,7 +3469,7 @@ TEST_F(WebRtcVideoChannelTest, UsesCorrectSettingsForScreencast) { cricket::VideoCodec codec = GetEngineCodec("VP8"); cricket::VideoSendParameters parameters; parameters.codecs.push_back(codec); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); AddSendStream(); webrtc::test::FrameForwarder frame_forwarder; @@ -3457,10 +3477,10 @@ TEST_F(WebRtcVideoChannelTest, UsesCorrectSettingsForScreencast) { rtc::kNumMicrosecsPerSec / 30); VideoOptions min_bitrate_options; min_bitrate_options.screencast_min_bitrate_kbps = kScreenshareMinBitrateKbps; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &min_bitrate_options, - &frame_forwarder)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, &min_bitrate_options, + &frame_forwarder)); - EXPECT_TRUE(channel_->SetSend(true)); + EXPECT_TRUE(send_channel_->SetSend(true)); frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame()); ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size()); @@ -3479,12 +3499,12 @@ TEST_F(WebRtcVideoChannelTest, UsesCorrectSettingsForScreencast) { EXPECT_EQ(0, encoder_config.min_transmit_bitrate_bps) << "Non-screenshare shouldn't use min-transmit bitrate."; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames()); VideoOptions screencast_options; screencast_options.is_screencast = true; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &screencast_options, - &frame_forwarder)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, &screencast_options, + &frame_forwarder)); frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame()); // Send stream recreated after option change. ASSERT_EQ(2, fake_call_->GetNumCreatedSendStreams()); @@ -3502,14 +3522,14 @@ TEST_F(WebRtcVideoChannelTest, UsesCorrectSettingsForScreencast) { EXPECT_EQ(rtc::checked_cast(1280), streams.front().width); EXPECT_EQ(rtc::checked_cast(720), streams.front().height); EXPECT_FALSE(streams[0].num_temporal_layers.has_value()); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, ConferenceModeScreencastConfiguresTemporalLayer) { static const int kConferenceScreencastTemporalBitrateBps = 200 * 1000; send_parameters_.conference_mode = true; - channel_->SetSendParameters(send_parameters_); + send_channel_->SetSendParameters(send_parameters_); AddSendStream(); VideoOptions options; @@ -3517,8 +3537,9 @@ TEST_F(WebRtcVideoChannelTest, webrtc::test::FrameForwarder frame_forwarder; cricket::FakeFrameSource frame_source(1280, 720, rtc::kNumMicrosecsPerSec / 30); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); - EXPECT_TRUE(channel_->SetSend(true)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + EXPECT_TRUE(send_channel_->SetSend(true)); frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame()); ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size()); @@ -3538,7 +3559,7 @@ TEST_F(WebRtcVideoChannelTest, EXPECT_EQ(kConferenceScreencastTemporalBitrateBps, streams[0].target_bitrate_bps); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, SuspendBelowMinBitrateDisabledByDefault) { @@ -3550,29 +3571,27 @@ TEST_F(WebRtcVideoChannelTest, SetMediaConfigSuspendBelowMinBitrate) { MediaConfig media_config = GetMediaConfig(); media_config.video.suspend_below_min_bitrate = true; - channel_.reset(engine_.CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, fake_call_.get(), media_config, - VideoOptions(), webrtc::CryptoOptions(), - video_bitrate_allocator_factory_.get())); - send_channel_ = channel_->AsVideoSendChannel(); - receive_channel_ = channel_->AsVideoReceiveChannel(); + send_channel_ = engine_.CreateSendChannel( + fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions(), + video_bitrate_allocator_factory_.get()); + receive_channel_ = engine_.CreateReceiveChannel( + fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions()); send_channel_->OnReadyToSend(true); - channel_->SetSendParameters(send_parameters_); + send_channel_->SetSendParameters(send_parameters_); FakeVideoSendStream* stream = AddSendStream(); EXPECT_TRUE(stream->GetConfig().suspend_below_min_bitrate); media_config.video.suspend_below_min_bitrate = false; - channel_.reset(engine_.CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, fake_call_.get(), media_config, - VideoOptions(), webrtc::CryptoOptions(), - video_bitrate_allocator_factory_.get())); - send_channel_ = channel_->AsVideoSendChannel(); - receive_channel_ = channel_->AsVideoReceiveChannel(); + send_channel_ = engine_.CreateSendChannel( + fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions(), + video_bitrate_allocator_factory_.get()); + receive_channel_ = engine_.CreateReceiveChannel( + fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions()); send_channel_->OnReadyToSend(true); - channel_->SetSendParameters(send_parameters_); + send_channel_->SetSendParameters(send_parameters_); stream = AddSendStream(); EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate); @@ -3588,7 +3607,7 @@ TEST_F(WebRtcVideoChannelTest, Vp8DenoisingEnabledByDefault) { TEST_F(WebRtcVideoChannelTest, VerifyVp8SpecificSettings) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); // Single-stream settings should apply with RTX as well (verifies that we // check number of regular SSRCs and not StreamParams::ssrcs which contains @@ -3596,8 +3615,9 @@ TEST_F(WebRtcVideoChannelTest, VerifyVp8SpecificSettings) { FakeVideoSendStream* stream = SetUpSimulcast(false, /*with_rtx=*/true); webrtc::test::FrameForwarder frame_forwarder; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); @@ -3620,10 +3640,11 @@ TEST_F(WebRtcVideoChannelTest, VerifyVp8SpecificSettings) { EXPECT_TRUE(vp8_settings.automaticResizeOn); EXPECT_TRUE(stream->GetEncoderConfig().frame_drop_enabled); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); stream = SetUpSimulcast(true, /*with_rtx=*/false); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); EXPECT_EQ(3u, stream->GetVideoStreams().size()); @@ -3635,7 +3656,8 @@ TEST_F(WebRtcVideoChannelTest, VerifyVp8SpecificSettings) { // In screen-share mode, denoising is forced off. VideoOptions options; options.is_screencast = true; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); stream = SetDenoisingOption(last_ssrc_, &frame_forwarder, false); @@ -3653,7 +3675,7 @@ TEST_F(WebRtcVideoChannelTest, VerifyVp8SpecificSettings) { EXPECT_FALSE(vp8_settings.automaticResizeOn); EXPECT_TRUE(stream->GetEncoderConfig().frame_drop_enabled); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } // Test that setting the same options doesn't result in the encoder being @@ -3665,25 +3687,29 @@ TEST_F(WebRtcVideoChannelTest, SetIdenticalOptionsDoesntReconfigureEncoder) { AddSendStream(); cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); // Expect 1 reconfigurations at this point from the initial configuration. EXPECT_EQ(1, send_stream->num_encoder_reconfigurations()); // Set the options one more time and expect no additional reconfigurations. - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); EXPECT_EQ(1, send_stream->num_encoder_reconfigurations()); // Change `options` and expect 2 reconfigurations. options.video_noise_reduction = true; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); EXPECT_EQ(2, send_stream->num_encoder_reconfigurations()); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } class Vp9SettingsTest : public WebRtcVideoChannelTest { @@ -3698,8 +3724,8 @@ class Vp9SettingsTest : public WebRtcVideoChannelTest { protected: void TearDown() override { // Remove references to encoder_factory_ since this will be destroyed - // before channel_ and engine_. - ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); + // before send_channel_ and engine_. + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); } }; @@ -3710,13 +3736,14 @@ TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(false, /*with_rtx=*/false); webrtc::test::FrameForwarder frame_forwarder; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); @@ -3779,7 +3806,8 @@ TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) { // In screen-share mode, denoising is forced off. VideoOptions options; options.is_screencast = true; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); stream = SetDenoisingOption(last_ssrc_, &frame_forwarder, false); @@ -3797,13 +3825,13 @@ TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) { EXPECT_TRUE(stream->GetEncoderConfig().frame_drop_enabled); EXPECT_FALSE(vp9_settings.automaticResizeOn); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(Vp9SettingsTest, MultipleSsrcsEnablesSvc) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); std::vector ssrcs = MAKE_VECTOR(kSsrcs3); @@ -3813,8 +3841,8 @@ TEST_F(Vp9SettingsTest, MultipleSsrcsEnablesSvc) { webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); webrtc::test::FrameForwarder frame_forwarder; - EXPECT_TRUE(channel_->SetVideoSend(ssrcs[0], nullptr, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE(send_channel_->SetVideoSend(ssrcs[0], nullptr, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); @@ -3826,13 +3854,13 @@ TEST_F(Vp9SettingsTest, MultipleSsrcsEnablesSvc) { EXPECT_EQ(vp9_settings.numberOfSpatialLayers, kNumSpatialLayers); EXPECT_EQ(vp9_settings.numberOfTemporalLayers, kNumTemporalLayers); - EXPECT_TRUE(channel_->SetVideoSend(ssrcs[0], nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(ssrcs[0], nullptr, nullptr)); } TEST_F(Vp9SettingsTest, SvcModeCreatesSingleRtpStream) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); std::vector ssrcs = MAKE_VECTOR(kSsrcs3); @@ -3845,8 +3873,8 @@ TEST_F(Vp9SettingsTest, SvcModeCreatesSingleRtpStream) { EXPECT_EQ(1u, config.rtp.ssrcs.size()); webrtc::test::FrameForwarder frame_forwarder; - EXPECT_TRUE(channel_->SetVideoSend(ssrcs[0], nullptr, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE(send_channel_->SetVideoSend(ssrcs[0], nullptr, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); @@ -3856,13 +3884,13 @@ TEST_F(Vp9SettingsTest, SvcModeCreatesSingleRtpStream) { const size_t kNumSpatialLayers = ssrcs.size(); EXPECT_EQ(vp9_settings.numberOfSpatialLayers, kNumSpatialLayers); - EXPECT_TRUE(channel_->SetVideoSend(ssrcs[0], nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(ssrcs[0], nullptr, nullptr)); } TEST_F(Vp9SettingsTest, AllEncodingParametersCopied) { cricket::VideoSendParameters send_parameters; send_parameters.codecs.push_back(GetEngineCodec("VP9")); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters)); const size_t kNumSpatialLayers = 3; std::vector ssrcs = MAKE_VECTOR(kSsrcs3); @@ -3895,7 +3923,7 @@ TEST_F(Vp9SettingsTest, AllEncodingParametersCopied) { TEST_F(Vp9SettingsTest, MaxBitrateDeterminedBySvcResolutions) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); std::vector ssrcs = MAKE_VECTOR(kSsrcs3); @@ -3905,8 +3933,8 @@ TEST_F(Vp9SettingsTest, MaxBitrateDeterminedBySvcResolutions) { webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); webrtc::test::FrameForwarder frame_forwarder; - EXPECT_TRUE(channel_->SetVideoSend(ssrcs[0], nullptr, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE(send_channel_->SetVideoSend(ssrcs[0], nullptr, &frame_forwarder)); + send_channel_->SetSend(true); // Send frame at 1080p@30fps. frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame( @@ -3921,7 +3949,7 @@ TEST_F(Vp9SettingsTest, MaxBitrateDeterminedBySvcResolutions) { EXPECT_EQ(vp9_settings.numberOfSpatialLayers, kNumSpatialLayers); EXPECT_EQ(vp9_settings.numberOfTemporalLayers, kNumTemporalLayers); - EXPECT_TRUE(channel_->SetVideoSend(ssrcs[0], nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(ssrcs[0], nullptr, nullptr)); // VideoStream max bitrate should be more than legacy 2.5Mbps default stream // cap. @@ -3932,7 +3960,7 @@ TEST_F(Vp9SettingsTest, MaxBitrateDeterminedBySvcResolutions) { // Update send parameters to 2Mbps, this should cap the max bitrate of the // stream. parameters.max_bandwidth_bps = 2000000; - channel_->SetSendParameters(parameters); + send_channel_->SetSendParameters(parameters); EXPECT_THAT( stream->GetVideoStreams(), ElementsAre(Field(&webrtc::VideoStream::max_bitrate_bps, Eq(2000000)))); @@ -3941,7 +3969,7 @@ TEST_F(Vp9SettingsTest, MaxBitrateDeterminedBySvcResolutions) { TEST_F(Vp9SettingsTest, Vp9SvcTargetBitrateCappedByMax) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); std::vector ssrcs = MAKE_VECTOR(kSsrcs3); @@ -3951,8 +3979,8 @@ TEST_F(Vp9SettingsTest, Vp9SvcTargetBitrateCappedByMax) { webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); webrtc::test::FrameForwarder frame_forwarder; - EXPECT_TRUE(channel_->SetVideoSend(ssrcs[0], nullptr, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE(send_channel_->SetVideoSend(ssrcs[0], nullptr, &frame_forwarder)); + send_channel_->SetSend(true); // Set up 3 spatial layers with 720p, which should result in a max bitrate of // 2084 kbps. @@ -3968,7 +3996,7 @@ TEST_F(Vp9SettingsTest, Vp9SvcTargetBitrateCappedByMax) { EXPECT_EQ(vp9_settings.numberOfSpatialLayers, kNumSpatialLayers); EXPECT_EQ(vp9_settings.numberOfTemporalLayers, kNumTemporalLayers); - EXPECT_TRUE(channel_->SetVideoSend(ssrcs[0], nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(ssrcs[0], nullptr, nullptr)); // VideoStream both min and max bitrate should be lower than legacy 2.5Mbps // default stream cap. @@ -3994,13 +4022,14 @@ class Vp9SettingsTestWithFieldTrial webrtc::InterLayerPredMode interLayerPred) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(false, /*with_rtx=*/false); webrtc::test::FrameForwarder frame_forwarder; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); @@ -4010,7 +4039,7 @@ class Vp9SettingsTestWithFieldTrial EXPECT_EQ(num_temporal_layers, vp9_settings.numberOfTemporalLayers); EXPECT_EQ(inter_layer_pred_mode_, vp9_settings.interLayerPred); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } const uint8_t num_spatial_layers_; @@ -4108,23 +4137,22 @@ TEST_F(WebRtcVideoChannelTest, PreviousAdaptationDoesNotApplyToScreenshare) { MediaConfig media_config = GetMediaConfig(); media_config.video.enable_cpu_adaptation = true; - channel_.reset(engine_.CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, fake_call_.get(), media_config, - VideoOptions(), webrtc::CryptoOptions(), - video_bitrate_allocator_factory_.get())); - send_channel_ = channel_->AsVideoSendChannel(); - receive_channel_ = channel_->AsVideoReceiveChannel(); + send_channel_ = engine_.CreateSendChannel( + fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions(), + video_bitrate_allocator_factory_.get()); + receive_channel_ = engine_.CreateReceiveChannel( + fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions()); send_channel_->OnReadyToSend(true); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); AddSendStream(); webrtc::test::FrameForwarder frame_forwarder; - ASSERT_TRUE(channel_->SetSend(true)); + ASSERT_TRUE(send_channel_->SetSend(true)); cricket::VideoOptions camera_options; camera_options.is_screencast = false; - channel_->SetVideoSend(last_ssrc_, &camera_options, &frame_forwarder); + send_channel_->SetVideoSend(last_ssrc_, &camera_options, &frame_forwarder); ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size()); FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); @@ -4136,20 +4164,21 @@ TEST_F(WebRtcVideoChannelTest, PreviousAdaptationDoesNotApplyToScreenshare) { // Switch to screen share. Expect no resolution scaling. cricket::VideoOptions screenshare_options; screenshare_options.is_screencast = true; - channel_->SetVideoSend(last_ssrc_, &screenshare_options, &frame_forwarder); + send_channel_->SetVideoSend(last_ssrc_, &screenshare_options, + &frame_forwarder); ASSERT_EQ(2, fake_call_->GetNumCreatedSendStreams()); send_stream = fake_call_->GetVideoSendStreams().front(); EXPECT_FALSE(send_stream->resolution_scaling_enabled()); // Switch back to the normal capturer. Expect resolution scaling to be // reenabled. - channel_->SetVideoSend(last_ssrc_, &camera_options, &frame_forwarder); + send_channel_->SetVideoSend(last_ssrc_, &camera_options, &frame_forwarder); send_stream = fake_call_->GetVideoSendStreams().front(); ASSERT_EQ(3, fake_call_->GetNumCreatedSendStreams()); send_stream = fake_call_->GetVideoSendStreams().front(); EXPECT_TRUE(send_stream->resolution_scaling_enabled()); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } // TODO(asapersson): Remove this test when the balanced field trial is removed. @@ -4162,30 +4191,30 @@ void WebRtcVideoChannelTest::TestDegradationPreference( MediaConfig media_config = GetMediaConfig(); media_config.video.enable_cpu_adaptation = true; - channel_.reset(engine_.CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, fake_call_.get(), media_config, - VideoOptions(), webrtc::CryptoOptions(), - video_bitrate_allocator_factory_.get())); - send_channel_ = channel_->AsVideoSendChannel(); - receive_channel_ = channel_->AsVideoReceiveChannel(); + send_channel_ = engine_.CreateSendChannel( + fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions(), + video_bitrate_allocator_factory_.get()); + receive_channel_ = engine_.CreateReceiveChannel( + fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions()); send_channel_->OnReadyToSend(true); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); AddSendStream(); webrtc::test::FrameForwarder frame_forwarder; VideoOptions options; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); - EXPECT_TRUE(channel_->SetSend(true)); + EXPECT_TRUE(send_channel_->SetSend(true)); FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); EXPECT_EQ(resolution_scaling_enabled, send_stream->resolution_scaling_enabled()); EXPECT_EQ(fps_scaling_enabled, send_stream->framerate_scaling_enabled()); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } void WebRtcVideoChannelTest::TestCpuAdaptation(bool enable_overuse, @@ -4198,24 +4227,24 @@ void WebRtcVideoChannelTest::TestCpuAdaptation(bool enable_overuse, if (enable_overuse) { media_config.video.enable_cpu_adaptation = true; } - channel_.reset(engine_.CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, fake_call_.get(), media_config, - VideoOptions(), webrtc::CryptoOptions(), - video_bitrate_allocator_factory_.get())); - send_channel_ = channel_->AsVideoSendChannel(); - receive_channel_ = channel_->AsVideoReceiveChannel(); + send_channel_ = engine_.CreateSendChannel( + fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions(), + video_bitrate_allocator_factory_.get()); + receive_channel_ = engine_.CreateReceiveChannel( + fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions()); send_channel_->OnReadyToSend(true); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); AddSendStream(); webrtc::test::FrameForwarder frame_forwarder; VideoOptions options; options.is_screencast = is_screenshare; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); - EXPECT_TRUE(channel_->SetSend(true)); + EXPECT_TRUE(send_channel_->SetSend(true)); FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); @@ -4229,7 +4258,7 @@ void WebRtcVideoChannelTest::TestCpuAdaptation(bool enable_overuse, EXPECT_TRUE(send_stream->resolution_scaling_enabled()); EXPECT_FALSE(send_stream->framerate_scaling_enabled()); } - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, EstimatesNtpStartTimeCorrectly) { @@ -4237,11 +4266,11 @@ TEST_F(WebRtcVideoChannelTest, EstimatesNtpStartTimeCorrectly) { static const uint32_t kInitialTimestamp = 0xFFFFFFFFu; static const int64_t kInitialNtpTimeMs = 1247891230; static const int kFrameOffsetMs = 20; - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); FakeVideoReceiveStream* stream = AddRecvStream(); cricket::FakeVideoRenderer renderer; - EXPECT_TRUE(channel_->SetSink(last_ssrc_, &renderer)); + EXPECT_TRUE(receive_channel_->SetSink(last_ssrc_, &renderer)); webrtc::VideoFrame video_frame = webrtc::VideoFrame::Builder() @@ -4269,8 +4298,8 @@ TEST_F(WebRtcVideoChannelTest, EstimatesNtpStartTimeCorrectly) { // Verify that NTP time has been correctly deduced. cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); ASSERT_EQ(1u, receive_info.receivers.size()); EXPECT_EQ(kInitialNtpTimeMs, @@ -4279,7 +4308,7 @@ TEST_F(WebRtcVideoChannelTest, EstimatesNtpStartTimeCorrectly) { TEST_F(WebRtcVideoChannelTest, SetDefaultSendCodecs) { AssignDefaultAptRtxTypes(); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); absl::optional codec = send_channel_->GetSendCodec(); ASSERT_TRUE(codec); @@ -4306,7 +4335,7 @@ TEST_F(WebRtcVideoChannelTest, SetDefaultSendCodecs) { TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutPacketization) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); const webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); @@ -4317,7 +4346,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithPacketization) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.back().packetization = kPacketizationParamRaw; - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); const webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); @@ -4428,7 +4457,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, EnablingFlexfecDoesNotRecreateVideoReceiveStream) { cricket::VideoRecvParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); AddRecvStream( CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc)); @@ -4444,7 +4473,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, // Enable FlexFEC. recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03")); - ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); // The count of created streams will remain 2 despite the creation of a new // flexfec stream. The existing receive stream will have been reconfigured @@ -4470,7 +4499,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, cricket::VideoRecvParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03")); - ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); AddRecvStream( CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc)); @@ -4488,7 +4517,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, // Disable FlexFEC. recv_parameters.codecs.clear(); recv_parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); // The count of created streams should remain 2 since the video stream will // have been reconfigured to not reference flexfec and not recreated on // account of the flexfec stream being deleted. @@ -4513,7 +4542,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, DuplicateFlexfecCodecIsDropped) { cricket::VideoCodec duplicate = GetEngineCodec("flexfec-03"); duplicate.id = kUnusedPayloadType1; recv_parameters.codecs.push_back(duplicate); - ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); AddRecvStream( CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc)); @@ -4560,7 +4589,7 @@ TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, SetDefaultSendCodecsWithSsrc) { TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutFec) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); @@ -4572,7 +4601,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutFec) { TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, SetSendCodecsWithoutFec) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); @@ -4587,7 +4616,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvCodecsWithFec) { cricket::VideoRecvParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03")); - ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); const std::vector& flexfec_streams = fake_call_->GetFlexfecReceiveStreams(); @@ -4621,7 +4650,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("flexfec-03")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); @@ -4636,7 +4665,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("flexfec-03")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = AddSendStream( CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc)); @@ -4656,7 +4685,7 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoCodec rtx_codec = cricket::CreateVideoCodec(kUnusedPayloadType, "rtx"); parameters.codecs.push_back(rtx_codec); - EXPECT_FALSE(channel_->SetSendParameters(parameters)) + EXPECT_FALSE(send_channel_->SetSendParameters(parameters)) << "RTX codec without associated payload type should be rejected."; } @@ -4672,7 +4701,7 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(rtx_codec); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); } { cricket::VideoCodec rtx_codec = @@ -4680,7 +4709,7 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(rtx_codec); - EXPECT_FALSE(channel_->SetSendParameters(parameters)) + EXPECT_FALSE(send_channel_->SetSendParameters(parameters)) << "RTX without matching video codec should be rejected."; } } @@ -4704,7 +4733,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithChangedRtxPayloadType) { cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx"); rtx_codec.SetParam("apt", GetEngineCodec("VP8").id); parameters.codecs.push_back(rtx_codec); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); ASSERT_EQ(1U, fake_call_->GetVideoSendStreams().size()); const webrtc::VideoSendStream::Config& config_before = fake_call_->GetVideoSendStreams()[0]->GetConfig(); @@ -4714,7 +4743,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithChangedRtxPayloadType) { // Change payload type for RTX. parameters.codecs[1].id = kUnusedPayloadType2; - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); ASSERT_EQ(1U, fake_call_->GetVideoSendStreams().size()); const webrtc::VideoSendStream::Config& config_after = fake_call_->GetVideoSendStreams()[0]->GetConfig(); @@ -4727,7 +4756,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutFecDisablesFec) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("ulpfec")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); @@ -4735,7 +4764,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutFecDisablesFec) { EXPECT_EQ(GetEngineCodec("ulpfec").id, config.rtp.ulpfec.ulpfec_payload_type); parameters.codecs.pop_back(); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); stream = fake_call_->GetVideoSendStreams()[0]; ASSERT_TRUE(stream != nullptr); config = stream->GetConfig().Copy(); @@ -4748,7 +4777,7 @@ TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("flexfec-03")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = AddSendStream( CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc)); @@ -4760,7 +4789,7 @@ TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, EXPECT_EQ(kSsrcs1[0], config.rtp.flexfec.protected_media_ssrcs[0]); parameters.codecs.pop_back(); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); stream = fake_call_->GetVideoSendStreams()[0]; ASSERT_TRUE(stream != nullptr); config = stream->GetConfig().Copy(); @@ -4774,12 +4803,13 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsChangesExistingStreams) { codec.SetParam(kCodecParamMaxQuantization, kDefaultQpMax); parameters.codecs.push_back(codec); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); - channel_->SetSend(true); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + send_channel_->SetSend(true); FakeVideoSendStream* stream = AddSendStream(); webrtc::test::FrameForwarder frame_forwarder; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); std::vector streams = stream->GetVideoStreams(); EXPECT_EQ(kDefaultQpMax, streams[0].max_qp); @@ -4787,10 +4817,10 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsChangesExistingStreams) { parameters.codecs.clear(); codec.SetParam(kCodecParamMaxQuantization, kDefaultQpMax + 1); parameters.codecs.push_back(codec); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); streams = fake_call_->GetVideoSendStreams()[0]->GetVideoStreams(); EXPECT_EQ(kDefaultQpMax + 1, streams[0].max_qp); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithBitrates) { @@ -4817,7 +4847,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsCapsMinAndStartBitrate) { TEST_F(WebRtcVideoChannelTest, SetSendCodecsRejectsMaxLessThanMinBitrate) { send_parameters_.codecs[0].params[kCodecParamMinBitrate] = "300"; send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "200"; - EXPECT_FALSE(channel_->SetSendParameters(send_parameters_)); + EXPECT_FALSE(send_channel_->SetSendParameters(send_parameters_)); } // Test that when both the codec-specific bitrate params and max_bandwidth_bps @@ -4829,24 +4859,24 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithBitratesAndMaxSendBandwidth) { send_parameters_.max_bandwidth_bps = 400000; // We expect max_bandwidth_bps to take priority, if set. ExpectSetBitrateParameters(100000, 200000, 400000); - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); // Since the codec isn't changing, start_bitrate_bps should be -1. ExpectSetBitrateParameters(100000, -1, 350000); // Decrease max_bandwidth_bps. send_parameters_.max_bandwidth_bps = 350000; - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); // Now try again with the values flipped around. send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "400"; send_parameters_.max_bandwidth_bps = 300000; ExpectSetBitrateParameters(100000, 200000, 300000); - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); // If we change the codec max, max_bandwidth_bps should still apply. send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "350"; ExpectSetBitrateParameters(100000, 200000, 300000); - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); } TEST_F(WebRtcVideoChannelTest, SetMaxSendBandwidthShouldPreserveOtherBitrates) { @@ -4856,31 +4886,31 @@ TEST_F(WebRtcVideoChannelTest, SetMaxSendBandwidthShouldPreserveOtherBitrates) { // Setting max bitrate should keep previous min bitrate. // Setting max bitrate should not reset start bitrate. ExpectSetBitrateParameters(100000, -1, 300000); - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); } TEST_F(WebRtcVideoChannelTest, SetMaxSendBandwidthShouldBeRemovable) { send_parameters_.max_bandwidth_bps = 300000; ExpectSetMaxBitrate(300000); - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); // -1 means to disable max bitrate (set infinite). send_parameters_.max_bandwidth_bps = -1; ExpectSetMaxBitrate(-1); - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); } TEST_F(WebRtcVideoChannelTest, SetMaxSendBandwidthAndAddSendStream) { send_parameters_.max_bandwidth_bps = 99999; FakeVideoSendStream* stream = AddSendStream(); ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); ASSERT_EQ(1u, stream->GetVideoStreams().size()); EXPECT_EQ(send_parameters_.max_bandwidth_bps, stream->GetVideoStreams()[0].max_bitrate_bps); send_parameters_.max_bandwidth_bps = 77777; ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); EXPECT_EQ(send_parameters_.max_bandwidth_bps, stream->GetVideoStreams()[0].max_bitrate_bps); } @@ -4896,7 +4926,7 @@ TEST_F(WebRtcVideoChannelTest, send_parameters_.max_bandwidth_bps = -1; AddSendStream(); ExpectSetMaxBitrate(300000); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); std::vector video_send_streams = GetFakeSendStreams(); ASSERT_EQ(1u, video_send_streams.size()); @@ -4909,7 +4939,7 @@ TEST_F(WebRtcVideoChannelTest, // The VideoSendParameters max bitrate overrides the codec's. send_parameters_.max_bandwidth_bps = 500000; ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); ASSERT_EQ(1u, video_send_stream->GetVideoStreams().size()); EXPECT_EQ(500000, video_send_stream->GetVideoStreams()[0].max_bitrate_bps); } @@ -4925,7 +4955,7 @@ TEST_F(WebRtcVideoChannelTest, send_parameters_.max_bandwidth_bps = -1; AddSendStream(); ExpectSetMaxBitrate(300000); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); std::vector video_send_streams = GetFakeSendStreams(); ASSERT_EQ(1u, video_send_streams.size()); @@ -4950,7 +4980,7 @@ TEST_F(WebRtcVideoChannelTest, send_parameters_.max_bandwidth_bps = 99999; FakeVideoSendStream* stream = AddSendStream(); ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); ASSERT_EQ(1u, stream->GetVideoStreams().size()); EXPECT_EQ(send_parameters_.max_bandwidth_bps, stream->GetVideoStreams()[0].max_bitrate_bps); @@ -4974,40 +5004,42 @@ TEST_F(WebRtcVideoChannelTest, TEST_F(WebRtcVideoChannelTest, SetMaxSendBitrateCanIncreaseSenderBitrate) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); - channel_->SetSend(true); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + send_channel_->SetSend(true); FakeVideoSendStream* stream = AddSendStream(); webrtc::test::FrameForwarder frame_forwarder; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); std::vector streams = stream->GetVideoStreams(); int initial_max_bitrate_bps = streams[0].max_bitrate_bps; EXPECT_GT(initial_max_bitrate_bps, 0); parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2; - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); // Insert a frame to update the encoder config. frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); streams = stream->GetVideoStreams(); EXPECT_EQ(initial_max_bitrate_bps * 2, streams[0].max_bitrate_bps); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); - channel_->SetSend(true); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + send_channel_->SetSend(true); FakeVideoSendStream* stream = AddSendStream( cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3))); // Send a frame to make sure this scales up to >1 stream (simulcast). webrtc::test::FrameForwarder frame_forwarder; - EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], nullptr, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(kSsrcs3[0], nullptr, &frame_forwarder)); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); std::vector streams = stream->GetVideoStreams(); @@ -5017,14 +5049,14 @@ TEST_F(WebRtcVideoChannelTest, EXPECT_GT(initial_max_bitrate_bps, 0); parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2; - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); // Insert a frame to update the encoder config. frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); streams = stream->GetVideoStreams(); int increased_max_bitrate_bps = GetTotalMaxBitrate(streams).bps(); EXPECT_EQ(initial_max_bitrate_bps * 2, increased_max_bitrate_bps); - EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(kSsrcs3[0], nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithMaxQuantization) { @@ -5032,7 +5064,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithMaxQuantization) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization; - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); EXPECT_EQ(atoi(kMaxQuantization), AddSendStream()->GetVideoStreams().back().max_qp); @@ -5048,7 +5080,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsRejectBadPayloadTypes) { parameters.codecs.push_back(GetEngineCodec("VP8")); for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) { parameters.codecs[0].id = kIncorrectPayloads[i]; - EXPECT_FALSE(channel_->SetSendParameters(parameters)) + EXPECT_FALSE(send_channel_->SetSendParameters(parameters)) << "Bad payload type '" << kIncorrectPayloads[i] << "' accepted."; } } @@ -5058,7 +5090,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsAcceptAllValidPayloadTypes) { parameters.codecs.push_back(GetEngineCodec("VP8")); for (int payload_type = 96; payload_type <= 127; ++payload_type) { parameters.codecs[0].id = payload_type; - EXPECT_TRUE(channel_->SetSendParameters(parameters)) + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)) << "Payload type '" << payload_type << "' rejected."; } } @@ -5072,21 +5104,21 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoSendParameters parameters1; parameters1.codecs.push_back(GetEngineCodec("VP8")); parameters1.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(channel_->SetSendParameters(parameters1)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters1)); AddSendStream(); EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); cricket::VideoSendParameters parameters2; parameters2.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(channel_->SetSendParameters(parameters2)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters2)); EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithOnlyVp8) { cricket::VideoRecvParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); } // Test that we set our inbound RTX codecs properly. @@ -5101,22 +5133,22 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithRtx) { cricket::VideoCodec rtx_codec = cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx"); parameters.codecs.push_back(rtx_codec); - EXPECT_FALSE(channel_->SetRecvParameters(parameters)) + EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)) << "RTX codec without associated payload should be rejected."; parameters.codecs[1].SetParam("apt", kUnusedPayloadType2); - EXPECT_FALSE(channel_->SetRecvParameters(parameters)) + EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)) << "RTX codec with invalid associated payload type should be rejected."; parameters.codecs[1].SetParam("apt", GetEngineCodec("VP8").id); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); cricket::VideoCodec rtx_codec2 = cricket::CreateVideoCodec(kUnusedPayloadType2, "rtx"); rtx_codec2.SetParam("apt", rtx_codec.id); parameters.codecs.push_back(rtx_codec2); - EXPECT_FALSE(channel_->SetRecvParameters(parameters)) + EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)) << "RTX codec with another RTX as associated payload type should be " "rejected."; } @@ -5127,7 +5159,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithPacketization) { cricket::VideoRecvParameters parameters; parameters.codecs = {vp8_codec, GetEngineCodec("VP9")}; - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); const cricket::StreamParams params = cricket::StreamParams::CreateLegacy(kSsrcs1[0]); @@ -5144,7 +5176,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithPacketizationRecreatesStream) { cricket::VideoRecvParameters parameters; parameters.codecs = {GetEngineCodec("VP8"), GetEngineCodec("VP9")}; parameters.codecs.back().packetization = kPacketizationParamRaw; - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); const cricket::StreamParams params = cricket::StreamParams::CreateLegacy(kSsrcs1[0]); @@ -5153,7 +5185,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithPacketizationRecreatesStream) { EXPECT_EQ(fake_call_->GetNumCreatedReceiveStreams(), 1); parameters.codecs.back().packetization.reset(); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); EXPECT_EQ(fake_call_->GetNumCreatedReceiveStreams(), 2); } @@ -5167,7 +5199,7 @@ TEST_F(WebRtcVideoChannelTest, DuplicateUlpfecCodecIsDropped) { kFirstUlpfecPayloadType, cricket::kUlpfecCodecName)); parameters.codecs.push_back(cricket::CreateVideoCodec( kSecondUlpfecPayloadType, cricket::kUlpfecCodecName)); - ASSERT_TRUE(channel_->SetRecvParameters(parameters)); + ASSERT_TRUE(receive_channel_->SetRecvParameters(parameters)); FakeVideoReceiveStream* recv_stream = AddRecvStream(); EXPECT_EQ(kFirstUlpfecPayloadType, @@ -5184,7 +5216,7 @@ TEST_F(WebRtcVideoChannelTest, DuplicateRedCodecIsDropped) { cricket::CreateVideoCodec(kFirstRedPayloadType, cricket::kRedCodecName)); parameters.codecs.push_back( cricket::CreateVideoCodec(kSecondRedPayloadType, cricket::kRedCodecName)); - ASSERT_TRUE(channel_->SetRecvParameters(parameters)); + ASSERT_TRUE(receive_channel_->SetRecvParameters(parameters)); FakeVideoReceiveStream* recv_stream = AddRecvStream(); EXPECT_EQ(kFirstRedPayloadType, @@ -5210,7 +5242,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithChangedRtxPayloadType) { cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx"); rtx_codec.SetParam("apt", GetEngineCodec("VP8").id); parameters.codecs.push_back(rtx_codec); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); ASSERT_EQ(1U, fake_call_->GetVideoReceiveStreams().size()); const webrtc::VideoReceiveStreamInterface::Config& config_before = fake_call_->GetVideoReceiveStreams()[0]->GetConfig(); @@ -5223,7 +5255,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithChangedRtxPayloadType) { // Change payload type for RTX. parameters.codecs[1].id = kUnusedPayloadType2; - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); ASSERT_EQ(1U, fake_call_->GetVideoReceiveStreams().size()); const webrtc::VideoReceiveStreamInterface::Config& config_after = fake_call_->GetVideoReceiveStreams()[0]->GetConfig(); @@ -5254,7 +5286,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRtxWithRtxTime) { cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx"); rtx_codec.SetParam("apt", GetEngineCodec("VP8").id); parameters.codecs.push_back(rtx_codec); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); ASSERT_EQ(1U, fake_call_->GetVideoReceiveStreams().size()); const webrtc::VideoReceiveStreamInterface::Config& config = fake_call_->GetVideoReceiveStreams()[0]->GetConfig(); @@ -5267,7 +5299,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRtxWithRtxTime) { // Set rtx-time. parameters.codecs[1].SetParam(kCodecParamRtxTime, kRtxTime); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); EXPECT_EQ(fake_call_->GetVideoReceiveStreams()[0] ->GetConfig() .rtp.nack.rtp_history_ms, @@ -5275,7 +5307,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRtxWithRtxTime) { // Negative values are ignored so the default value applies. parameters.codecs[1].SetParam(kCodecParamRtxTime, -1); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); EXPECT_NE(fake_call_->GetVideoReceiveStreams()[0] ->GetConfig() .rtp.nack.rtp_history_ms, @@ -5287,7 +5319,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRtxWithRtxTime) { // 0 is ignored so the default applies. parameters.codecs[1].SetParam(kCodecParamRtxTime, 0); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); EXPECT_NE(fake_call_->GetVideoReceiveStreams()[0] ->GetConfig() .rtp.nack.rtp_history_ms, @@ -5299,7 +5331,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRtxWithRtxTime) { // Values larger than the default are clamped to the default. parameters.codecs[1].SetParam(kCodecParamRtxTime, default_history_ms + 100); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); EXPECT_EQ(fake_call_->GetVideoReceiveStreams()[0] ->GetConfig() .rtp.nack.rtp_history_ms, @@ -5310,13 +5342,13 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsDifferentPayloadType) { cricket::VideoRecvParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs[0].id = 99; - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsAcceptDefaultCodecs) { cricket::VideoRecvParameters parameters; parameters.codecs = engine_.recv_codecs(); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); FakeVideoReceiveStream* stream = AddRecvStream(); const webrtc::VideoReceiveStreamInterface::Config& config = @@ -5330,14 +5362,14 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectUnsupportedCodec) { cricket::VideoRecvParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(cricket::CreateVideoCodec(101, "WTF3")); - EXPECT_FALSE(channel_->SetRecvParameters(parameters)); + EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)); } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsAcceptsMultipleVideoCodecs) { cricket::VideoRecvParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithoutFecDisablesFec) { @@ -5345,7 +5377,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithoutFecDisablesFec) { send_parameters.codecs.push_back(GetEngineCodec("VP8")); send_parameters.codecs.push_back(GetEngineCodec("red")); send_parameters.codecs.push_back(GetEngineCodec("ulpfec")); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters)); FakeVideoReceiveStream* stream = AddRecvStream(); @@ -5354,7 +5386,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithoutFecDisablesFec) { cricket::VideoRecvParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); stream = fake_call_->GetVideoReceiveStreams()[0]; ASSERT_TRUE(stream != nullptr); EXPECT_EQ(-1, stream->GetConfig().rtp.ulpfec_payload_type) @@ -5376,7 +5408,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvParamsWithoutFecDisablesFec) { cricket::VideoRecvParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); EXPECT_TRUE(streams.empty()) << "SetSendCodec without FlexFEC should disable current FlexFEC."; } @@ -5390,7 +5422,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendParamsWithFecEnablesFec) { recv_parameters.codecs.push_back(GetEngineCodec("VP8")); recv_parameters.codecs.push_back(GetEngineCodec("red")); recv_parameters.codecs.push_back(GetEngineCodec("ulpfec")); - ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); stream = fake_call_->GetVideoReceiveStreams()[0]; ASSERT_TRUE(stream != nullptr); EXPECT_EQ(GetEngineCodec("ulpfec").id, @@ -5401,7 +5433,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendParamsWithFecEnablesFec) { send_parameters.codecs.push_back(GetEngineCodec("VP8")); send_parameters.codecs.push_back(GetEngineCodec("red")); send_parameters.codecs.push_back(GetEngineCodec("ulpfec")); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters)); stream = fake_call_->GetVideoReceiveStreams()[0]; EXPECT_EQ(GetEngineCodec("ulpfec").id, stream->GetConfig().rtp.ulpfec_payload_type) @@ -5418,7 +5450,7 @@ TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, cricket::VideoRecvParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03")); - ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); ASSERT_EQ(1U, streams.size()); const FakeFlexfecReceiveStream* stream_with_recv_params = streams.front(); EXPECT_EQ(GetEngineCodec("flexfec-03").id, @@ -5432,7 +5464,7 @@ TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, cricket::VideoSendParameters send_parameters; send_parameters.codecs.push_back(GetEngineCodec("VP8")); send_parameters.codecs.push_back(GetEngineCodec("flexfec-03")); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters)); ASSERT_EQ(1U, streams.size()); const FakeFlexfecReceiveStream* stream_with_send_params = streams.front(); EXPECT_EQ(GetEngineCodec("flexfec-03").id, @@ -5449,7 +5481,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectDuplicateFecPayloads) { parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("red")); parameters.codecs[1].id = parameters.codecs[0].id; - EXPECT_FALSE(channel_->SetRecvParameters(parameters)); + EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)); } TEST_F(WebRtcVideoChannelFlexfecRecvTest, @@ -5458,7 +5490,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("flexfec-03")); parameters.codecs[1].id = parameters.codecs[0].id; - EXPECT_FALSE(channel_->SetRecvParameters(parameters)); + EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)); } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectDuplicateCodecPayloads) { @@ -5466,7 +5498,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectDuplicateCodecPayloads) { parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); parameters.codecs[1].id = parameters.codecs[0].id; - EXPECT_FALSE(channel_->SetRecvParameters(parameters)); + EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)); } TEST_F(WebRtcVideoChannelTest, @@ -5475,7 +5507,7 @@ TEST_F(WebRtcVideoChannelTest, parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs[1].id += 1; - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); } // Test that setting the same codecs but with a different order @@ -5485,7 +5517,7 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoRecvParameters parameters1; parameters1.codecs.push_back(GetEngineCodec("VP8")); parameters1.codecs.push_back(GetEngineCodec("red")); - EXPECT_TRUE(channel_->SetRecvParameters(parameters1)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters1)); AddRecvStream(cricket::StreamParams::CreateLegacy(123)); EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams()); @@ -5493,7 +5525,7 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoRecvParameters parameters2; parameters2.codecs.push_back(GetEngineCodec("red")); parameters2.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(channel_->SetRecvParameters(parameters2)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters2)); EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams()); } @@ -5510,19 +5542,19 @@ TEST_F(WebRtcVideoChannelTest, SetSend) { EXPECT_FALSE(stream->IsSending()); // false->true - EXPECT_TRUE(channel_->SetSend(true)); + EXPECT_TRUE(send_channel_->SetSend(true)); EXPECT_TRUE(stream->IsSending()); // true->true - EXPECT_TRUE(channel_->SetSend(true)); + EXPECT_TRUE(send_channel_->SetSend(true)); EXPECT_TRUE(stream->IsSending()); // true->false - EXPECT_TRUE(channel_->SetSend(false)); + EXPECT_TRUE(send_channel_->SetSend(false)); EXPECT_FALSE(stream->IsSending()); // false->false - EXPECT_TRUE(channel_->SetSend(false)); + EXPECT_TRUE(send_channel_->SetSend(false)); EXPECT_FALSE(stream->IsSending()); - EXPECT_TRUE(channel_->SetSend(true)); + EXPECT_TRUE(send_channel_->SetSend(true)); FakeVideoSendStream* new_stream = AddSendStream(); EXPECT_TRUE(new_stream->IsSending()) << "Send stream created after SetSend(true) not sending initially."; @@ -5602,7 +5634,7 @@ TEST_F(WebRtcVideoChannelTest, TestSetSendRtcpReducedSize) { // Now enable reduced size mode. send_parameters_.rtcp.reduced_size = true; - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); stream1 = fake_call_->GetVideoSendStreams()[0]; EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream1->GetConfig().rtp.rtcp_mode); rtp_parameters = send_channel_->GetRtpSendParameters(last_ssrc_); @@ -5624,7 +5656,7 @@ TEST_F(WebRtcVideoChannelTest, TestSetRecvRtcpReducedSize) { // TODO(deadbeef): Once "recv_parameters" becomes "receiver_parameters", // the reduced_size flag should come from that. send_parameters_.rtcp.reduced_size = true; - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); stream1 = fake_call_->GetVideoReceiveStreams()[0]; EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream1->GetConfig().rtp.rtcp_mode); @@ -5655,14 +5687,14 @@ TEST_F(WebRtcVideoChannelTest, OnReadyToSendSignalsNetworkState) { TEST_F(WebRtcVideoChannelTest, GetStatsReportsSentCodecName) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); AddSendStream(); cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_EQ("VP8", send_info.senders[0].codec_name); } @@ -5675,8 +5707,8 @@ TEST_F(WebRtcVideoChannelTest, GetStatsReportsEncoderImplementationName) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_EQ(stats.encoder_implementation_name, send_info.senders[0].encoder_implementation_name); @@ -5690,8 +5722,8 @@ TEST_F(WebRtcVideoChannelTest, GetStatsReportsPowerEfficientEncoder) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_TRUE(send_info.senders[0].power_efficient_encoder); } @@ -5705,8 +5737,8 @@ TEST_F(WebRtcVideoChannelTest, GetStatsReportsCpuOveruseMetrics) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_EQ(stats.avg_encode_time_ms, send_info.senders[0].avg_encode_ms); EXPECT_EQ(stats.encode_usage_percent, @@ -5721,8 +5753,8 @@ TEST_F(WebRtcVideoChannelTest, GetStatsReportsFramesEncoded) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_EQ(stats.frames_encoded, send_info.senders[0].frames_encoded); } @@ -5736,8 +5768,8 @@ TEST_F(WebRtcVideoChannelTest, GetStatsReportsKeyFramesEncoded) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_EQ(send_info.senders.size(), 2u); EXPECT_EQ(10u, send_info.senders[0].key_frames_encoded); @@ -5754,8 +5786,8 @@ TEST_F(WebRtcVideoChannelTest, GetStatsReportsPerLayerQpSum) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_EQ(send_info.senders.size(), 2u); EXPECT_EQ(stats.substreams[123].qp_sum, send_info.senders[0].qp_sum); @@ -5806,8 +5838,8 @@ TEST_F(WebRtcVideoChannelTest, GetAggregatedStatsReportWithoutSubStreams) { stream->SetStats(stats); cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_EQ(send_info.aggregated_senders.size(), 1u); auto& sender = send_info.aggregated_senders[0]; @@ -5919,8 +5951,8 @@ TEST_F(WebRtcVideoChannelTest, GetAggregatedStatsReportForSubStreams) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_EQ(send_info.aggregated_senders.size(), 1u); auto& sender = send_info.aggregated_senders[0]; @@ -6043,8 +6075,8 @@ TEST_F(WebRtcVideoChannelTest, GetPerLayerStatsReportForSubStreams) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_EQ(send_info.senders.size(), 2u); auto& sender = send_info.senders[0]; @@ -6149,8 +6181,8 @@ TEST_F(WebRtcVideoChannelTest, // GetStats() and ensure `active` matches `encodings` for each SSRC. cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); ASSERT_EQ(send_info.senders.size(), 2u); ASSERT_TRUE(send_info.senders[0].active.has_value()); @@ -6162,7 +6194,7 @@ TEST_F(WebRtcVideoChannelTest, TEST_F(WebRtcVideoChannelTest, OutboundRtpIsActiveComesFromAnyEncodingInSvc) { cricket::VideoSendParameters send_parameters; send_parameters.codecs.push_back(GetEngineCodec("VP9")); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters)); constexpr uint32_t kSsrc1 = 123u; constexpr uint32_t kSsrc2 = 456u; @@ -6195,8 +6227,8 @@ TEST_F(WebRtcVideoChannelTest, OutboundRtpIsActiveComesFromAnyEncodingInSvc) { // GetStats() and ensure `active` is true if ANY encoding is active. cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); ASSERT_EQ(send_info.senders.size(), 1u); // Middle layer is active. @@ -6209,8 +6241,8 @@ TEST_F(WebRtcVideoChannelTest, OutboundRtpIsActiveComesFromAnyEncodingInSvc) { parameters.encodings[1].active = false; parameters.encodings[2].active = false; send_channel_->SetRtpSendParameters(kSsrc1, parameters); - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); ASSERT_EQ(send_info.senders.size(), 1u); // No layer is active. @@ -6236,8 +6268,8 @@ TEST_F(WebRtcVideoChannelTest, MediaSubstreamMissingProducesEmpyStats) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_TRUE(send_info.senders.empty()); } @@ -6255,8 +6287,8 @@ TEST_F(WebRtcVideoChannelTest, GetStatsReportsUpperResolution) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); ASSERT_EQ(1u, send_info.aggregated_senders.size()); ASSERT_EQ(3u, send_info.senders.size()); @@ -6279,8 +6311,8 @@ TEST_F(WebRtcVideoChannelTest, GetStatsReportsCpuAdaptationStats) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); ASSERT_EQ(1U, send_info.senders.size()); EXPECT_EQ(WebRtcVideoChannel::ADAPTREASON_CPU, @@ -6299,8 +6331,8 @@ TEST_F(WebRtcVideoChannelTest, GetStatsReportsAdaptationAndBandwidthStats) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); ASSERT_EQ(1U, send_info.senders.size()); EXPECT_EQ(WebRtcVideoChannel::ADAPTREASON_CPU | @@ -6474,8 +6506,8 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_EQ(send_info.senders.size(), 2u); EXPECT_EQ(15u, send_info.senders[0].header_and_padding_bytes_sent); @@ -6500,8 +6532,8 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); ASSERT_EQ(1U, send_info.senders.size()); EXPECT_EQ(WebRtcVideoChannel::ADAPTREASON_BANDWIDTH, @@ -6523,8 +6555,8 @@ TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesSendRtcpPacketTypesCorrectly) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_EQ(2, send_info.senders[0].firs_received); EXPECT_EQ(3u, send_info.senders[0].nacks_received); @@ -6550,8 +6582,8 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_EQ( stats.rtcp_packet_type_counts.fir_packets, @@ -6597,8 +6629,8 @@ TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesDecodeStatsCorrectly) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_EQ(stats.decoder_implementation_name, receive_info.receivers[0].decoder_implementation_name); @@ -6651,8 +6683,8 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_EQ(stats.total_inter_frame_delay, receive_info.receivers[0].total_inter_frame_delay); @@ -6672,8 +6704,8 @@ TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesReceivePacketStatsCorrectly) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_EQ(stats.rtp_stats.packet_counter.payload_bytes, rtc::checked_cast( @@ -6694,8 +6726,8 @@ TEST_F(WebRtcVideoChannelTest, TranslatesCallStatsCorrectly) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); ASSERT_EQ(2u, send_info.senders.size()); EXPECT_EQ(stats.rtt_ms, send_info.senders[0].rtt_ms); @@ -6725,13 +6757,13 @@ TEST_F(WebRtcVideoChannelTest, TranslatesSenderBitrateStatsCorrectly) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); ASSERT_EQ(2u, send_info.aggregated_senders.size()); ASSERT_EQ(4u, send_info.senders.size()); BandwidthEstimationInfo bwe_info; - channel_->FillBitrateInfo(&bwe_info); + send_channel_->FillBitrateInfo(&bwe_info); // Assuming stream and stream2 corresponds to senders[0] and [1] respectively // is OK as std::maps are sorted and AddSendStream() gives increasing SSRCs. EXPECT_EQ(stats.media_bitrate_bps, @@ -6749,7 +6781,7 @@ TEST_F(WebRtcVideoChannelTest, TranslatesSenderBitrateStatsCorrectly) { } TEST_F(WebRtcVideoChannelTest, DefaultReceiveStreamReconfiguresToUseRtx) { - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); const std::vector ssrcs = MAKE_VECTOR(kSsrcs1); const std::vector rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); @@ -6781,7 +6813,7 @@ TEST_F(WebRtcVideoChannelTest, DefaultReceiveStreamReconfiguresToUseRtx) { } TEST_F(WebRtcVideoChannelTest, RejectsAddingStreamsWithMissingSsrcsForRtx) { - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); const std::vector ssrcs = MAKE_VECTOR(kSsrcs1); const std::vector rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); @@ -6795,7 +6827,7 @@ TEST_F(WebRtcVideoChannelTest, RejectsAddingStreamsWithMissingSsrcsForRtx) { } TEST_F(WebRtcVideoChannelTest, RejectsAddingStreamsWithOverlappingRtxSsrcs) { - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); const std::vector ssrcs = MAKE_VECTOR(kSsrcs1); const std::vector rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); @@ -6823,7 +6855,7 @@ TEST_F(WebRtcVideoChannelTest, RejectsAddingStreamsWithOverlappingSimulcastSsrcs) { static const uint32_t kFirstStreamSsrcs[] = {1, 2, 3}; static const uint32_t kOverlappingStreamSsrcs[] = {4, 3, 5}; - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); StreamParams sp = cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kFirstStreamSsrcs)); @@ -6846,7 +6878,7 @@ TEST_F(WebRtcVideoChannelTest, } TEST_F(WebRtcVideoChannelTest, ReportsSsrcGroupsInStats) { - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); static const uint32_t kSenderSsrcs[] = {4, 7, 10}; static const uint32_t kSenderRtxSsrcs[] = {5, 8, 11}; @@ -6865,8 +6897,8 @@ TEST_F(WebRtcVideoChannelTest, ReportsSsrcGroupsInStats) { cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); ASSERT_EQ(1u, send_info.senders.size()); ASSERT_EQ(1u, receive_info.receivers.size()); @@ -6884,24 +6916,24 @@ TEST_F(WebRtcVideoChannelTest, MapsReceivedPayloadTypeToCodecName) { stream->SetStats(stats); cricket::VideoMediaSendInfo send_info; cricket::VideoMediaReceiveInfo receive_info; - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_STREQ("", receive_info.receivers[0].codec_name.c_str()); // Report VP8 if we're receiving it. stats.current_payload_type = GetEngineCodec("VP8").id; stream->SetStats(stats); - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_STREQ(kVp8CodecName, receive_info.receivers[0].codec_name.c_str()); // Report no codec name for unknown playload types. stats.current_payload_type = 3; stream->SetStats(stats); - EXPECT_TRUE(channel_->GetSendStats(&send_info)); - EXPECT_TRUE(channel_->GetReceiveStats(&receive_info)); + EXPECT_TRUE(send_channel_->GetStats(&send_info)); + EXPECT_TRUE(receive_channel_->GetStats(&receive_info)); EXPECT_STREQ("", receive_info.receivers[0].codec_name.c_str()); } @@ -7323,7 +7355,7 @@ void WebRtcVideoChannelTest::TestReceiveUnsignaledSsrcPacket( VideoCodec red_rtx_codec = cricket::CreateVideoRtxCodec( kRedRtxPayloadType, GetEngineCodec("red").id); recv_parameters_.codecs.push_back(red_rtx_codec); - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size()); RtpPacketReceived packet; @@ -7468,11 +7500,11 @@ TEST_F(WebRtcVideoChannelTest, ReceiveDifferentUnsignaledSsrc) { parameters.codecs.push_back(H264codec); #endif - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); // No receive streams yet. ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size()); cricket::FakeVideoRenderer renderer; - channel_->SetDefaultSink(&renderer); + receive_channel_->SetDefaultSink(&renderer); // Receive VP8 packet on first SSRC. RtpPacketReceived rtp_packet; @@ -7542,7 +7574,7 @@ TEST_F(WebRtcVideoChannelTest, NewUnsignaledStreamDoesNotDestroyPreviouslyUnsignaledStream) { cricket::VideoRecvParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(channel_->SetRecvParameters(parameters)); + ASSERT_TRUE(receive_channel_->SetRecvParameters(parameters)); // No streams signaled and no packets received, so we should not have any // stream objects created yet. @@ -7581,8 +7613,9 @@ TEST_F(WebRtcVideoChannelTest, CanSetMaxBitrateForExistingStream) { AddSendStream(); webrtc::test::FrameForwarder frame_forwarder; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); - EXPECT_TRUE(channel_->SetSend(true)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); + EXPECT_TRUE(send_channel_->SetSend(true)); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); int default_encoder_bitrate = GetMaxEncoderBitrate(); @@ -7601,7 +7634,7 @@ TEST_F(WebRtcVideoChannelTest, CanSetMaxBitrateForExistingStream) { SetAndExpectMaxBitrate(0, 800, 800); SetAndExpectMaxBitrate(0, 0, default_encoder_bitrate); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, CannotSetMaxBitrateForNonexistentStream) { @@ -7673,7 +7706,7 @@ TEST_F(WebRtcVideoChannelTest, send_parameters_.max_bandwidth_bps = 99999; FakeVideoSendStream* stream = AddSendStream(); ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); ASSERT_EQ(1UL, stream->GetVideoStreams().size()); EXPECT_EQ(webrtc::kDefaultMinVideoBitrateBps, stream->GetVideoStreams()[0].min_bitrate_bps); @@ -7861,8 +7894,9 @@ TEST_F(WebRtcVideoChannelTest, SetRtpSendParametersPrioritySimulcastStreams) { // reconfiguring, and allows us to test this behavior. webrtc::test::FrameForwarder frame_forwarder; VideoOptions options; - EXPECT_TRUE(channel_->SetVideoSend(primary_ssrc, &options, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(primary_ssrc, &options, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame( 1920, 1080, webrtc::VideoRotation::kVideoRotation_0, rtc::kNumMicrosecsPerSec / 30)); @@ -7907,22 +7941,23 @@ TEST_F(WebRtcVideoChannelTest, SetRtpSendParametersPrioritySimulcastStreams) { video_send_stream->GetVideoStreams()[1].bitrate_priority); EXPECT_EQ(absl::nullopt, video_send_stream->GetVideoStreams()[2].bitrate_priority); - EXPECT_TRUE(channel_->SetVideoSend(primary_ssrc, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(primary_ssrc, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, GetAndSetRtpSendParametersScaleResolutionDownByVP8) { VideoSendParameters parameters; parameters.codecs.push_back(cricket::CreateVideoCodec(kVp8CodecName)); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false); webrtc::test::FrameForwarder frame_forwarder; FakeFrameSource frame_source(1280, 720, rtc::kNumMicrosecsPerSec / 30); VideoOptions options; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + send_channel_->SetSend(true); // Try layers in natural order (smallest to largest). { @@ -8016,7 +8051,7 @@ TEST_F(WebRtcVideoChannelTest, EXPECT_EQ(180u, video_streams[2].height); } - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, @@ -8031,12 +8066,12 @@ TEST_F(WebRtcVideoChannelTest, // Set up WebRtcVideoChannel for 3-layer VP8 simulcast. VideoSendParameters parameters; parameters.codecs.push_back(cricket::CreateVideoCodec(kVp8CodecName)); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false); webrtc::test::FrameForwarder frame_forwarder; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, /*options=*/nullptr, - &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, /*options=*/nullptr, + &frame_forwarder)); + send_channel_->SetSend(true); // Set `scale_resolution_down_by`'s. auto rtp_parameters = send_channel_->GetRtpSendParameters(last_ssrc_); @@ -8066,7 +8101,7 @@ TEST_F(WebRtcVideoChannelTest, EXPECT_EQ(video_streams[2].height, 300u); // Tear down. - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, @@ -8074,15 +8109,16 @@ TEST_F(WebRtcVideoChannelTest, encoder_factory_->AddSupportedVideoCodecType(kH264CodecName); VideoSendParameters parameters; parameters.codecs.push_back(cricket::CreateVideoCodec(kH264CodecName)); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false); webrtc::test::FrameForwarder frame_forwarder; FakeFrameSource frame_source(1280, 720, rtc::kNumMicrosecsPerSec / 30); VideoOptions options; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + send_channel_->SetSend(true); // Try layers in natural order (smallest to largest). { @@ -8175,7 +8211,7 @@ TEST_F(WebRtcVideoChannelTest, EXPECT_EQ(320u, video_streams[2].width); EXPECT_EQ(180u, video_streams[2].height); } - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, @@ -8191,12 +8227,12 @@ TEST_F(WebRtcVideoChannelTest, encoder_factory_->AddSupportedVideoCodecType(kH264CodecName); VideoSendParameters parameters; parameters.codecs.push_back(cricket::CreateVideoCodec(kH264CodecName)); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false); webrtc::test::FrameForwarder frame_forwarder; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, /*options=*/nullptr, - &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, /*options=*/nullptr, + &frame_forwarder)); + send_channel_->SetSend(true); // Set `scale_resolution_down_by`'s. auto rtp_parameters = send_channel_->GetRtpSendParameters(last_ssrc_); @@ -8226,7 +8262,7 @@ TEST_F(WebRtcVideoChannelTest, EXPECT_EQ(video_streams[2].height, 300u); // Tear down. - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, GetAndSetRtpSendParametersMaxFramerate) { @@ -8302,8 +8338,9 @@ TEST_F(WebRtcVideoChannelTest, NumTemporalLayersPropagatedToEncoder) { // Send a full size frame so all simulcast layers are used when reconfiguring. webrtc::test::FrameForwarder frame_forwarder; VideoOptions options; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); // Get and set the rtp encoding parameters. @@ -8337,7 +8374,7 @@ TEST_F(WebRtcVideoChannelTest, NumTemporalLayersPropagatedToEncoder) { EXPECT_TRUE(send_channel_->SetRtpSendParameters(last_ssrc_, parameters).ok()); EXPECT_EQ(2, stream->num_encoder_reconfigurations()); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, @@ -8348,8 +8385,9 @@ TEST_F(WebRtcVideoChannelTest, // Send a full size frame so all simulcast layers are used when reconfiguring. webrtc::test::FrameForwarder frame_forwarder; VideoOptions options; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); // Change rtp encoding parameters. @@ -8376,7 +8414,7 @@ TEST_F(WebRtcVideoChannelTest, stream->GetVideoStreams()[1].num_temporal_layers); EXPECT_EQ(1UL, stream->GetVideoStreams()[2].num_temporal_layers); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, @@ -8387,8 +8425,9 @@ TEST_F(WebRtcVideoChannelTest, // Send a full size frame so all simulcast layers are used when reconfiguring. webrtc::test::FrameForwarder frame_forwarder; VideoOptions options; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); // Get and set the rtp encoding parameters. @@ -8418,7 +8457,7 @@ TEST_F(WebRtcVideoChannelTest, stream->GetVideoStreams()[1].max_framerate); EXPECT_EQ(20, stream->GetVideoStreams()[2].max_framerate); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, FallbackForUnsetOrUnsupportedScalabilityMode) { @@ -8434,8 +8473,9 @@ TEST_F(WebRtcVideoChannelTest, FallbackForUnsetOrUnsupportedScalabilityMode) { // Send a full size frame so all simulcast layers are used when reconfiguring. webrtc::test::FrameForwarder frame_forwarder; VideoOptions options; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); // Set scalability mode. @@ -8487,7 +8527,7 @@ TEST_F(WebRtcVideoChannelTest, FallbackForUnsetOrUnsupportedScalabilityMode) { EXPECT_TRUE(send_channel_->SetRtpSendParameters(last_ssrc_, parameters).ok()); EXPECT_EQ(2, stream->num_encoder_reconfigurations()); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, @@ -8502,15 +8542,16 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoSendParameters send_parameters; send_parameters.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(channel_->SetSendParameters(send_parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters)); FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false); // Send a full size frame so all simulcast layers are used when reconfiguring. webrtc::test::FrameForwarder frame_forwarder; VideoOptions options; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); // Set scalability mode. @@ -8555,7 +8596,7 @@ TEST_F(WebRtcVideoChannelTest, // Change codec to VP8. cricket::VideoSendParameters vp8_parameters; vp8_parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(channel_->SetSendParameters(vp8_parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(vp8_parameters)); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); // The stream should be recreated due to codec change. @@ -8582,7 +8623,7 @@ TEST_F(WebRtcVideoChannelTest, Field(&webrtc::RtpEncodingParameters::scalability_mode, kDefaultScalabilityModeStr))); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, GetAndSetRtpSendParametersMinAndMaxBitrate) { @@ -8642,8 +8683,9 @@ TEST_F(WebRtcVideoChannelTest, MinAndMaxSimulcastBitratePropagatedToEncoder) { // Send a full size frame so all simulcast layers are used when reconfiguring. webrtc::test::FrameForwarder frame_forwarder; VideoOptions options; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); // Get and set the rtp encoding parameters. @@ -8692,7 +8734,7 @@ TEST_F(WebRtcVideoChannelTest, MinAndMaxSimulcastBitratePropagatedToEncoder) { EXPECT_TRUE(send_channel_->SetRtpSendParameters(last_ssrc_, parameters).ok()); EXPECT_EQ(2, stream->num_encoder_reconfigurations()); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } // Test to only specify the min or max bitrate value for a layer via @@ -8705,8 +8747,9 @@ TEST_F(WebRtcVideoChannelTest, MinOrMaxSimulcastBitratePropagatedToEncoder) { // Send a full size frame so all simulcast layers are used when reconfiguring. webrtc::test::FrameForwarder frame_forwarder; VideoOptions options; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); // Get and set the rtp encoding parameters. @@ -8761,7 +8804,7 @@ TEST_F(WebRtcVideoChannelTest, MinOrMaxSimulcastBitratePropagatedToEncoder) { EXPECT_EQ(kDefault[2].max_bitrate_bps, stream->GetVideoStreams()[2].max_bitrate_bps); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } // Test that specifying the min (or max) bitrate value for a layer via @@ -8774,8 +8817,9 @@ TEST_F(WebRtcVideoChannelTest, SetMinAndMaxSimulcastBitrateAboveBelowDefault) { // Send a full size frame so all simulcast layers are used when reconfiguring. webrtc::test::FrameForwarder frame_forwarder; VideoOptions options; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); // Get and set the rtp encoding parameters. @@ -8812,7 +8856,7 @@ TEST_F(WebRtcVideoChannelTest, SetMinAndMaxSimulcastBitrateAboveBelowDefault) { EXPECT_EQ(kDefault[2].max_bitrate_bps, stream->GetVideoStreams()[2].max_bitrate_bps); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, BandwidthAboveTotalMaxBitrateGivenToMaxLayer) { @@ -8822,8 +8866,9 @@ TEST_F(WebRtcVideoChannelTest, BandwidthAboveTotalMaxBitrateGivenToMaxLayer) { // Send a full size frame so all simulcast layers are used when reconfiguring. webrtc::test::FrameForwarder frame_forwarder; VideoOptions options; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); // Set max bitrate for all but the highest layer. @@ -8838,7 +8883,7 @@ TEST_F(WebRtcVideoChannelTest, BandwidthAboveTotalMaxBitrateGivenToMaxLayer) { send_parameters_.max_bandwidth_bps = GetTotalMaxBitrate(stream->GetVideoStreams()).bps(); ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); // No bitrate above the total max to give to the highest layer. EXPECT_EQ(kNumSimulcastStreams, stream->GetVideoStreams().size()); @@ -8849,7 +8894,7 @@ TEST_F(WebRtcVideoChannelTest, BandwidthAboveTotalMaxBitrateGivenToMaxLayer) { send_parameters_.max_bandwidth_bps = GetTotalMaxBitrate(stream->GetVideoStreams()).bps() + 1; ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); // The highest layer has no max bitrate set -> the bitrate above the total // max should be given to the highest layer. @@ -8859,7 +8904,7 @@ TEST_F(WebRtcVideoChannelTest, BandwidthAboveTotalMaxBitrateGivenToMaxLayer) { EXPECT_EQ(kDefault[2].max_bitrate_bps + 1, stream->GetVideoStreams()[2].max_bitrate_bps); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, @@ -8871,8 +8916,9 @@ TEST_F(WebRtcVideoChannelTest, // Send a full size frame so all simulcast layers are used when reconfiguring. webrtc::test::FrameForwarder frame_forwarder; VideoOptions options; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); // Set max bitrate for the highest layer. @@ -8886,7 +8932,7 @@ TEST_F(WebRtcVideoChannelTest, send_parameters_.max_bandwidth_bps = GetTotalMaxBitrate(stream->GetVideoStreams()).bps() + 1; ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps); - ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); // The highest layer has the max bitrate set -> the bitrate above the total // max should not be given to the highest layer. @@ -8894,14 +8940,14 @@ TEST_F(WebRtcVideoChannelTest, EXPECT_EQ(*parameters.encodings[2].max_bitrate_bps, stream->GetVideoStreams()[2].max_bitrate_bps); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } // Test that min and max bitrate values set via RtpParameters are correctly // propagated to the underlying encoder for a single stream. TEST_F(WebRtcVideoChannelTest, MinAndMaxBitratePropagatedToEncoder) { FakeVideoSendStream* stream = AddSendStream(); - EXPECT_TRUE(channel_->SetSend(true)); + EXPECT_TRUE(send_channel_->SetSend(true)); EXPECT_TRUE(stream->IsSending()); // Set min and max bitrate. @@ -8932,7 +8978,7 @@ TEST_F(WebRtcVideoChannelTest, MinAndMaxBitratePropagatedToEncoder) { // RtpParameters). TEST_F(WebRtcVideoChannelTest, DefaultMinAndMaxBitratePropagatedToEncoder) { FakeVideoSendStream* stream = AddSendStream(); - EXPECT_TRUE(channel_->SetSend(true)); + EXPECT_TRUE(send_channel_->SetSend(true)); EXPECT_TRUE(stream->IsSending()); // Check that WebRtcVideoSendStream updates VideoEncoderConfig correctly. @@ -8957,7 +9003,7 @@ TEST_F(WebRtcVideoChannelTest, DefaultMinAndMaxBitratePropagatedToEncoder) { // through SetRtpSendParameters. TEST_F(WebRtcVideoChannelTest, SetRtpSendParametersOneEncodingActive) { FakeVideoSendStream* stream = AddSendStream(); - EXPECT_TRUE(channel_->SetSend(true)); + EXPECT_TRUE(send_channel_->SetSend(true)); EXPECT_TRUE(stream->IsSending()); // Get current parameters and change "active" to false. @@ -8991,8 +9037,9 @@ TEST_F(WebRtcVideoChannelTest, SetRtpSendParametersMultipleEncodingsActive) { // appropriately. webrtc::test::FrameForwarder frame_forwarder; VideoOptions options; - EXPECT_TRUE(channel_->SetVideoSend(primary_ssrc, &options, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(primary_ssrc, &options, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame( 1920, 1080, webrtc::VideoRotation::kVideoRotation_0, rtc::kNumMicrosecsPerSec / 30)); @@ -9048,7 +9095,7 @@ TEST_F(WebRtcVideoChannelTest, SetRtpSendParametersMultipleEncodingsActive) { EXPECT_FALSE(simulcast_streams[1].active); EXPECT_FALSE(simulcast_streams[2].active); - EXPECT_TRUE(channel_->SetVideoSend(primary_ssrc, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(primary_ssrc, nullptr, nullptr)); } // Tests that when some streams are disactivated then the lowest @@ -9067,8 +9114,9 @@ TEST_F(WebRtcVideoChannelTest, // appropriately. webrtc::test::FrameForwarder frame_forwarder; VideoOptions options; - EXPECT_TRUE(channel_->SetVideoSend(primary_ssrc, &options, &frame_forwarder)); - channel_->SetSend(true); + EXPECT_TRUE( + send_channel_->SetVideoSend(primary_ssrc, &options, &frame_forwarder)); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame( 1920, 1080, webrtc::VideoRotation::kVideoRotation_0, rtc::kNumMicrosecsPerSec / 30)); @@ -9102,7 +9150,7 @@ TEST_F(WebRtcVideoChannelTest, EXPECT_EQ(simulcast_streams[2].min_bitrate_bps, simulcast_streams[0].min_bitrate_bps); - EXPECT_TRUE(channel_->SetVideoSend(primary_ssrc, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(primary_ssrc, nullptr, nullptr)); } // Test that if a stream is reconfigured (due to a codec change or other @@ -9113,10 +9161,10 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoSendParameters parameters1; parameters1.codecs.push_back(GetEngineCodec("VP8")); parameters1.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(channel_->SetSendParameters(parameters1)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters1)); FakeVideoSendStream* stream = AddSendStream(); - EXPECT_TRUE(channel_->SetSend(true)); + EXPECT_TRUE(send_channel_->SetSend(true)); EXPECT_TRUE(stream->IsSending()); // Get current parameters and change "active" to false. @@ -9134,7 +9182,7 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoSendParameters parameters2; parameters2.codecs.push_back(GetEngineCodec("VP9")); parameters2.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(channel_->SetSendParameters(parameters2)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters2)); auto new_streams = GetFakeSendStreams(); // Assert that a new underlying stream was created due to the codec change. // Otherwise, this test isn't testing what it set out to test. @@ -9152,7 +9200,7 @@ TEST_F(WebRtcVideoChannelTest, GetRtpSendParametersCodecs) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); webrtc::RtpParameters rtp_parameters = send_channel_->GetRtpSendParameters(last_ssrc_); @@ -9203,7 +9251,8 @@ TEST_F(WebRtcVideoChannelTest, GetRtpSendParametersDegradationPreference) { AddSendStream(); webrtc::test::FrameForwarder frame_forwarder; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); webrtc::RtpParameters rtp_parameters = send_channel_->GetRtpSendParameters(last_ssrc_); @@ -9220,7 +9269,7 @@ TEST_F(WebRtcVideoChannelTest, GetRtpSendParametersDegradationPreference) { webrtc::DegradationPreference::MAINTAIN_FRAMERATE); // Remove the source since it will be destroyed before the channel - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } // Test that if we set/get parameters multiple times, we get the same results. @@ -9229,7 +9278,7 @@ TEST_F(WebRtcVideoChannelTest, SetAndGetRtpSendParameters) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); webrtc::RtpParameters initial_params = send_channel_->GetRtpSendParameters(last_ssrc_); @@ -9248,10 +9297,10 @@ TEST_F(WebRtcVideoChannelTest, GetRtpReceiveParametersCodecs) { cricket::VideoRecvParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); webrtc::RtpParameters rtp_parameters = - channel_->GetRtpReceiveParameters(last_ssrc_); + receive_channel_->GetRtpReceiveParameters(last_ssrc_); ASSERT_EQ(2u, rtp_parameters.codecs.size()); EXPECT_EQ(GetEngineCodec("VP8").ToCodecParameters(), rtp_parameters.codecs[0]); @@ -9271,13 +9320,13 @@ TEST_F(WebRtcVideoChannelTest, DISABLED_GetRtpReceiveFmtpSprop) { cricket::VideoCodec kH264sprop2 = cricket::CreateVideoCodec(102, "H264"); kH264sprop2.SetParam(kH264FmtpSpropParameterSets, "xyz"); parameters.codecs.push_back(kH264sprop2); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); FakeVideoReceiveStream* recv_stream = AddRecvStream(); const webrtc::VideoReceiveStreamInterface::Config& cfg = recv_stream->GetConfig(); webrtc::RtpParameters rtp_parameters = - channel_->GetRtpReceiveParameters(last_ssrc_); + receive_channel_->GetRtpReceiveParameters(last_ssrc_); ASSERT_EQ(2u, rtp_parameters.codecs.size()); EXPECT_EQ(kH264sprop1.ToCodecParameters(), rtp_parameters.codecs[0]); ASSERT_EQ(2u, cfg.decoders.size()); @@ -9302,7 +9351,7 @@ TEST_F(WebRtcVideoChannelTest, GetRtpReceiveParametersSsrc) { AddRecvStream(); webrtc::RtpParameters rtp_parameters = - channel_->GetRtpReceiveParameters(last_ssrc_); + receive_channel_->GetRtpReceiveParameters(last_ssrc_); ASSERT_EQ(1u, rtp_parameters.encodings.size()); EXPECT_EQ(last_ssrc_, rtp_parameters.encodings[0].ssrc); } @@ -9313,14 +9362,15 @@ TEST_F(WebRtcVideoChannelTest, SetAndGetRtpReceiveParameters) { cricket::VideoRecvParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); webrtc::RtpParameters initial_params = - channel_->GetRtpReceiveParameters(last_ssrc_); + receive_channel_->GetRtpReceiveParameters(last_ssrc_); // ... And this shouldn't change the params returned by // GetRtpReceiveParameters. - EXPECT_EQ(initial_params, channel_->GetRtpReceiveParameters(last_ssrc_)); + EXPECT_EQ(initial_params, + receive_channel_->GetRtpReceiveParameters(last_ssrc_)); } // Test that GetDefaultRtpReceiveParameters returns parameters correctly when @@ -9334,20 +9384,20 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoRecvParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); // Call GetRtpReceiveParameters before configured to receive an unsignaled // stream. Should return nothing. EXPECT_EQ(webrtc::RtpParameters(), - channel_->GetDefaultRtpReceiveParameters()); + receive_channel_->GetDefaultRtpReceiveParameters()); // Set a sink for an unsignaled stream. cricket::FakeVideoRenderer renderer; - channel_->SetDefaultSink(&renderer); + receive_channel_->SetDefaultSink(&renderer); // Call GetDefaultRtpReceiveParameters before the SSRC is known. webrtc::RtpParameters rtp_parameters = - channel_->GetDefaultRtpReceiveParameters(); + receive_channel_->GetDefaultRtpReceiveParameters(); ASSERT_EQ(1u, rtp_parameters.encodings.size()); EXPECT_FALSE(rtp_parameters.encodings[0].ssrc); @@ -9358,7 +9408,7 @@ TEST_F(WebRtcVideoChannelTest, ReceivePacketAndAdvanceTime(rtp_packet); // The `ssrc` member should still be unset. - rtp_parameters = channel_->GetDefaultRtpReceiveParameters(); + rtp_parameters = receive_channel_->GetDefaultRtpReceiveParameters(); ASSERT_EQ(1u, rtp_parameters.encodings.size()); EXPECT_FALSE(rtp_parameters.encodings[0].ssrc); } @@ -9383,7 +9433,7 @@ TEST_F(WebRtcVideoChannelTest, void WebRtcVideoChannelTest::TestReceiverLocalSsrcConfiguration( bool receiver_first) { - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); const uint32_t kSenderSsrc = 0xC0FFEE; const uint32_t kSecondSenderSsrc = 0xBADCAFE; @@ -9448,13 +9498,14 @@ TEST_F(WebRtcVideoChannelTest, webrtc::test::FrameForwarder frame_forwarder; VideoOptions options; options.is_screencast = true; - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, &options, &frame_forwarder)); // Fetch the latest stream since SetVideoSend() may recreate it if the // screen content setting is changed. FakeVideoSendStream* stream = fake_call_->GetVideoSendStreams().front(); EXPECT_FALSE(stream->GetEncoderConfig().is_quality_scaling_allowed); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, @@ -9492,12 +9543,11 @@ class WebRtcVideoChannelSimulcastTest : public ::testing::Test { void SetUp() override { encoder_factory_->AddSupportedVideoCodecType("VP8"); decoder_factory_->AddSupportedVideoCodecType("VP8"); - channel_.reset(engine_.CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, &fake_call_, GetMediaConfig(), - VideoOptions(), webrtc::CryptoOptions(), - mock_rate_allocator_factory_.get())); - send_channel_ = channel_->AsVideoSendChannel(); - receive_channel_ = channel_->AsVideoReceiveChannel(); + send_channel_ = engine_.CreateSendChannel( + &fake_call_, GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(), + mock_rate_allocator_factory_.get()); + receive_channel_ = engine_.CreateReceiveChannel( + &fake_call_, GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions()); send_channel_->OnReadyToSend(true); receive_channel_->SetReceive(true); last_ssrc_ = 123; @@ -9514,7 +9564,7 @@ class WebRtcVideoChannelSimulcastTest : public ::testing::Test { cricket::VideoSendParameters parameters; parameters.codecs.push_back(codec); parameters.conference_mode = conference_mode; - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); std::vector ssrcs = MAKE_VECTOR(kSsrcs3); RTC_DCHECK(num_configured_streams <= ssrcs.size()); @@ -9531,11 +9581,11 @@ class WebRtcVideoChannelSimulcastTest : public ::testing::Test { if (screenshare) options.is_screencast = screenshare; EXPECT_TRUE( - channel_->SetVideoSend(ssrcs.front(), &options, &frame_forwarder)); + send_channel_->SetVideoSend(ssrcs.front(), &options, &frame_forwarder)); // Fetch the latest stream since SetVideoSend() may recreate it if the // screen content setting is changed. FakeVideoSendStream* stream = fake_call_.GetVideoSendStreams().front(); - channel_->SetSend(true); + send_channel_->SetSend(true); frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame()); auto rtp_parameters = send_channel_->GetRtpSendParameters(kSsrcs3[0]); @@ -9605,7 +9655,7 @@ class WebRtcVideoChannelSimulcastTest : public ::testing::Test { } } - EXPECT_TRUE(channel_->SetVideoSend(ssrcs.front(), nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(ssrcs.front(), nullptr, nullptr)); } FakeVideoSendStream* AddSendStream() { @@ -9646,9 +9696,8 @@ class WebRtcVideoChannelSimulcastTest : public ::testing::Test { std::unique_ptr mock_rate_allocator_factory_; WebRtcVideoEngine engine_; - std::unique_ptr channel_; - VideoMediaSendChannelInterface* send_channel_; - VideoMediaReceiveChannelInterface* receive_channel_; + std::unique_ptr send_channel_; + std::unique_ptr receive_channel_; uint32_t last_ssrc_; }; @@ -9684,9 +9733,9 @@ TEST_F(WebRtcVideoChannelSimulcastTest, SimulcastScreenshareWithoutConference) { } TEST_F(WebRtcVideoChannelBaseTest, GetSources) { - EXPECT_THAT(channel_->GetSources(kSsrc), IsEmpty()); + EXPECT_THAT(receive_channel_->GetSources(kSsrc), IsEmpty()); - channel_->SetDefaultSink(&renderer_); + receive_channel_->SetDefaultSink(&renderer_); EXPECT_TRUE(SetDefaultCodec()); EXPECT_TRUE(SetSend(true)); EXPECT_EQ(renderer_.num_rendered_frames(), 0); @@ -9695,11 +9744,11 @@ TEST_F(WebRtcVideoChannelBaseTest, GetSources) { SendFrame(); EXPECT_FRAME(1, kVideoWidth, kVideoHeight); - EXPECT_THAT(channel_->GetSources(kSsrc - 1), IsEmpty()); - EXPECT_THAT(channel_->GetSources(kSsrc), SizeIs(1)); - EXPECT_THAT(channel_->GetSources(kSsrc + 1), IsEmpty()); + EXPECT_THAT(receive_channel_->GetSources(kSsrc - 1), IsEmpty()); + EXPECT_THAT(receive_channel_->GetSources(kSsrc), SizeIs(1)); + EXPECT_THAT(receive_channel_->GetSources(kSsrc + 1), IsEmpty()); - webrtc::RtpSource source = channel_->GetSources(kSsrc)[0]; + webrtc::RtpSource source = receive_channel_->GetSources(kSsrc)[0]; EXPECT_EQ(source.source_id(), kSsrc); EXPECT_EQ(source.source_type(), webrtc::RtpSourceType::SSRC); int64_t rtp_timestamp_1 = source.rtp_timestamp(); @@ -9709,11 +9758,11 @@ TEST_F(WebRtcVideoChannelBaseTest, GetSources) { SendFrame(); EXPECT_FRAME(2, kVideoWidth, kVideoHeight); - EXPECT_THAT(channel_->GetSources(kSsrc - 1), IsEmpty()); - EXPECT_THAT(channel_->GetSources(kSsrc), SizeIs(1)); - EXPECT_THAT(channel_->GetSources(kSsrc + 1), IsEmpty()); + EXPECT_THAT(receive_channel_->GetSources(kSsrc - 1), IsEmpty()); + EXPECT_THAT(receive_channel_->GetSources(kSsrc), SizeIs(1)); + EXPECT_THAT(receive_channel_->GetSources(kSsrc + 1), IsEmpty()); - source = channel_->GetSources(kSsrc)[0]; + source = receive_channel_->GetSources(kSsrc)[0]; EXPECT_EQ(source.source_id(), kSsrc); EXPECT_EQ(source.source_type(), webrtc::RtpSourceType::SSRC); int64_t rtp_timestamp_2 = source.rtp_timestamp(); @@ -9748,8 +9797,8 @@ TEST_F(WebRtcVideoChannelBaseTest, EncoderSelectorSwitchCodec) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(vp9); - EXPECT_TRUE(channel_->SetSendParameters(parameters)); - channel_->SetSend(true); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + send_channel_->SetSend(true); absl::optional codec = send_channel_->GetSendCodec(); ASSERT_TRUE(codec); @@ -9759,7 +9808,7 @@ TEST_F(WebRtcVideoChannelBaseTest, EncoderSelectorSwitchCodec) { EXPECT_CALL(encoder_selector, OnAvailableBitrate) .WillRepeatedly(Return(webrtc::SdpVideoFormat("VP9"))); - channel_->SetEncoderSelector(kSsrc, &encoder_selector); + send_channel_->SetEncoderSelector(kSsrc, &encoder_selector); time_controller_.AdvanceTime(kFrameDuration); codec = send_channel_->GetSendCodec(); @@ -9767,19 +9816,20 @@ TEST_F(WebRtcVideoChannelBaseTest, EncoderSelectorSwitchCodec) { EXPECT_EQ("VP9", codec->name); // Deregister the encoder selector in case it's called during test tear-down. - channel_->SetEncoderSelector(kSsrc, nullptr); + send_channel_->SetEncoderSelector(kSsrc, nullptr); } TEST_F(WebRtcVideoChannelTest, RequestedResolutionSinglecast) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); webrtc::test::FrameForwarder frame_forwarder; cricket::FakeFrameSource frame_source(1280, 720, rtc::kNumMicrosecsPerSec / 30); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); { // TEST requested_resolution < frame size webrtc::RtpParameters rtp_parameters = @@ -9825,19 +9875,20 @@ TEST_F(WebRtcVideoChannelTest, RequestedResolutionSinglecast) { EXPECT_EQ(rtc::checked_cast(720), streams[0].height); } - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, RequestedResolutionSinglecastCropping) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); webrtc::test::FrameForwarder frame_forwarder; cricket::FakeFrameSource frame_source(1280, 720, rtc::kNumMicrosecsPerSec / 30); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); { auto rtp_parameters = send_channel_->GetRtpSendParameters(last_ssrc_); @@ -9882,19 +9933,20 @@ TEST_F(WebRtcVideoChannelTest, RequestedResolutionSinglecastCropping) { EXPECT_EQ(rtc::checked_cast(480), streams[0].height); } - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } TEST_F(WebRtcVideoChannelTest, RequestedResolutionSimulcast) { cricket::VideoSendParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false); webrtc::test::FrameForwarder frame_forwarder; cricket::FakeFrameSource frame_source(1280, 720, rtc::kNumMicrosecsPerSec / 30); - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); + EXPECT_TRUE( + send_channel_->SetVideoSend(last_ssrc_, nullptr, &frame_forwarder)); { webrtc::RtpParameters rtp_parameters = @@ -9962,7 +10014,7 @@ TEST_F(WebRtcVideoChannelTest, RequestedResolutionSimulcast) { })); } - EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); + EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); } } // namespace cricket