From 96293f0876d4f162adccc54c3aa38727a90a89d5 Mon Sep 17 00:00:00 2001 From: Florent Castelli Date: Tue, 27 Jun 2023 16:09:12 +0000 Subject: [PATCH] Remove usage of CreateMediaChannel in webrtc_voice_engine_unittest Bug: webrtc:13931 Change-Id: Iad11f54469fe86a1a97e2bc33dc250ccd1457474 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/310620 Auto-Submit: Florent Castelli Reviewed-by: Harald Alvestrand Commit-Queue: Florent Castelli Cr-Commit-Position: refs/heads/main@{#40365} --- media/engine/webrtc_voice_engine_unittest.cc | 466 ++++++++++--------- 1 file changed, 241 insertions(+), 225 deletions(-) diff --git a/media/engine/webrtc_voice_engine_unittest.cc b/media/engine/webrtc_voice_engine_unittest.cc index d4055a0ba9..74021af8e3 100644 --- a/media/engine/webrtc_voice_engine_unittest.cc +++ b/media/engine/webrtc_voice_engine_unittest.cc @@ -27,6 +27,7 @@ #include "media/base/fake_media_engine.h" #include "media/base/fake_network_interface.h" #include "media/base/fake_rtp.h" +#include "media/base/media_channel.h" #include "media/base/media_channel_shim.h" #include "media/base/media_constants.h" #include "media/engine/fake_webrtc_call.h" @@ -233,13 +234,26 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { } bool SetupChannel() { - channel_ = engine_->CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, &call_, cricket::MediaConfig(), - cricket::AudioOptions(), webrtc::CryptoOptions(), - webrtc::AudioCodecPairId::Create()); - send_channel_ = channel_->AsVoiceSendChannel(); - receive_channel_ = channel_->AsVoiceReceiveChannel(); - return (channel_ != nullptr); + send_channel_ = engine_->CreateSendChannel( + &call_, cricket::MediaConfig(), cricket::AudioOptions(), + webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); + receive_channel_ = engine_->CreateReceiveChannel( + &call_, cricket::MediaConfig(), cricket::AudioOptions(), + webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); + send_channel_->SetSsrcListChangedCallback( + [receive_channel = + receive_channel_.get()](const std::set& choices) { + receive_channel->ChooseReceiverReportSsrc(choices); + }); + send_channel_->SetSendCodecChangedCallback( + [receive_channel = receive_channel_.get(), + send_channel = send_channel_.get()]() { + receive_channel->SetReceiveNackEnabled( + send_channel->SendCodecHasNack()); + receive_channel->SetReceiveNonSenderRttEnabled( + send_channel->SenderNonSenderRttEnabled()); + }); + return true; } bool SetupRecvStream() { @@ -263,11 +277,11 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { if (!use_null_apm_) { EXPECT_CALL(*apm_, set_output_will_be_muted(false)); } - return channel_->SetAudioSend(kSsrcX, true, nullptr, &fake_source_); + return send_channel_->SetAudioSend(kSsrcX, true, nullptr, &fake_source_); } bool AddRecvStream(uint32_t ssrc) { - EXPECT_TRUE(channel_); + EXPECT_TRUE(receive_channel_); return receive_channel_->AddRecvStream( cricket::StreamParams::CreateLegacy(ssrc)); } @@ -288,8 +302,6 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { rtc::Thread::Current()->ProcessMessages(0); } - void TearDown() override { delete channel_; } - const cricket::FakeAudioSendStream& GetSendStream(uint32_t ssrc) { const auto* send_stream = call_.GetAudioSendStream(ssrc); EXPECT_TRUE(send_stream); @@ -312,7 +324,7 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { } void SetSend(bool enable) { - ASSERT_TRUE(channel_); + ASSERT_TRUE(send_channel_); if (enable) { EXPECT_CALL(*adm_, RecordingIsInitialized()) .Times(::testing::AtMost(1)) @@ -324,23 +336,23 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { .Times(::testing::AtMost(1)) .WillOnce(Return(0)); } - channel_->SetSend(enable); + send_channel_->SetSend(enable); } void SetSendParameters(const cricket::AudioSendParameters& params) { - ASSERT_TRUE(channel_); - EXPECT_TRUE(channel_->SetSendParameters(params)); + ASSERT_TRUE(send_channel_); + EXPECT_TRUE(send_channel_->SetSendParameters(params)); } void SetAudioSend(uint32_t ssrc, bool enable, cricket::AudioSource* source, const cricket::AudioOptions* options = nullptr) { - ASSERT_TRUE(channel_); + ASSERT_TRUE(send_channel_); if (!use_null_apm_) { EXPECT_CALL(*apm_, set_output_will_be_muted(!enable)); } - EXPECT_TRUE(channel_->SetAudioSend(ssrc, enable, options, source)); + EXPECT_TRUE(send_channel_->SetAudioSend(ssrc, enable, options, source)); } void TestInsertDtmf(uint32_t ssrc, @@ -357,27 +369,27 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { // Test we can only InsertDtmf when the other side supports telephone-event. SetSendParameters(send_parameters_); SetSend(true); - EXPECT_FALSE(channel_->CanInsertDtmf()); - EXPECT_FALSE(channel_->InsertDtmf(ssrc, 1, 111)); + EXPECT_FALSE(send_channel_->CanInsertDtmf()); + EXPECT_FALSE(send_channel_->InsertDtmf(ssrc, 1, 111)); send_parameters_.codecs.push_back(codec); SetSendParameters(send_parameters_); - EXPECT_TRUE(channel_->CanInsertDtmf()); + EXPECT_TRUE(send_channel_->CanInsertDtmf()); if (!caller) { // If this is callee, there's no active send channel yet. - EXPECT_FALSE(channel_->InsertDtmf(ssrc, 2, 123)); + EXPECT_FALSE(send_channel_->InsertDtmf(ssrc, 2, 123)); EXPECT_TRUE(send_channel_->AddSendStream( cricket::StreamParams::CreateLegacy(kSsrcX))); } // Check we fail if the ssrc is invalid. - EXPECT_FALSE(channel_->InsertDtmf(-1, 1, 111)); + EXPECT_FALSE(send_channel_->InsertDtmf(-1, 1, 111)); // Test send. cricket::FakeAudioSendStream::TelephoneEvent telephone_event = GetSendStream(kSsrcX).GetLatestTelephoneEvent(); EXPECT_EQ(-1, telephone_event.payload_type); - EXPECT_TRUE(channel_->InsertDtmf(ssrc, 2, 123)); + EXPECT_TRUE(send_channel_->InsertDtmf(ssrc, 2, 123)); telephone_event = GetSendStream(kSsrcX).GetLatestTelephoneEvent(); EXPECT_EQ(codec.id, telephone_event.payload_type); EXPECT_EQ(codec.clockrate, telephone_event.payload_frequency); @@ -401,7 +413,7 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { // For a callee, the answer will be applied in set local description // where SetExtmapAllowMixed() and AddSendStream() are called. EXPECT_TRUE(SetupChannel()); - channel_->SetExtmapAllowMixed(extmap_allow_mixed); + send_channel_->SetExtmapAllowMixed(extmap_allow_mixed); EXPECT_TRUE(send_channel_->AddSendStream( cricket::StreamParams::CreateLegacy(kSsrcX))); @@ -424,7 +436,7 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { if (expected_result) { SetSendParameters(parameters); } else { - EXPECT_FALSE(channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); } EXPECT_EQ(expected_bitrate, GetCodecBitrate(kSsrcX)); } @@ -563,41 +575,48 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { EXPECT_TRUE(SetupRecvStream()); // Ensure extensions are off by default. - EXPECT_THAT(channel_->GetRtpReceiveParameters(kSsrcX).header_extensions, - IsEmpty()); + EXPECT_THAT( + receive_channel_->GetRtpReceiveParameters(kSsrcX).header_extensions, + IsEmpty()); // Ensure unknown extensions won't cause an error. recv_parameters_.extensions.push_back( webrtc::RtpExtension("urn:ietf:params:unknownextention", 1)); - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); - EXPECT_THAT(channel_->GetRtpReceiveParameters(kSsrcX).header_extensions, - IsEmpty()); + EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); + EXPECT_THAT( + receive_channel_->GetRtpReceiveParameters(kSsrcX).header_extensions, + IsEmpty()); // Ensure extensions stay off with an empty list of headers. recv_parameters_.extensions.clear(); - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); - EXPECT_THAT(channel_->GetRtpReceiveParameters(kSsrcX).header_extensions, - IsEmpty()); + EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); + EXPECT_THAT( + receive_channel_->GetRtpReceiveParameters(kSsrcX).header_extensions, + IsEmpty()); // Ensure extension is set properly. const int id = 2; recv_parameters_.extensions.push_back(webrtc::RtpExtension(ext, id)); - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); - EXPECT_EQ(channel_->GetRtpReceiveParameters(kSsrcX).header_extensions, - recv_parameters_.extensions); + EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); + EXPECT_EQ( + receive_channel_->GetRtpReceiveParameters(kSsrcX).header_extensions, + recv_parameters_.extensions); // Ensure extension is set properly on new stream. EXPECT_TRUE(AddRecvStream(kSsrcY)); - EXPECT_EQ(channel_->GetRtpReceiveParameters(kSsrcY).header_extensions, - recv_parameters_.extensions); + EXPECT_EQ( + receive_channel_->GetRtpReceiveParameters(kSsrcY).header_extensions, + recv_parameters_.extensions); // Ensure all extensions go back off with an empty list. recv_parameters_.extensions.clear(); - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); - EXPECT_THAT(channel_->GetRtpReceiveParameters(kSsrcX).header_extensions, - IsEmpty()); - EXPECT_THAT(channel_->GetRtpReceiveParameters(kSsrcY).header_extensions, - IsEmpty()); + EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); + EXPECT_THAT( + receive_channel_->GetRtpReceiveParameters(kSsrcX).header_extensions, + IsEmpty()); + EXPECT_THAT( + receive_channel_->GetRtpReceiveParameters(kSsrcY).header_extensions, + IsEmpty()); } webrtc::AudioSendStream::Stats GetAudioSendStreamStats() const { @@ -806,19 +825,16 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { } cricket::WebRtcVoiceSendChannel* SendImplFromPointer( - cricket::VoiceMediaChannel* channel) { - return static_cast( - static_cast(channel) - ->SendImplForTesting()); + cricket::VoiceMediaSendChannelInterface* channel) { + return static_cast(channel); } cricket::WebRtcVoiceSendChannel* SendImpl() { - return SendImplFromPointer(channel_); + return SendImplFromPointer(send_channel_.get()); } cricket::WebRtcVoiceReceiveChannel* ReceiveImpl() { return static_cast( - static_cast(channel_) - ->ReceiveImplForTesting()); + receive_channel_.get()); } protected: @@ -830,9 +846,8 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { rtc::scoped_refptr> apm_; cricket::FakeCall call_; std::unique_ptr engine_; - cricket::VoiceMediaChannel* channel_ = nullptr; - cricket::VoiceMediaSendChannelInterface* send_channel_; - cricket::VoiceMediaReceiveChannelInterface* receive_channel_; + std::unique_ptr send_channel_; + std::unique_ptr receive_channel_; cricket::AudioSendParameters send_parameters_; cricket::AudioRecvParameters recv_parameters_; FakeAudioSource fake_source_; @@ -894,7 +909,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecs) { parameters.codecs.push_back(kTelephoneEventCodec2); parameters.codecs[0].id = 106; // collide with existing CN 32k parameters.codecs[2].id = 126; - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); EXPECT_TRUE(AddRecvStream(kSsrcX)); EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, (ContainerEq>( @@ -910,7 +925,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsUnsupportedCodec) { cricket::AudioRecvParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(cricket::CreateAudioCodec(127, "XYZ", 32000, 1)); - EXPECT_FALSE(channel_->SetRecvParameters(parameters)); + EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)); } // Test that we fail if we have duplicate types in the inbound list. @@ -920,7 +935,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsDuplicatePayloadType) { parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kCn16000Codec); parameters.codecs[1].id = kOpusCodec.id; - EXPECT_FALSE(channel_->SetRecvParameters(parameters)); + EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)); } // Test that we can decode OPUS without stereo parameters. @@ -929,7 +944,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpusNoStereo) { cricket::AudioRecvParameters parameters; parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kOpusCodec); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); EXPECT_TRUE(AddRecvStream(kSsrcX)); EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, (ContainerEq>( @@ -943,7 +958,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus0Stereo) { parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kOpusCodec); parameters.codecs[1].params["stereo"] = "0"; - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); EXPECT_TRUE(AddRecvStream(kSsrcX)); EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, (ContainerEq>( @@ -958,7 +973,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus1Stereo) { parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kOpusCodec); parameters.codecs[1].params["stereo"] = "1"; - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); EXPECT_TRUE(AddRecvStream(kSsrcX)); EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, (ContainerEq>( @@ -976,7 +991,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) { parameters.codecs.push_back(kTelephoneEventCodec2); parameters.codecs[0].id = 106; // collide with existing CN 32k parameters.codecs[2].id = 126; - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); for (const auto& ssrc : {kSsrcX, kSsrcY}) { EXPECT_TRUE(AddRecvStream(ssrc)); EXPECT_THAT(GetRecvStreamConfig(ssrc).decoder_map, @@ -993,7 +1008,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsAfterAddingStreams) { cricket::AudioRecvParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].id = 106; // collide with existing CN 32k - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); const auto& dm = GetRecvStreamConfig(kSsrcX).decoder_map; ASSERT_EQ(1u, dm.count(106)); @@ -1006,14 +1021,14 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWhilePlaying) { cricket::AudioRecvParameters parameters; parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kCn16000Codec); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); - channel_->SetPlayout(true); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + receive_channel_->SetPlayout(true); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); // Remapping a payload type to a different codec should fail. parameters.codecs[0] = kOpusCodec; parameters.codecs[0].id = kPcmuCodec.id; - EXPECT_FALSE(channel_->SetRecvParameters(parameters)); + EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)); EXPECT_TRUE(GetRecvStream(kSsrcX).started()); } @@ -1023,11 +1038,11 @@ TEST_P(WebRtcVoiceEngineTestFake, AddRecvCodecsWhilePlaying) { cricket::AudioRecvParameters parameters; parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kCn16000Codec); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); - channel_->SetPlayout(true); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + receive_channel_->SetPlayout(true); parameters.codecs.push_back(kOpusCodec); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); EXPECT_TRUE(GetRecvStream(kSsrcX).started()); } @@ -1037,10 +1052,10 @@ TEST_P(WebRtcVoiceEngineTestFake, ChangeRecvCodecPayloadType) { EXPECT_TRUE(SetupRecvStream()); cricket::AudioRecvParameters parameters; parameters.codecs.push_back(kOpusCodec); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); ++parameters.codecs[0].id; - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); } // Test that we do allow setting Opus/Red by default. @@ -1050,7 +1065,7 @@ TEST_P(WebRtcVoiceEngineTestFake, RecvRedDefault) { parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kRed48000Codec); parameters.codecs[1].params[""] = "111/111"; - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, (ContainerEq>( {{111, {"opus", 48000, 2}}, @@ -1126,7 +1141,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) { EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); send_parameters_.max_bandwidth_bps = 128; - EXPECT_FALSE(channel_->SetSendParameters(send_parameters_)); + EXPECT_FALSE(send_channel_->SetSendParameters(send_parameters_)); EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); } @@ -1423,10 +1438,10 @@ TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersCodecs) { cricket::AudioRecvParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); webrtc::RtpParameters rtp_parameters = - channel_->GetRtpReceiveParameters(kSsrcX); + receive_channel_->GetRtpReceiveParameters(kSsrcX); ASSERT_EQ(2u, rtp_parameters.codecs.size()); EXPECT_EQ(kOpusCodec.ToCodecParameters(), rtp_parameters.codecs[0]); EXPECT_EQ(kPcmuCodec.ToCodecParameters(), rtp_parameters.codecs[1]); @@ -1436,7 +1451,7 @@ TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersCodecs) { TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersSsrc) { EXPECT_TRUE(SetupRecvStream()); webrtc::RtpParameters rtp_parameters = - channel_->GetRtpReceiveParameters(kSsrcX); + receive_channel_->GetRtpReceiveParameters(kSsrcX); ASSERT_EQ(1u, rtp_parameters.encodings.size()); EXPECT_EQ(kSsrcX, rtp_parameters.encodings[0].ssrc); } @@ -1447,15 +1462,16 @@ TEST_P(WebRtcVoiceEngineTestFake, SetAndGetRtpReceiveParameters) { cricket::AudioRecvParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); webrtc::RtpParameters initial_params = - channel_->GetRtpReceiveParameters(kSsrcX); + receive_channel_->GetRtpReceiveParameters(kSsrcX); // ... And this shouldn't change the params returned by // GetRtpReceiveParameters. - webrtc::RtpParameters new_params = channel_->GetRtpReceiveParameters(kSsrcX); - EXPECT_EQ(initial_params, channel_->GetRtpReceiveParameters(kSsrcX)); + webrtc::RtpParameters new_params = + receive_channel_->GetRtpReceiveParameters(kSsrcX); + EXPECT_EQ(initial_params, receive_channel_->GetRtpReceiveParameters(kSsrcX)); } // Test that GetRtpReceiveParameters returns parameters correctly when SSRCs @@ -1469,20 +1485,20 @@ TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersWithUnsignaledSsrc) { cricket::AudioRecvParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); // Call GetDefaultRtpReceiveParameters 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. std::unique_ptr fake_sink(new FakeAudioSink()); - channel_->SetDefaultRawAudioSink(std::move(fake_sink)); + receive_channel_->SetDefaultRawAudioSink(std::move(fake_sink)); // 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); @@ -1490,7 +1506,7 @@ TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersWithUnsignaledSsrc) { DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame)); // 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); } @@ -1500,7 +1516,7 @@ TEST_P(WebRtcVoiceEngineTestFake, OnPacketReceivedIdentifiesExtensions) { cricket::AudioRecvParameters parameters = recv_parameters_; parameters.extensions.push_back( RtpExtension(RtpExtension::kAudioLevelUri, /*id=*/1)); - ASSERT_TRUE(channel_->SetRecvParameters(parameters)); + ASSERT_TRUE(receive_channel_->SetRecvParameters(parameters)); webrtc::RtpHeaderExtensionMap extension_map(parameters.extensions); webrtc::RtpPacketReceived reference_packet(&extension_map); constexpr uint8_t kAudioLevel = 123; @@ -1536,7 +1552,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecs) { EXPECT_STRCASEEQ("OPUS", send_codec_spec.format.name.c_str()); EXPECT_NE(send_codec_spec.format.clockrate_hz, 8000); EXPECT_EQ(absl::nullopt, send_codec_spec.cng_payload_type); - EXPECT_FALSE(channel_->CanInsertDtmf()); + EXPECT_FALSE(send_channel_->CanInsertDtmf()); } // Test that we use Opus/Red by default when it is @@ -1653,7 +1669,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; parameters.codecs[0].clockrate = 50000; - EXPECT_FALSE(channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); } // Test that if channels=0 for opus, we fail. @@ -1663,7 +1679,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0ChannelsNoStereo) { parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; parameters.codecs[0].channels = 0; - EXPECT_FALSE(channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); } // Test that if channels=0 for opus, we fail. @@ -1674,7 +1690,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0Channels1Stereo) { parameters.codecs[0].bitrate = 0; parameters.codecs[0].channels = 0; parameters.codecs[0].params["stereo"] = "1"; - EXPECT_FALSE(channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); } // Test that if channel is 1 for opus and there's no stereo, we fail. @@ -1684,7 +1700,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpus1ChannelNoStereo) { parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; parameters.codecs[0].channels = 1; - EXPECT_FALSE(channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); } // Test that if channel is 1 for opus and stereo=0, we fail. @@ -1695,7 +1711,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel0Stereo) { parameters.codecs[0].bitrate = 0; parameters.codecs[0].channels = 1; parameters.codecs[0].params["stereo"] = "0"; - EXPECT_FALSE(channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); } // Test that if channel is 1 for opus and stereo=1, we fail. @@ -1706,7 +1722,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) { parameters.codecs[0].bitrate = 0; parameters.codecs[0].channels = 1; parameters.codecs[0].params["stereo"] = "1"; - EXPECT_FALSE(channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); } // Test that with bitrate=0 and no stereo, bitrate is 32000. @@ -1983,7 +1999,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { EXPECT_TRUE(SetupSendStream()); cricket::AudioSendParameters parameters; - EXPECT_FALSE(channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); } // Test that we can set send codecs even with telephone-event codec as the first @@ -2001,7 +2017,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { EXPECT_EQ(96, spec.payload_type); EXPECT_STRCASEEQ("OPUS", spec.format.name.c_str()); SetSend(true); - EXPECT_TRUE(channel_->CanInsertDtmf()); + EXPECT_TRUE(send_channel_->CanInsertDtmf()); } // Test that CanInsertDtmf() is governed by the send flag @@ -2013,11 +2029,11 @@ TEST_P(WebRtcVoiceEngineTestFake, DTMFControlledBySendFlag) { parameters.codecs[0].id = 98; // DTMF parameters.codecs[1].id = 96; SetSendParameters(parameters); - EXPECT_FALSE(channel_->CanInsertDtmf()); + EXPECT_FALSE(send_channel_->CanInsertDtmf()); SetSend(true); - EXPECT_TRUE(channel_->CanInsertDtmf()); + EXPECT_TRUE(send_channel_->CanInsertDtmf()); SetSend(false); - EXPECT_FALSE(channel_->CanInsertDtmf()); + EXPECT_FALSE(send_channel_->CanInsertDtmf()); } // Test that payload type range is limited for telephone-event codec. @@ -2030,16 +2046,16 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { parameters.codecs[1].id = 96; SetSendParameters(parameters); SetSend(true); - EXPECT_TRUE(channel_->CanInsertDtmf()); + EXPECT_TRUE(send_channel_->CanInsertDtmf()); parameters.codecs[0].id = 128; // DTMF - EXPECT_FALSE(channel_->SetSendParameters(parameters)); - EXPECT_FALSE(channel_->CanInsertDtmf()); + EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->CanInsertDtmf()); parameters.codecs[0].id = 127; SetSendParameters(parameters); - EXPECT_TRUE(channel_->CanInsertDtmf()); + EXPECT_TRUE(send_channel_->CanInsertDtmf()); parameters.codecs[0].id = -1; // DTMF - EXPECT_FALSE(channel_->SetSendParameters(parameters)); - EXPECT_FALSE(channel_->CanInsertDtmf()); + EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->CanInsertDtmf()); } // Test that we can set send codecs even with CN codec as the first @@ -2075,7 +2091,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { EXPECT_EQ(1u, send_codec_spec.format.num_channels); EXPECT_EQ(97, send_codec_spec.cng_payload_type); SetSend(true); - EXPECT_TRUE(channel_->CanInsertDtmf()); + EXPECT_TRUE(send_channel_->CanInsertDtmf()); } // Test that we set VAD and DTMF types correctly as callee. @@ -2099,7 +2115,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { EXPECT_EQ(1u, send_codec_spec.format.num_channels); EXPECT_EQ(97, send_codec_spec.cng_payload_type); SetSend(true); - EXPECT_TRUE(channel_->CanInsertDtmf()); + EXPECT_TRUE(send_channel_->CanInsertDtmf()); } // Test that we only apply VAD if we have a CN codec that matches the @@ -2155,7 +2171,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { EXPECT_EQ(1u, send_codec_spec.format.num_channels); EXPECT_EQ(97, send_codec_spec.cng_payload_type); SetSend(true); - EXPECT_TRUE(channel_->CanInsertDtmf()); + EXPECT_TRUE(send_channel_->CanInsertDtmf()); } TEST_P(WebRtcVoiceEngineTestFake, @@ -2249,10 +2265,10 @@ TEST_P(WebRtcVoiceEngineTestFake, SendStateWhenStreamsAreRecreated) { // Test that we can create a channel and start playing out on it. TEST_P(WebRtcVoiceEngineTestFake, Playout) { EXPECT_TRUE(SetupRecvStream()); - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); - channel_->SetPlayout(true); + EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); + receive_channel_->SetPlayout(true); EXPECT_TRUE(GetRecvStream(kSsrcX).started()); - channel_->SetPlayout(false); + receive_channel_->SetPlayout(false); EXPECT_FALSE(GetRecvStream(kSsrcX).started()); } @@ -2364,7 +2380,7 @@ TEST_P(WebRtcVoiceEngineTestFake, GetStatsWithMultipleSendStreams) { // We need send codec to be set to get all stats. SetSendParameters(send_parameters_); - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); SetAudioSendStreamStats(); SetAudioReceiveStreamStats(); @@ -2373,8 +2389,8 @@ TEST_P(WebRtcVoiceEngineTestFake, GetStatsWithMultipleSendStreams) { EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0)); cricket::VoiceMediaSendInfo send_info; cricket::VoiceMediaReceiveInfo receive_info; - EXPECT_EQ(true, channel_->GetSendStats(&send_info)); - EXPECT_EQ(true, channel_->GetReceiveStats( + EXPECT_EQ(true, send_channel_->GetStats(&send_info)); + EXPECT_EQ(true, receive_channel_->GetStats( &receive_info, /*get_and_clear_legacy_stats=*/true)); // We have added 4 send streams. We should see empty stats for all. @@ -2396,8 +2412,8 @@ TEST_P(WebRtcVoiceEngineTestFake, GetStatsWithMultipleSendStreams) { cricket::VoiceMediaSendInfo send_info; EXPECT_TRUE(receive_channel_->RemoveRecvStream(kSsrcY)); EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0)); - EXPECT_EQ(true, channel_->GetSendStats(&send_info)); - EXPECT_EQ(true, channel_->GetReceiveStats( + EXPECT_EQ(true, send_channel_->GetStats(&send_info)); + EXPECT_EQ(true, receive_channel_->GetStats( &receive_info, /*get_and_clear_legacy_stats=*/true)); EXPECT_EQ(static_cast(arraysize(kSsrcs4)), send_info.senders.size()); @@ -2412,8 +2428,8 @@ TEST_P(WebRtcVoiceEngineTestFake, GetStatsWithMultipleSendStreams) { DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame)); SetAudioReceiveStreamStats(); EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0)); - EXPECT_EQ(true, channel_->GetSendStats(&send_info)); - EXPECT_EQ(true, channel_->GetReceiveStats( + EXPECT_EQ(true, send_channel_->GetStats(&send_info)); + EXPECT_EQ(true, receive_channel_->GetStats( &receive_info, /*get_and_clear_legacy_stats=*/true)); EXPECT_EQ(static_cast(arraysize(kSsrcs4)), send_info.senders.size()); @@ -2430,7 +2446,7 @@ TEST_P(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) { // Start playout without a receive stream. SetSendParameters(send_parameters_); - channel_->SetPlayout(true); + receive_channel_->SetPlayout(true); // Adding another stream should enable playout on the new stream only. EXPECT_TRUE(AddRecvStream(kSsrcY)); @@ -2450,12 +2466,12 @@ TEST_P(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) { EXPECT_FALSE(GetSendStream(kSsrcX).IsSending()); // Stop playout. - channel_->SetPlayout(false); + receive_channel_->SetPlayout(false); EXPECT_FALSE(GetRecvStream(kSsrcY).started()); EXPECT_FALSE(GetRecvStream(kSsrcZ).started()); // Restart playout and make sure recv streams are played out. - channel_->SetPlayout(true); + receive_channel_->SetPlayout(true); EXPECT_TRUE(GetRecvStream(kSsrcY).started()); EXPECT_TRUE(GetRecvStream(kSsrcZ).started()); @@ -2519,7 +2535,7 @@ TEST_P(WebRtcVoiceEngineTestFake, GetStats) { // stream has to use a different SSRC. EXPECT_TRUE(AddRecvStream(kSsrcY)); SetSendParameters(send_parameters_); - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); SetAudioSendStreamStats(); // Check stats for the added streams. @@ -2527,8 +2543,8 @@ TEST_P(WebRtcVoiceEngineTestFake, GetStats) { EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0)); cricket::VoiceMediaSendInfo send_info; cricket::VoiceMediaReceiveInfo receive_info; - EXPECT_EQ(true, channel_->GetSendStats(&send_info)); - EXPECT_EQ(true, channel_->GetReceiveStats( + EXPECT_EQ(true, send_channel_->GetStats(&send_info)); + EXPECT_EQ(true, receive_channel_->GetStats( &receive_info, /*get_and_clear_legacy_stats=*/true)); // We have added one send stream. We should see the stats we've set. @@ -2546,8 +2562,8 @@ TEST_P(WebRtcVoiceEngineTestFake, GetStats) { cricket::VoiceMediaSendInfo send_info; cricket::VoiceMediaReceiveInfo receive_info; SetAudioReceiveStreamStats(); - EXPECT_EQ(true, channel_->GetSendStats(&send_info)); - EXPECT_EQ(true, channel_->GetReceiveStats( + EXPECT_EQ(true, send_channel_->GetStats(&send_info)); + EXPECT_EQ(true, receive_channel_->GetStats( &receive_info, /*get_and_clear_legacy_stats=*/true)); VerifyVoiceSenderInfo(send_info.senders[0], true); VerifyVoiceSendRecvCodecs(send_info, receive_info); @@ -2559,8 +2575,8 @@ TEST_P(WebRtcVoiceEngineTestFake, GetStats) { EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0)); cricket::VoiceMediaSendInfo send_info; cricket::VoiceMediaReceiveInfo receive_info; - EXPECT_EQ(true, channel_->GetSendStats(&send_info)); - EXPECT_EQ(true, channel_->GetReceiveStats( + EXPECT_EQ(true, send_channel_->GetStats(&send_info)); + EXPECT_EQ(true, receive_channel_->GetStats( &receive_info, /*get_and_clear_legacy_stats=*/true)); EXPECT_EQ(1u, send_info.senders.size()); EXPECT_EQ(0u, receive_info.receivers.size()); @@ -2574,8 +2590,8 @@ TEST_P(WebRtcVoiceEngineTestFake, GetStats) { EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0)); cricket::VoiceMediaSendInfo send_info; cricket::VoiceMediaReceiveInfo receive_info; - EXPECT_EQ(true, channel_->GetSendStats(&send_info)); - EXPECT_EQ(true, channel_->GetReceiveStats( + EXPECT_EQ(true, send_channel_->GetStats(&send_info)); + EXPECT_EQ(true, receive_channel_->GetStats( &receive_info, /*get_and_clear_legacy_stats=*/true)); EXPECT_EQ(1u, send_info.senders.size()); EXPECT_EQ(1u, receive_info.receivers.size()); @@ -2881,7 +2897,7 @@ TEST_P(WebRtcVoiceEngineTestFake, AddRecvStreamUnsupportedCodec) { cricket::AudioRecvParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); - EXPECT_TRUE(channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); EXPECT_TRUE(AddRecvStream(kSsrcX)); EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, (ContainerEq>( @@ -2898,8 +2914,8 @@ TEST_P(WebRtcVoiceEngineTestFake, StreamCleanup) { EXPECT_EQ(1u, call_.GetAudioSendStreams().size()); EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size()); - delete channel_; - channel_ = NULL; + send_channel_.reset(); + receive_channel_.reset(); EXPECT_EQ(0u, call_.GetAudioSendStreams().size()); EXPECT_EQ(0u, call_.GetAudioReceiveStreams().size()); } @@ -3045,13 +3061,12 @@ TEST_P(WebRtcVoiceEngineTestFake, InitRecordingOnSend) { EXPECT_CALL(*adm_, Recording()).WillOnce(Return(false)); EXPECT_CALL(*adm_, InitRecording()).Times(1); - std::unique_ptr channel( - engine_->CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, &call_, cricket::MediaConfig(), - cricket::AudioOptions(), webrtc::CryptoOptions(), - webrtc::AudioCodecPairId::Create())); + std::unique_ptr send_channel( + engine_->CreateSendChannel( + &call_, cricket::MediaConfig(), cricket::AudioOptions(), + webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create())); - channel->SetSend(true); + send_channel->SetSend(true); } TEST_P(WebRtcVoiceEngineTestFake, SkipInitRecordingOnSend) { @@ -3062,13 +3077,12 @@ TEST_P(WebRtcVoiceEngineTestFake, SkipInitRecordingOnSend) { cricket::AudioOptions options; options.init_recording_on_send = false; - std::unique_ptr channel( - engine_->CreateMediaChannel(cricket::MediaChannel::Role::kBoth, &call_, - cricket::MediaConfig(), options, - webrtc::CryptoOptions(), - webrtc::AudioCodecPairId::Create())); + std::unique_ptr send_channel( + engine_->CreateSendChannel(&call_, cricket::MediaConfig(), options, + webrtc::CryptoOptions(), + webrtc::AudioCodecPairId::Create())); - channel->SetSend(true); + send_channel->SetSend(true); } TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { @@ -3089,49 +3103,47 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { EXPECT_CALL(*adm_, Recording()).Times(2).WillRepeatedly(Return(false)); EXPECT_CALL(*adm_, InitRecording()).Times(2).WillRepeatedly(Return(0)); - std::unique_ptr channel1( - engine_->CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, &call_, cricket::MediaConfig(), - cricket::AudioOptions(), webrtc::CryptoOptions(), - webrtc::AudioCodecPairId::Create())); - std::unique_ptr channel2( - engine_->CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, &call_, cricket::MediaConfig(), - cricket::AudioOptions(), webrtc::CryptoOptions(), - webrtc::AudioCodecPairId::Create())); + std::unique_ptr send_channel1( + engine_->CreateSendChannel( + &call_, cricket::MediaConfig(), cricket::AudioOptions(), + webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create())); + std::unique_ptr send_channel2( + engine_->CreateSendChannel( + &call_, cricket::MediaConfig(), cricket::AudioOptions(), + webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create())); // Have to add a stream to make SetSend work. cricket::StreamParams stream1; stream1.ssrcs.push_back(1); - channel1->AddSendStream(stream1); + send_channel1->AddSendStream(stream1); cricket::StreamParams stream2; stream2.ssrcs.push_back(2); - channel2->AddSendStream(stream2); + send_channel2->AddSendStream(stream2); // AEC and AGC and NS cricket::AudioSendParameters parameters_options_all = send_parameters_; parameters_options_all.options.echo_cancellation = true; parameters_options_all.options.auto_gain_control = true; parameters_options_all.options.noise_suppression = true; - EXPECT_TRUE(channel1->SetSendParameters(parameters_options_all)); + EXPECT_TRUE(send_channel1->SetSendParameters(parameters_options_all)); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); VerifyGainControlEnabledCorrectly(); EXPECT_TRUE(apm_config_.noise_suppression.enabled); EXPECT_EQ(apm_config_.noise_suppression.level, kDefaultNsLevel); EXPECT_EQ(parameters_options_all.options, - SendImplFromPointer(channel1.get())->options()); - EXPECT_TRUE(channel2->SetSendParameters(parameters_options_all)); + SendImplFromPointer(send_channel1.get())->options()); + EXPECT_TRUE(send_channel2->SetSendParameters(parameters_options_all)); VerifyEchoCancellationSettings(/*enabled=*/true); VerifyGainControlEnabledCorrectly(); EXPECT_EQ(parameters_options_all.options, - SendImplFromPointer(channel2.get())->options()); + SendImplFromPointer(send_channel2.get())->options()); } // unset NS cricket::AudioSendParameters parameters_options_no_ns = send_parameters_; parameters_options_no_ns.options.noise_suppression = false; - EXPECT_TRUE(channel1->SetSendParameters(parameters_options_no_ns)); + EXPECT_TRUE(send_channel1->SetSendParameters(parameters_options_no_ns)); cricket::AudioOptions expected_options = parameters_options_all.options; if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); @@ -3141,13 +3153,14 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { expected_options.echo_cancellation = true; expected_options.auto_gain_control = true; expected_options.noise_suppression = false; - EXPECT_EQ(expected_options, SendImplFromPointer(channel1.get())->options()); + EXPECT_EQ(expected_options, + SendImplFromPointer(send_channel1.get())->options()); } // unset AGC cricket::AudioSendParameters parameters_options_no_agc = send_parameters_; parameters_options_no_agc.options.auto_gain_control = false; - EXPECT_TRUE(channel2->SetSendParameters(parameters_options_no_agc)); + EXPECT_TRUE(send_channel2->SetSendParameters(parameters_options_no_agc)); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); EXPECT_FALSE(apm_config_.gain_controller1.enabled); @@ -3156,10 +3169,11 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { expected_options.echo_cancellation = true; expected_options.auto_gain_control = false; expected_options.noise_suppression = true; - EXPECT_EQ(expected_options, SendImplFromPointer(channel2.get())->options()); + EXPECT_EQ(expected_options, + SendImplFromPointer(send_channel2.get())->options()); } - EXPECT_TRUE(channel_->SetSendParameters(parameters_options_all)); + EXPECT_TRUE(send_channel_->SetSendParameters(parameters_options_all)); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); VerifyGainControlEnabledCorrectly(); @@ -3167,7 +3181,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { EXPECT_EQ(apm_config_.noise_suppression.level, kDefaultNsLevel); } - channel1->SetSend(true); + send_channel1->SetSend(true); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); VerifyGainControlEnabledCorrectly(); @@ -3175,7 +3189,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { EXPECT_EQ(apm_config_.noise_suppression.level, kDefaultNsLevel); } - channel2->SetSend(true); + send_channel2->SetSend(true); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); EXPECT_FALSE(apm_config_.gain_controller1.enabled); @@ -3188,7 +3202,8 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { send_parameters_; parameters_options_no_agc_nor_ns.options.auto_gain_control = false; parameters_options_no_agc_nor_ns.options.noise_suppression = false; - EXPECT_TRUE(channel2->SetSendParameters(parameters_options_no_agc_nor_ns)); + EXPECT_TRUE( + send_channel2->SetSendParameters(parameters_options_no_agc_nor_ns)); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); EXPECT_FALSE(apm_config_.gain_controller1.enabled); @@ -3197,7 +3212,8 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { expected_options.echo_cancellation = true; expected_options.auto_gain_control = false; expected_options.noise_suppression = false; - EXPECT_EQ(expected_options, SendImplFromPointer(channel2.get())->options()); + EXPECT_EQ(expected_options, + SendImplFromPointer(send_channel2.get())->options()); } } @@ -3206,23 +3222,21 @@ TEST_P(WebRtcVoiceEngineTestFake, TestSetDscpOptions) { EXPECT_TRUE(SetupSendStream()); cricket::FakeNetworkInterface network_interface; cricket::MediaConfig config; - std::unique_ptr channel; + std::unique_ptr channel; webrtc::RtpParameters parameters; - channel.reset(engine_->CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, &call_, config, - cricket::AudioOptions(), webrtc::CryptoOptions(), - webrtc::AudioCodecPairId::Create())); + channel = engine_->CreateSendChannel(&call_, config, cricket::AudioOptions(), + webrtc::CryptoOptions(), + webrtc::AudioCodecPairId::Create()); channel->SetInterface(&network_interface); // Default value when DSCP is disabled should be DSCP_DEFAULT. EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface.dscp()); channel->SetInterface(nullptr); config.enable_dscp = true; - channel.reset(engine_->CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, &call_, config, - cricket::AudioOptions(), webrtc::CryptoOptions(), - webrtc::AudioCodecPairId::Create())); + channel = engine_->CreateSendChannel(&call_, config, cricket::AudioOptions(), + webrtc::CryptoOptions(), + webrtc::AudioCodecPairId::Create()); channel->SetInterface(&network_interface); EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface.dscp()); @@ -3251,10 +3265,9 @@ TEST_P(WebRtcVoiceEngineTestFake, TestSetDscpOptions) { // Verify that setting the option to false resets the // DiffServCodePoint. config.enable_dscp = false; - channel.reset(engine_->CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, &call_, config, - cricket::AudioOptions(), webrtc::CryptoOptions(), - webrtc::AudioCodecPairId::Create())); + channel = engine_->CreateSendChannel(&call_, config, cricket::AudioOptions(), + webrtc::CryptoOptions(), + webrtc::AudioCodecPairId::Create()); channel->SetInterface(&network_interface); // Default value when DSCP is disabled should be DSCP_DEFAULT. EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface.dscp()); @@ -3264,12 +3277,12 @@ TEST_P(WebRtcVoiceEngineTestFake, TestSetDscpOptions) { TEST_P(WebRtcVoiceEngineTestFake, SetOutputVolume) { EXPECT_TRUE(SetupChannel()); - EXPECT_FALSE(channel_->SetOutputVolume(kSsrcY, 0.5)); + EXPECT_FALSE(receive_channel_->SetOutputVolume(kSsrcY, 0.5)); cricket::StreamParams stream; stream.ssrcs.push_back(kSsrcY); EXPECT_TRUE(receive_channel_->AddRecvStream(stream)); EXPECT_DOUBLE_EQ(1, GetRecvStream(kSsrcY).gain()); - EXPECT_TRUE(channel_->SetOutputVolume(kSsrcY, 3)); + EXPECT_TRUE(receive_channel_->SetOutputVolume(kSsrcY, 3)); EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrcY).gain()); } @@ -3282,7 +3295,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOutputVolumeUnsignaledRecvStream) { // Should remember the volume "2" which will be set on new unsignaled streams, // and also set the gain to 2 on existing unsignaled streams. - EXPECT_TRUE(channel_->SetDefaultOutputVolume(2)); + EXPECT_TRUE(receive_channel_->SetDefaultOutputVolume(2)); EXPECT_DOUBLE_EQ(2, GetRecvStream(kSsrc1).gain()); // Spawn an unsignaled stream by sending a packet - gain should be 2. @@ -3293,14 +3306,14 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOutputVolumeUnsignaledRecvStream) { EXPECT_DOUBLE_EQ(2, GetRecvStream(kSsrcX).gain()); // Setting gain for all unsignaled streams. - EXPECT_TRUE(channel_->SetDefaultOutputVolume(3)); + EXPECT_TRUE(receive_channel_->SetDefaultOutputVolume(3)); if (kMaxUnsignaledRecvStreams > 1) { EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrc1).gain()); } EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrcX).gain()); // Setting gain on an individual stream affects only that. - EXPECT_TRUE(channel_->SetOutputVolume(kSsrcX, 4)); + EXPECT_TRUE(receive_channel_->SetOutputVolume(kSsrcX, 4)); if (kMaxUnsignaledRecvStreams > 1) { EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrc1).gain()); } @@ -3431,7 +3444,7 @@ TEST_P(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) { GetDefaultEnabledRtpHeaderExtensions(*engine_); cricket::AudioRecvParameters recv_parameters; recv_parameters.extensions = header_extensions; - channel_->SetRecvParameters(recv_parameters); + receive_channel_->SetRecvParameters(recv_parameters); EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size()); for (uint32_t ssrc : ssrcs) { EXPECT_THAT( @@ -3440,7 +3453,7 @@ TEST_P(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) { } // Disable receive extensions. - channel_->SetRecvParameters(cricket::AudioRecvParameters()); + receive_channel_->SetRecvParameters(cricket::AudioRecvParameters()); for (uint32_t ssrc : ssrcs) { EXPECT_THAT( receive_channel_->GetRtpReceiveParameters(ssrc).header_extensions, @@ -3510,16 +3523,16 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRawAudioSink) { std::unique_ptr fake_sink_2(new FakeAudioSink()); // Setting the sink before a recv stream exists should do nothing. - channel_->SetRawAudioSink(kSsrcX, std::move(fake_sink_1)); + receive_channel_->SetRawAudioSink(kSsrcX, std::move(fake_sink_1)); EXPECT_TRUE(AddRecvStream(kSsrcX)); EXPECT_EQ(nullptr, GetRecvStream(kSsrcX).sink()); // Now try actually setting the sink. - channel_->SetRawAudioSink(kSsrcX, std::move(fake_sink_2)); + receive_channel_->SetRawAudioSink(kSsrcX, std::move(fake_sink_2)); EXPECT_NE(nullptr, GetRecvStream(kSsrcX).sink()); // Now try resetting it. - channel_->SetRawAudioSink(kSsrcX, nullptr); + receive_channel_->SetRawAudioSink(kSsrcX, nullptr); EXPECT_EQ(nullptr, GetRecvStream(kSsrcX).sink()); } @@ -3531,7 +3544,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRawAudioSinkUnsignaledRecvStream) { std::unique_ptr fake_sink_4(new FakeAudioSink()); // Should be able to set a default sink even when no stream exists. - channel_->SetDefaultRawAudioSink(std::move(fake_sink_1)); + receive_channel_->SetDefaultRawAudioSink(std::move(fake_sink_1)); // Spawn an unsignaled stream by sending a packet - it should be assigned the // default sink. @@ -3539,11 +3552,11 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRawAudioSinkUnsignaledRecvStream) { EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink()); // Try resetting the default sink. - channel_->SetDefaultRawAudioSink(nullptr); + receive_channel_->SetDefaultRawAudioSink(nullptr); EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink()); // Try setting the default sink while the default stream exists. - channel_->SetDefaultRawAudioSink(std::move(fake_sink_2)); + receive_channel_->SetDefaultRawAudioSink(std::move(fake_sink_2)); EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink()); // If we remove and add a default stream, it should get the same sink. @@ -3563,21 +3576,21 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRawAudioSinkUnsignaledRecvStream) { EXPECT_NE(nullptr, GetRecvStream(kSsrcX).sink()); // Reset the default sink - the second unsignaled stream should lose it. - channel_->SetDefaultRawAudioSink(nullptr); + receive_channel_->SetDefaultRawAudioSink(nullptr); if (kMaxUnsignaledRecvStreams > 1) { EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink()); } EXPECT_EQ(nullptr, GetRecvStream(kSsrcX).sink()); // Try setting the default sink while two streams exists. - channel_->SetDefaultRawAudioSink(std::move(fake_sink_3)); + receive_channel_->SetDefaultRawAudioSink(std::move(fake_sink_3)); if (kMaxUnsignaledRecvStreams > 1) { EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink()); } EXPECT_NE(nullptr, GetRecvStream(kSsrcX).sink()); // Try setting the sink for the first unsignaled stream using its known SSRC. - channel_->SetRawAudioSink(kSsrc1, std::move(fake_sink_4)); + receive_channel_->SetRawAudioSink(kSsrc1, std::move(fake_sink_4)); if (kMaxUnsignaledRecvStreams > 1) { EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink()); } @@ -3613,7 +3626,7 @@ TEST_P(WebRtcVoiceEngineTestFake, OnReadyToSendSignalsNetworkState) { // Test that playout is still started after changing parameters TEST_P(WebRtcVoiceEngineTestFake, PreservePlayoutWhenRecreateRecvStream) { SetupRecvStream(); - channel_->SetPlayout(true); + receive_channel_->SetPlayout(true); EXPECT_TRUE(GetRecvStream(kSsrcX).started()); // Changing RTP header extensions will recreate the @@ -3621,7 +3634,7 @@ TEST_P(WebRtcVoiceEngineTestFake, PreservePlayoutWhenRecreateRecvStream) { cricket::AudioRecvParameters parameters; parameters.extensions.push_back( webrtc::RtpExtension(webrtc::RtpExtension::kAudioLevelUri, 12)); - channel_->SetRecvParameters(parameters); + receive_channel_->SetRecvParameters(parameters); EXPECT_TRUE(GetRecvStream(kSsrcX).started()); } @@ -3661,12 +3674,16 @@ TEST(WebRtcVoiceEngineTest, StartupShutdown) { call_config.trials = &field_trials; call_config.task_queue_factory = task_queue_factory.get(); auto call = absl::WrapUnique(webrtc::Call::Create(call_config)); - cricket::VoiceMediaChannel* channel = engine.CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, call.get(), cricket::MediaConfig(), - cricket::AudioOptions(), webrtc::CryptoOptions(), - webrtc::AudioCodecPairId::Create()); - EXPECT_TRUE(channel != nullptr); - delete channel; + std::unique_ptr send_channel = + engine.CreateSendChannel( + call.get(), cricket::MediaConfig(), cricket::AudioOptions(), + webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); + EXPECT_TRUE(send_channel); + std::unique_ptr + receive_channel = engine.CreateReceiveChannel( + call.get(), cricket::MediaConfig(), cricket::AudioOptions(), + webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); + EXPECT_TRUE(receive_channel); } } @@ -3693,12 +3710,16 @@ TEST(WebRtcVoiceEngineTest, StartupShutdownWithExternalADM) { call_config.trials = &field_trials; call_config.task_queue_factory = task_queue_factory.get(); auto call = absl::WrapUnique(webrtc::Call::Create(call_config)); - cricket::VoiceMediaChannel* channel = engine.CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, call.get(), - cricket::MediaConfig(), cricket::AudioOptions(), - webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); - EXPECT_TRUE(channel != nullptr); - delete channel; + std::unique_ptr send_channel = + engine.CreateSendChannel( + call.get(), cricket::MediaConfig(), cricket::AudioOptions(), + webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); + EXPECT_TRUE(send_channel); + std::unique_ptr + receive_channel = engine.CreateReceiveChannel( + call.get(), cricket::MediaConfig(), cricket::AudioOptions(), + webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); + EXPECT_TRUE(receive_channel); } // The engine/channel should have dropped their references. EXPECT_EQ(adm.release()->Release(), @@ -3780,24 +3801,19 @@ TEST(WebRtcVoiceEngineTest, Has32Channels) { call_config.task_queue_factory = task_queue_factory.get(); auto call = absl::WrapUnique(webrtc::Call::Create(call_config)); - cricket::VoiceMediaChannel* channels[32]; - size_t num_channels = 0; - while (num_channels < arraysize(channels)) { - cricket::VoiceMediaChannel* channel = engine.CreateMediaChannel( - cricket::MediaChannel::Role::kBoth, call.get(), - cricket::MediaConfig(), cricket::AudioOptions(), - webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); + std::vector> + channels; + while (channels.size() < 32) { + std::unique_ptr channel = + engine.CreateSendChannel( + call.get(), cricket::MediaConfig(), cricket::AudioOptions(), + webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); if (!channel) break; - channels[num_channels++] = channel; + channels.emplace_back(std::move(channel)); } - size_t expected = arraysize(channels); - EXPECT_EQ(expected, num_channels); - - while (num_channels > 0) { - delete channels[--num_channels]; - } + EXPECT_EQ(channels.size(), 32u); } }