diff --git a/media/base/fake_media_engine.cc b/media/base/fake_media_engine.cc index daf62894da..5a1da3326e 100644 --- a/media/base/fake_media_engine.cc +++ b/media/base/fake_media_engine.cc @@ -76,7 +76,7 @@ const AudioOptions& FakeVoiceMediaReceiveChannel::options() const { int FakeVoiceMediaReceiveChannel::max_bps() const { return max_bps_; } -bool FakeVoiceMediaReceiveChannel::SetRecvParameters( +bool FakeVoiceMediaReceiveChannel::SetReceiverParameters( const AudioReceiverParameters& params) { set_recv_rtcp_parameters(params.rtcp); return (SetRecvCodecs(params.codecs) && @@ -235,7 +235,7 @@ const AudioOptions& FakeVoiceMediaSendChannel::options() const { int FakeVoiceMediaSendChannel::max_bps() const { return max_bps_; } -bool FakeVoiceMediaSendChannel::SetSendParameters( +bool FakeVoiceMediaSendChannel::SetSenderParameters( const AudioSenderParameter& params) { set_send_rtcp_parameters(params.rtcp); SetExtmapAllowMixed(params.extmap_allow_mixed); @@ -355,7 +355,7 @@ const VideoOptions& FakeVideoMediaSendChannel::options() const { int FakeVideoMediaSendChannel::max_bps() const { return max_bps_; } -bool FakeVideoMediaSendChannel::SetSendParameters( +bool FakeVideoMediaSendChannel::SetSenderParameters( const VideoSenderParameters& params) { set_send_rtcp_parameters(params.rtcp); SetExtmapAllowMixed(params.extmap_allow_mixed); @@ -441,7 +441,7 @@ FakeVideoMediaReceiveChannel::sinks() const { int FakeVideoMediaReceiveChannel::max_bps() const { return max_bps_; } -bool FakeVideoMediaReceiveChannel::SetRecvParameters( +bool FakeVideoMediaReceiveChannel::SetReceiverParameters( const VideoReceiverParameters& params) { set_recv_rtcp_parameters(params.rtcp); return (SetRecvCodecs(params.codecs) && diff --git a/media/base/fake_media_engine.h b/media/base/fake_media_engine.h index 8525d0bfcf..51828c3535 100644 --- a/media/base/fake_media_engine.h +++ b/media/base/fake_media_engine.h @@ -118,7 +118,7 @@ class RtpReceiveChannelHelper : public Base, public MediaChannelUtil { return RemoveStreamBySsrc(&receive_streams_, ssrc); } - webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override { + webrtc::RtpParameters GetRtpReceiverParameters(uint32_t ssrc) const override { auto parameters_iterator = rtp_receive_parameters_.find(ssrc); if (parameters_iterator != rtp_receive_parameters_.end()) { return parameters_iterator->second; @@ -469,7 +469,7 @@ class FakeVoiceMediaReceiveChannel return cricket::MEDIA_TYPE_AUDIO; } - bool SetRecvParameters(const AudioReceiverParameters& params) override; + bool SetReceiverParameters(const AudioReceiverParameters& params) override; void SetPlayout(bool playout) override; bool AddRecvStream(const StreamParams& sp) override; @@ -559,7 +559,7 @@ class FakeVoiceMediaSendChannel return cricket::MEDIA_TYPE_AUDIO; } - bool SetSendParameters(const AudioSenderParameter& params) override; + bool SetSenderParameters(const AudioSenderParameter& params) override; void SetSend(bool send) override; bool SetAudioSend(uint32_t ssrc, bool enable, @@ -644,7 +644,7 @@ class FakeVideoMediaReceiveChannel const std::map*>& sinks() const; int max_bps() const; - bool SetRecvParameters(const VideoReceiverParameters& params) override; + bool SetReceiverParameters(const VideoReceiverParameters& params) override; bool SetSink(uint32_t ssrc, rtc::VideoSinkInterface* sink) override; @@ -717,7 +717,7 @@ class FakeVideoMediaSendChannel const std::map*>& sinks() const; int max_bps() const; - bool SetSendParameters(const VideoSenderParameters& params) override; + bool SetSenderParameters(const VideoSenderParameters& params) override; absl::optional GetSendCodec() const override; diff --git a/media/base/media_channel.h b/media/base/media_channel.h index 01aa2b251c..2282b57d7e 100644 --- a/media/base/media_channel.h +++ b/media/base/media_channel.h @@ -872,7 +872,7 @@ struct AudioReceiverParameters : MediaChannelParameters {}; class VoiceMediaSendChannelInterface : public MediaSendChannelInterface { public: - virtual bool SetSendParameters(const AudioSenderParameter& params) = 0; + virtual bool SetSenderParameters(const AudioSenderParameter& params) = 0; // Starts or stops sending (and potentially capture) of local audio. virtual void SetSend(bool send) = 0; // Configure stream for sending. @@ -894,9 +894,9 @@ class VoiceMediaSendChannelInterface : public MediaSendChannelInterface { class VoiceMediaReceiveChannelInterface : public MediaReceiveChannelInterface { public: - virtual bool SetRecvParameters(const AudioReceiverParameters& params) = 0; + virtual bool SetReceiverParameters(const AudioReceiverParameters& params) = 0; // Get the receive parameters for the incoming stream identified by `ssrc`. - virtual webrtc::RtpParameters GetRtpReceiveParameters( + virtual webrtc::RtpParameters GetRtpReceiverParameters( uint32_t ssrc) const = 0; virtual std::vector GetSources(uint32_t ssrc) const = 0; // Retrieve the receive parameters for the default receive @@ -937,7 +937,7 @@ struct VideoReceiverParameters : MediaChannelParameters {}; class VideoMediaSendChannelInterface : public MediaSendChannelInterface { public: - virtual bool SetSendParameters(const VideoSenderParameters& params) = 0; + virtual bool SetSenderParameters(const VideoSenderParameters& params) = 0; // Starts or stops transmission (and potentially capture) of local video. virtual bool SetSend(bool send) = 0; // Configure stream for sending and register a source. @@ -969,9 +969,9 @@ class VideoMediaSendChannelInterface : public MediaSendChannelInterface { class VideoMediaReceiveChannelInterface : public MediaReceiveChannelInterface { public: - virtual bool SetRecvParameters(const VideoReceiverParameters& params) = 0; + virtual bool SetReceiverParameters(const VideoReceiverParameters& params) = 0; // Get the receive parameters for the incoming stream identified by `ssrc`. - virtual webrtc::RtpParameters GetRtpReceiveParameters( + virtual webrtc::RtpParameters GetRtpReceiverParameters( uint32_t ssrc) const = 0; // Starts or stops decoding of remote video. virtual void SetReceive(bool receive) = 0; diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc index 056478c384..3478e2fc17 100644 --- a/media/engine/webrtc_video_engine.cc +++ b/media/engine/webrtc_video_engine.cc @@ -666,8 +666,8 @@ bool NonFlexfecReceiveCodecsHaveChanged(std::vector before, absl::c_sort(after, comparison); // Changes in FlexFEC payload type are handled separately in - // WebRtcVideoReceiveChannel::GetChangedRecvParameters, so disregard FlexFEC - // in the comparison here. + // WebRtcVideoReceiveChannel::GetChangedReceiverParameters, so disregard + // FlexFEC in the comparison here. return !absl::c_equal(before, after, VideoCodecSettings::EqualsDisregardingFlexfec); } @@ -971,9 +971,9 @@ std::vector WebRtcVideoSendChannel::SelectSendVideoCodecs( return encoders; } -bool WebRtcVideoSendChannel::GetChangedSendParameters( +bool WebRtcVideoSendChannel::GetChangedSenderParameters( const VideoSenderParameters& params, - ChangedSendParameters* changed_params) const { + ChangedSenderParameters* changed_params) const { if (!ValidateCodecFormats(params.codecs) || !ValidateRtpExtensions(params.extensions, send_rtp_extensions_)) { return false; @@ -1071,13 +1071,13 @@ bool WebRtcVideoSendChannel::GetChangedSendParameters( return true; } -bool WebRtcVideoSendChannel::SetSendParameters( +bool WebRtcVideoSendChannel::SetSenderParameters( const VideoSenderParameters& params) { RTC_DCHECK_RUN_ON(&thread_checker_); - TRACE_EVENT0("webrtc", "WebRtcVideoSendChannel::SetSendParameters"); - RTC_LOG(LS_INFO) << "SetSendParameters: " << params.ToString(); - ChangedSendParameters changed_params; - if (!GetChangedSendParameters(params, &changed_params)) { + TRACE_EVENT0("webrtc", "WebRtcVideoSendChannel::SetSenderParameters"); + RTC_LOG(LS_INFO) << "SetSenderParameters: " << params.ToString(); + ChangedSenderParameters changed_params; + if (!GetChangedSenderParameters(params, &changed_params)) { return false; } @@ -1103,7 +1103,7 @@ void WebRtcVideoSendChannel::RequestEncoderFallback() { return; } - ChangedSendParameters params; + ChangedSenderParameters params; params.negotiated_codecs = negotiated_codecs_; params.negotiated_codecs->erase(params.negotiated_codecs->begin()); params.send_codec = params.negotiated_codecs->front(); @@ -1136,7 +1136,7 @@ void WebRtcVideoSendChannel::RequestEncoderSwitch( return; } - ChangedSendParameters params; + ChangedSenderParameters params; params.send_codec = new_codec_setting; ApplyChangedParams(params); return; @@ -1153,7 +1153,7 @@ void WebRtcVideoSendChannel::RequestEncoderSwitch( } bool WebRtcVideoSendChannel::ApplyChangedParams( - const ChangedSendParameters& changed_params) { + const ChangedSenderParameters& changed_params) { RTC_DCHECK_RUN_ON(&thread_checker_); if (changed_params.negotiated_codecs) negotiated_codecs_ = *changed_params.negotiated_codecs; @@ -1208,7 +1208,7 @@ bool WebRtcVideoSendChannel::ApplyChangedParams( } for (auto& kv : send_streams_) { - kv.second->SetSendParameters(changed_params); + kv.second->SetSenderParameters(changed_params); } if (changed_params.send_codec || changed_params.rtcp_mode) { if (send_codec_changed_callback_) { @@ -1304,7 +1304,7 @@ webrtc::RTCError WebRtcVideoSendChannel::SetRtpSendParameters( }); RTC_CHECK(matched_codec != negotiated_codecs_.end()); - ChangedSendParameters params; + ChangedSenderParameters params; params.send_codec = *matched_codec; ApplyChangedParams(params); } @@ -1841,8 +1841,8 @@ void WebRtcVideoSendChannel::WebRtcVideoSendStream::SetCodec( RecreateWebRtcStream(); } -void WebRtcVideoSendChannel::WebRtcVideoSendStream::SetSendParameters( - const ChangedSendParameters& params) { +void WebRtcVideoSendChannel::WebRtcVideoSendStream::SetSenderParameters( + const ChangedSenderParameters& params) { RTC_DCHECK_RUN_ON(&thread_checker_); // `recreate_stream` means construction-time parameters have changed and the // sending stream needs to be reset with the new config. @@ -1884,7 +1884,7 @@ void WebRtcVideoSendChannel::WebRtcVideoSendStream::SetSendParameters( } if (recreate_stream) { RTC_LOG(LS_INFO) - << "RecreateWebRtcStream (send) because of SetSendParameters"; + << "RecreateWebRtcStream (send) because of SetSenderParameters"; RecreateWebRtcStream(); } } @@ -2571,7 +2571,7 @@ void WebRtcVideoReceiveChannel::SetReceiverFeedbackParameters( // Note: There is no place in config to store rtx_time. } -webrtc::RtpParameters WebRtcVideoReceiveChannel::GetRtpReceiveParameters( +webrtc::RtpParameters WebRtcVideoReceiveChannel::GetRtpReceiverParameters( uint32_t ssrc) const { RTC_DCHECK_RUN_ON(&thread_checker_); webrtc::RtpParameters rtp_params; @@ -2614,9 +2614,9 @@ WebRtcVideoReceiveChannel::GetDefaultRtpReceiveParameters() const { return rtp_params; } -bool WebRtcVideoReceiveChannel::GetChangedRecvParameters( +bool WebRtcVideoReceiveChannel::GetChangedReceiverParameters( const VideoReceiverParameters& params, - ChangedRecvParameters* changed_params) const { + ChangedReceiverParameters* changed_params) const { if (!ValidateCodecFormats(params.codecs) || !ValidateRtpExtensions(params.extensions, recv_rtp_extensions_)) { return false; @@ -2627,7 +2627,7 @@ bool WebRtcVideoReceiveChannel::GetChangedRecvParameters( MapCodecs(params.codecs); if (mapped_codecs.empty()) { RTC_LOG(LS_ERROR) - << "GetChangedRecvParameters called without any video codecs."; + << "GetChangedReceiverParameters called without any video codecs."; return false; } @@ -2639,9 +2639,9 @@ bool WebRtcVideoReceiveChannel::GetChangedRecvParameters( /*include_rtx=*/true, call_->trials()); for (const VideoCodecSettings& mapped_codec : mapped_codecs) { if (!FindMatchingCodec(local_supported_codecs, mapped_codec.codec)) { - RTC_LOG(LS_ERROR) - << "GetChangedRecvParameters called with unsupported video codec: " - << mapped_codec.codec.ToString(); + RTC_LOG(LS_ERROR) << "GetChangedReceiverParameters called with " + "unsupported video codec: " + << mapped_codec.codec.ToString(); return false; } } @@ -2669,13 +2669,13 @@ bool WebRtcVideoReceiveChannel::GetChangedRecvParameters( return true; } -bool WebRtcVideoReceiveChannel::SetRecvParameters( +bool WebRtcVideoReceiveChannel::SetReceiverParameters( const VideoReceiverParameters& params) { RTC_DCHECK_RUN_ON(&thread_checker_); - TRACE_EVENT0("webrtc", "WebRtcVideoReceiveChannel::SetRecvParameters"); - RTC_LOG(LS_INFO) << "SetRecvParameters: " << params.ToString(); - ChangedRecvParameters changed_params; - if (!GetChangedRecvParameters(params, &changed_params)) { + TRACE_EVENT0("webrtc", "WebRtcVideoReceiveChannel::SetReceiverParameters"); + RTC_LOG(LS_INFO) << "SetReceiverParameters: " << params.ToString(); + ChangedReceiverParameters changed_params; + if (!GetChangedReceiverParameters(params, &changed_params)) { return false; } if (changed_params.flexfec_payload_type) { @@ -2698,7 +2698,7 @@ bool WebRtcVideoReceiveChannel::SetRecvParameters( } for (auto& kv : receive_streams_) { - kv.second->SetRecvParameters(changed_params); + kv.second->SetReceiverParameters(changed_params); } recv_params_ = params; return true; @@ -3428,8 +3428,8 @@ void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::SetFlexFecPayload( } } -void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::SetRecvParameters( - const ChangedRecvParameters& params) { +void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::SetReceiverParameters( + const ChangedReceiverParameters& params) { RTC_DCHECK(stream_); bool video_needs_recreation = false; if (params.codec_settings) { diff --git a/media/engine/webrtc_video_engine.h b/media/engine/webrtc_video_engine.h index 4ad6a3ac70..11f1b99ac2 100644 --- a/media/engine/webrtc_video_engine.h +++ b/media/engine/webrtc_video_engine.h @@ -190,7 +190,7 @@ class WebRtcVideoSendChannel : public MediaChannelUtil, // Common functions between sender and receiver void SetInterface(MediaChannelNetworkInterface* iface) override; // VideoMediaSendChannelInterface implementation - bool SetSendParameters(const VideoSenderParameters& params) override; + bool SetSenderParameters(const VideoSenderParameters& params) override; webrtc::RTCError SetRtpSendParameters( uint32_t ssrc, const webrtc::RtpParameters& parameters, @@ -296,7 +296,7 @@ class WebRtcVideoSendChannel : public MediaChannelUtil, } private: - struct ChangedSendParameters { + struct ChangedSenderParameters { // These optionals are unset if not changed. absl::optional send_codec; absl::optional> negotiated_codecs; @@ -308,10 +308,10 @@ class WebRtcVideoSendChannel : public MediaChannelUtil, absl::optional rtcp_mode; }; - bool GetChangedSendParameters(const VideoSenderParameters& params, - ChangedSendParameters* changed_params) const + bool GetChangedSenderParameters(const VideoSenderParameters& params, + ChangedSenderParameters* changed_params) const RTC_EXCLUSIVE_LOCKS_REQUIRED(thread_checker_); - bool ApplyChangedParams(const ChangedSendParameters& changed_params); + bool ApplyChangedParams(const ChangedSenderParameters& changed_params); bool ValidateSendSsrcAvailability(const StreamParams& sp) const RTC_EXCLUSIVE_LOCKS_REQUIRED(thread_checker_); @@ -339,7 +339,7 @@ class WebRtcVideoSendChannel : public MediaChannelUtil, const VideoSenderParameters& send_params); ~WebRtcVideoSendStream(); - void SetSendParameters(const ChangedSendParameters& send_params); + void SetSenderParameters(const ChangedSenderParameters& send_params); webrtc::RTCError SetRtpParameters(const webrtc::RtpParameters& parameters, webrtc::SetParametersCallback callback); webrtc::RtpParameters GetRtpParameters() const; @@ -525,7 +525,7 @@ class WebRtcVideoSendChannel : public MediaChannelUtil, std::vector recv_rtp_extensions_ RTC_GUARDED_BY(thread_checker_); // See reason for keeping track of the FlexFEC payload type separately in - // comment in WebRtcVideoChannel::ChangedRecvParameters. + // comment in WebRtcVideoChannel::ChangedReceiverParameters. int recv_flexfec_payload_type_ RTC_GUARDED_BY(thread_checker_); webrtc::BitrateConstraints bitrate_config_ RTC_GUARDED_BY(thread_checker_); // TODO(deadbeef): Don't duplicate information between @@ -590,8 +590,8 @@ class WebRtcVideoReceiveChannel : public MediaChannelUtil, // Common functions between sender and receiver void SetInterface(MediaChannelNetworkInterface* iface) override; // VideoMediaReceiveChannelInterface implementation - bool SetRecvParameters(const VideoReceiverParameters& params) override; - webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override; + bool SetReceiverParameters(const VideoReceiverParameters& params) override; + webrtc::RtpParameters GetRtpReceiverParameters(uint32_t ssrc) const override; webrtc::RtpParameters GetDefaultRtpReceiveParameters() const override; void SetReceive(bool receive) override; bool AddRecvStream(const StreamParams& sp) override; @@ -645,7 +645,7 @@ class WebRtcVideoReceiveChannel : public MediaChannelUtil, private: class WebRtcVideoReceiveStream; - struct ChangedRecvParameters { + struct ChangedReceiverParameters { // These optionals are unset if not changed. absl::optional> codec_settings; absl::optional> rtp_header_extensions; @@ -719,7 +719,7 @@ class WebRtcVideoReceiveChannel : public MediaChannelUtil, bool nack_enabled, webrtc::RtcpMode rtcp_mode, absl::optional rtx_time); - void SetRecvParameters(const ChangedRecvParameters& recv_params); + void SetReceiverParameters(const ChangedReceiverParameters& recv_params); void OnFrame(const webrtc::VideoFrame& frame) override; bool IsDefaultStream() const; @@ -786,9 +786,9 @@ class WebRtcVideoReceiveChannel : public MediaChannelUtil, RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker thread_checker_; bool receiving_ RTC_GUARDED_BY(&thread_checker_); }; - bool GetChangedRecvParameters(const VideoReceiverParameters& params, - ChangedRecvParameters* changed_params) const - RTC_EXCLUSIVE_LOCKS_REQUIRED(thread_checker_); + bool GetChangedReceiverParameters(const VideoReceiverParameters& params, + ChangedReceiverParameters* changed_params) + const RTC_EXCLUSIVE_LOCKS_REQUIRED(thread_checker_); std::map receive_streams_ RTC_GUARDED_BY(thread_checker_); @@ -857,7 +857,7 @@ class WebRtcVideoReceiveChannel : public MediaChannelUtil, std::vector recv_rtp_extensions_ RTC_GUARDED_BY(thread_checker_); // See reason for keeping track of the FlexFEC payload type separately in - // comment in WebRtcVideoChannel::ChangedRecvParameters. + // comment in WebRtcVideoChannel::ChangedReceiverParameters. int recv_flexfec_payload_type_ RTC_GUARDED_BY(thread_checker_); webrtc::BitrateConstraints bitrate_config_ RTC_GUARDED_BY(thread_checker_); // TODO(deadbeef): Don't duplicate information between diff --git a/media/engine/webrtc_video_engine_unittest.cc b/media/engine/webrtc_video_engine_unittest.cc index d228ab4c9c..4262aa03db 100644 --- a/media/engine/webrtc_video_engine_unittest.cc +++ b/media/engine/webrtc_video_engine_unittest.cc @@ -531,7 +531,7 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeCapturer) { parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.extensions.push_back( RtpExtension(RtpExtension::kVideoRotationUri, id)); - EXPECT_TRUE(send_channel->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel->SetSenderParameters(parameters)); EXPECT_CALL( video_source, @@ -548,7 +548,7 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeCapturer) { video_source, AddOrUpdateSink(_, Field(&rtc::VideoSinkWants::rotation_applied, true))); - EXPECT_TRUE(send_channel->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel->SetSenderParameters(parameters)); } TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeAddSendStream) { @@ -565,7 +565,7 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeAddSendStream) { parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.extensions.push_back( RtpExtension(RtpExtension::kVideoRotationUri, id)); - EXPECT_TRUE(send_channel->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel->SetSenderParameters(parameters)); EXPECT_TRUE(send_channel->AddSendStream(StreamParams::CreateLegacy(kSsrc))); // Set source. @@ -606,7 +606,7 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionAfterCapturer) { EXPECT_CALL( video_source, AddOrUpdateSink(_, Field(&rtc::VideoSinkWants::rotation_applied, false))); - EXPECT_TRUE(send_channel->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel->SetSenderParameters(parameters)); // Verify capturer has turned off applying rotation. ::testing::Mock::VerifyAndClear(&video_source); @@ -616,7 +616,7 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionAfterCapturer) { EXPECT_CALL( video_source, AddOrUpdateSink(_, Field(&rtc::VideoSinkWants::rotation_applied, true))); - EXPECT_TRUE(send_channel->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel->SetSenderParameters(parameters)); } TEST_F(WebRtcVideoEngineTest, SetSendFailsBeforeSettingCodecs) { @@ -682,7 +682,7 @@ TEST_F(WebRtcVideoEngineTest, UseFactoryForVp8WhenSupported) { // (expecting a no-op). cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(send_channel->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel->SetSenderParameters(parameters)); EXPECT_EQ(num_created_encoders, encoder_factory_->GetNumCreatedEncoders()); // Remove stream previously added to free the external encoder instance. @@ -876,7 +876,7 @@ WebRtcVideoEngineTest::SetSendParamsWithAllSupportedCodecs() { } } - EXPECT_TRUE(channel->SetSendParameters(parameters)); + EXPECT_TRUE(channel->SetSenderParameters(parameters)); return channel; } @@ -889,7 +889,7 @@ WebRtcVideoEngineTest::SetRecvParamsWithSupportedCodecs( VideoOptions(), webrtc::CryptoOptions()); cricket::VideoReceiverParameters parameters; parameters.codecs = codecs; - EXPECT_TRUE(channel->SetRecvParameters(parameters)); + EXPECT_TRUE(channel->SetReceiverParameters(parameters)); return channel; } @@ -947,7 +947,7 @@ TEST_F(WebRtcVideoEngineTest, SendsFeedbackAfterUnsignaledRtxPacket) { const int kTransportSeqExtensionId = 1; parameters.extensions.push_back(RtpExtension( RtpExtension::kTransportSequenceNumberUri, kTransportSeqExtensionId)); - ASSERT_TRUE(receive_channel->SetRecvParameters(parameters)); + ASSERT_TRUE(receive_channel->SetReceiverParameters(parameters)); send_channel->SetInterface(&network); receive_channel->SetInterface(&network); send_channel->OnReadyToSend(true); @@ -986,7 +986,7 @@ TEST_F(WebRtcVideoEngineTest, UpdatesUnsignaledRtxSsrcAndRecoversPayload) { VideoOptions(), webrtc::CryptoOptions()); cricket::VideoReceiverParameters parameters; parameters.codecs = supported_codecs; - ASSERT_TRUE(receive_channel->SetRecvParameters(parameters)); + ASSERT_TRUE(receive_channel->SetReceiverParameters(parameters)); receive_channel->SetReceive(true); // Receive a normal payload packet. It is not a complete frame since the @@ -1069,7 +1069,7 @@ TEST_F(WebRtcVideoEngineTest, ChannelWithH264CanChangeToVp8) { video_bitrate_allocator_factory_.get()); cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("H264")); - EXPECT_TRUE(send_channel->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel->SetSenderParameters(parameters)); EXPECT_TRUE( send_channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); @@ -1082,7 +1082,7 @@ TEST_F(WebRtcVideoEngineTest, ChannelWithH264CanChangeToVp8) { cricket::VideoSenderParameters new_parameters; new_parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(send_channel->SetSendParameters(new_parameters)); + EXPECT_TRUE(send_channel->SetSenderParameters(new_parameters)); // Sending one frame will switch encoder. frame_forwarder.IncomingCapturedFrame(frame_source.GetFrame()); @@ -1102,7 +1102,7 @@ TEST_F(WebRtcVideoEngineTest, video_bitrate_allocator_factory_.get()); cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(send_channel->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel->SetSenderParameters(parameters)); std::vector ssrcs = MAKE_VECTOR(kSsrcs3); @@ -1142,7 +1142,7 @@ TEST_F(WebRtcVideoEngineTest, video_bitrate_allocator_factory_.get()); cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("H264")); - EXPECT_TRUE(send_channel->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel->SetSenderParameters(parameters)); EXPECT_TRUE( send_channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); @@ -1175,7 +1175,7 @@ TEST_F(WebRtcVideoEngineTest, SimulcastEnabledForH264) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("H264")); - EXPECT_TRUE(send_channel->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel->SetSenderParameters(parameters)); const std::vector ssrcs = MAKE_VECTOR(kSsrcs3); EXPECT_TRUE(send_channel->AddSendStream( @@ -1289,7 +1289,7 @@ TEST_F(WebRtcVideoEngineTest, RegisterDecodersIfSupported) { EXPECT_EQ(0u, decoder_factory_->decoders().size()); // Setting codecs of the same type should not reallocate the decoder. - EXPECT_TRUE(receive_channel->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel->SetReceiverParameters(parameters)); EXPECT_EQ(0, decoder_factory_->GetNumCreatedDecoders()); // Remove stream previously added to free the external decoder instance. @@ -1454,7 +1454,7 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) { cricket::VideoSenderParameters send_parameters; send_parameters.codecs.push_back(engine_codecs.at(0)); - EXPECT_TRUE(send_channel->SetSendParameters(send_parameters)); + EXPECT_TRUE(send_channel->SetSenderParameters(send_parameters)); send_channel->OnReadyToSend(true); EXPECT_TRUE( send_channel->AddSendStream(StreamParams::CreateLegacy(send_ssrc))); @@ -1477,7 +1477,7 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) { cricket::VideoReceiverParameters recv_parameters; recv_parameters.codecs.push_back(engine_codecs.at(0)); - EXPECT_TRUE(receive_channel->SetRecvParameters(recv_parameters)); + EXPECT_TRUE(receive_channel->SetReceiverParameters(recv_parameters)); EXPECT_TRUE(receive_channel->AddRecvStream( cricket::StreamParams::CreateLegacy(recv_ssrc))); @@ -1501,7 +1501,7 @@ TEST_F(WebRtcVideoEngineTest, DISABLED_RecreatesEncoderOnContentTypeChange) { parameters.codecs.push_back(codec); send_channel->OnReadyToSend(true); send_channel->SetSend(true); - ASSERT_TRUE(send_channel->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel->SetSenderParameters(parameters)); webrtc::test::FrameForwarder frame_forwarder; cricket::FakeFrameSource frame_source(1280, 720, @@ -1608,7 +1608,7 @@ class WebRtcVideoChannelEncodedFrameCallbackTest : public ::testing::Test { receive_channel_->SetInterface(&network_interface_); cricket::VideoReceiverParameters parameters; parameters.codecs = engine_.recv_codecs(); - receive_channel_->SetRecvParameters(parameters); + receive_channel_->SetReceiverParameters(parameters); receive_channel_->SetReceive(true); } @@ -1796,7 +1796,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test { receive_channel_->SetInterface(&network_interface_); cricket::VideoReceiverParameters parameters; parameters.codecs = engine_.send_codecs(); - receive_channel_->SetRecvParameters(parameters); + receive_channel_->SetReceiverParameters(parameters); EXPECT_TRUE(send_channel_->AddSendStream(DefaultSendStreamParams())); frame_forwarder_ = std::make_unique(); frame_source_ = std::make_unique( @@ -1865,7 +1865,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test { if (success) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(codec); - success = send_channel_->SetSendParameters(parameters); + success = send_channel_->SetSenderParameters(parameters); } if (success) { success = SetSend(sending); @@ -2094,7 +2094,7 @@ TEST_F(WebRtcVideoChannelBaseTest, GetStatsMultipleRecvStreams) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(DefaultCodec()); parameters.conference_mode = true; - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); EXPECT_TRUE(SetSend(true)); EXPECT_TRUE( receive_channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); @@ -2148,7 +2148,7 @@ TEST_F(WebRtcVideoChannelBaseTest, GetStatsMultipleSendStreams) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(DefaultCodec()); parameters.conference_mode = true; - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); EXPECT_TRUE(receive_channel_->AddRecvStream( cricket::StreamParams::CreateLegacy(kSsrc))); EXPECT_TRUE(receive_channel_->SetSink(kSsrc, &renderer_)); @@ -2199,9 +2199,9 @@ TEST_F(WebRtcVideoChannelBaseTest, SetSendBandwidth) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(DefaultCodec()); parameters.max_bandwidth_bps = -1; // <= 0 means unlimited. - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); parameters.max_bandwidth_bps = 128 * 1024; - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); } // Test that we can set the SSRC for the default send source. @@ -2300,7 +2300,7 @@ TEST_F(WebRtcVideoChannelBaseTest, SimulateConference) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(DefaultCodec()); parameters.conference_mode = true; - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); EXPECT_TRUE(SetSend(true)); EXPECT_TRUE( receive_channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); @@ -2532,7 +2532,7 @@ TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderFallback) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); absl::optional codec = send_channel_->GetSendCodec(); ASSERT_TRUE(codec); @@ -2558,7 +2558,7 @@ TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderSwitchDefaultFallback) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); absl::optional codec = send_channel_->GetSendCodec(); ASSERT_TRUE(codec); @@ -2584,7 +2584,7 @@ TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderSwitchStrictPreference) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(vp9); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); absl::optional codec = send_channel_->GetSendCodec(); ASSERT_TRUE(codec); @@ -2616,7 +2616,7 @@ TEST_F(WebRtcVideoChannelBaseTest, SendCodecIsMovedToFrontInRtpParameters) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); send_channel_->SetVideoCodecSwitchingEnabled(true); auto send_codecs = send_channel_->GetRtpSendParameters(kSsrc).codecs; @@ -2672,7 +2672,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { last_ssrc_ = 123; send_parameters_.codecs = engine_.send_codecs(); recv_parameters_.codecs = engine_.recv_codecs(); - ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); } void TearDown() override { @@ -2767,7 +2767,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(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); } void ExpectSetBitrateParameters(int min_bitrate_bps, @@ -2789,11 +2789,11 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { void TestExtmapAllowMixedCaller(bool extmap_allow_mixed) { // For a caller, the answer will be applied in set remote description - // where SetSendParameters() is called. + // where SetSenderParameters() is called. EXPECT_TRUE(send_channel_->AddSendStream( cricket::StreamParams::CreateLegacy(kSsrc))); send_parameters_.extmap_allow_mixed = extmap_allow_mixed; - EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); const webrtc::VideoSendStream::Config& config = fake_call_->GetVideoSendStreams()[0]->GetConfig(); EXPECT_EQ(extmap_allow_mixed, config.rtp.extmap_allow_mixed); @@ -2815,7 +2815,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { const int id = 1; cricket::VideoSenderParameters parameters = send_parameters_; parameters.extensions.push_back(RtpExtension(ext_uri, id)); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* send_stream = AddSendStream(cricket::StreamParams::CreateLegacy(123)); @@ -2824,17 +2824,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(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); // Verify that existing RTP header extensions can be removed. - EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(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(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(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); @@ -2846,15 +2846,15 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { const int id = 1; cricket::VideoReceiverParameters parameters = recv_parameters_; parameters.extensions.push_back(RtpExtension(ext_uri, id)); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); AddRecvStream(cricket::StreamParams::CreateLegacy(123)); EXPECT_THAT( - receive_channel_->GetRtpReceiveParameters(123).header_extensions, + receive_channel_->GetRtpReceiverParameters(123).header_extensions, ElementsAre(RtpExtension(ext_uri, id))); // Verify call with same set of extensions returns true. - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for // senders. @@ -2863,15 +2863,15 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { .rtp.extensions.empty()); // Verify that existing RTP header extensions can be removed. - EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); EXPECT_THAT( - receive_channel_->GetRtpReceiveParameters(123).header_extensions, + receive_channel_->GetRtpReceiverParameters(123).header_extensions, IsEmpty()); // Verify that adding receive RTP header extensions adds them for existing // streams. - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); - EXPECT_EQ(receive_channel_->GetRtpReceiveParameters(123).header_extensions, + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); + EXPECT_EQ(receive_channel_->GetRtpReceiverParameters(123).header_extensions, parameters.extensions); } @@ -2881,7 +2881,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { cricket::VideoSenderParameters parameters; parameters.codecs = engine_.send_codecs(); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); EXPECT_TRUE(send_channel_->SetSend(true)); // Send side. @@ -2905,7 +2905,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { expected_id = id; parameters.extensions.push_back(RtpExtension(extension, id++)); } - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* send_stream = AddSendStream(cricket::StreamParams::CreateLegacy(123)); @@ -2972,7 +2972,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { int expected_encoder_bitrate) { VideoSenderParameters limited_send_params = send_parameters_; limited_send_params.max_bandwidth_bps = global_max; - EXPECT_TRUE(send_channel_->SetSendParameters(limited_send_params)); + EXPECT_TRUE(send_channel_->SetSenderParameters(limited_send_params)); webrtc::RtpParameters parameters = send_channel_->GetRtpSendParameters(last_ssrc_); EXPECT_EQ(1UL, parameters.encodings.size()); @@ -3028,10 +3028,10 @@ TEST_F(WebRtcVideoChannelTest, SetsSyncGroupFromSyncLabel) { TEST_F(WebRtcVideoChannelTest, RecvStreamWithSimAndRtx) { cricket::VideoSenderParameters parameters; parameters.codecs = engine_.send_codecs(); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); EXPECT_TRUE(send_channel_->SetSend(true)); parameters.conference_mode = true; - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); // Send side. const std::vector ssrcs = MAKE_VECTOR(kSsrcs1); @@ -3100,7 +3100,7 @@ TEST_F(WebRtcVideoChannelTest, NoHeaderExtesionsByDefault) { ASSERT_TRUE(send_stream->GetConfig().rtp.extensions.empty()); AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0])); - ASSERT_TRUE(receive_channel_->GetRtpReceiveParameters(kSsrcs1[0]) + ASSERT_TRUE(receive_channel_->GetRtpReceiverParameters(kSsrcs1[0]) .header_extensions.empty()); } @@ -3165,7 +3165,7 @@ TEST_F(WebRtcVideoChannelTest, IdenticalSendExtensionsDoesntRecreateStream) { send_parameters_.extensions.push_back( RtpExtension(RtpExtension::kVideoRotationUri, kVideoRotationId)); - EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); FakeVideoSendStream* send_stream = AddSendStream(cricket::StreamParams::CreateLegacy(123)); @@ -3175,13 +3175,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(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); // Setting different extensions should recreate the stream. send_parameters_.extensions.resize(1); - EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams()); } @@ -3195,7 +3195,7 @@ TEST_F(WebRtcVideoChannelTest, RtpExtension(kUnsupportedExtensionName, kUnsupportedId)); send_parameters_.extensions.push_back( RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId)); - EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); FakeVideoSendStream* send_stream = AddSendStream(cricket::StreamParams::CreateLegacy(123)); @@ -3215,14 +3215,14 @@ TEST_F(WebRtcVideoChannelTest, RtpExtension(kUnsupportedExtensionName, kUnsupportedId)); recv_parameters_.extensions.push_back( RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId)); - EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); AddRecvStream(cricket::StreamParams::CreateLegacy(123)); // Only timestamp offset extension is set to receive stream, // unsupported rtp extension is ignored. - ASSERT_THAT(receive_channel_->GetRtpReceiveParameters(123).header_extensions, + ASSERT_THAT(receive_channel_->GetRtpReceiverParameters(123).header_extensions, SizeIs(1)); - EXPECT_STREQ(receive_channel_->GetRtpReceiveParameters(123) + EXPECT_STREQ(receive_channel_->GetRtpReceiverParameters(123) .header_extensions[0] .uri.c_str(), RtpExtension::kTimestampOffsetUri); @@ -3233,7 +3233,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(send_channel_->SetSendParameters(send_parameters_)) + EXPECT_FALSE(send_channel_->SetSenderParameters(send_parameters_)) << "Bad extension id '" << kIncorrectIds[i] << "' accepted."; } } @@ -3243,7 +3243,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(receive_channel_->SetRecvParameters(recv_parameters_)) + EXPECT_FALSE(receive_channel_->SetReceiverParameters(recv_parameters_)) << "Bad extension id '" << kIncorrectIds[i] << "' accepted."; } } @@ -3254,14 +3254,14 @@ TEST_F(WebRtcVideoChannelTest, SetSendRtpHeaderExtensionsRejectsDuplicateIds) { RtpExtension(RtpExtension::kTimestampOffsetUri, id)); send_parameters_.extensions.push_back( RtpExtension(RtpExtension::kAbsSendTimeUri, id)); - EXPECT_FALSE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_FALSE(send_channel_->SetSenderParameters(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(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_FALSE(send_channel_->SetSenderParameters(send_parameters_)); } TEST_F(WebRtcVideoChannelTest, SetRecvRtpHeaderExtensionsRejectsDuplicateIds) { @@ -3270,21 +3270,21 @@ TEST_F(WebRtcVideoChannelTest, SetRecvRtpHeaderExtensionsRejectsDuplicateIds) { RtpExtension(RtpExtension::kTimestampOffsetUri, id)); recv_parameters_.extensions.push_back( RtpExtension(RtpExtension::kAbsSendTimeUri, id)); - EXPECT_FALSE(receive_channel_->SetRecvParameters(recv_parameters_)); + EXPECT_FALSE(receive_channel_->SetReceiverParameters(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(receive_channel_->SetRecvParameters(recv_parameters_)); + EXPECT_FALSE(receive_channel_->SetReceiverParameters(recv_parameters_)); } TEST_F(WebRtcVideoChannelTest, OnPacketReceivedIdentifiesExtensions) { cricket::VideoReceiverParameters parameters = recv_parameters_; parameters.extensions.push_back( RtpExtension(RtpExtension::kVideoRotationUri, /*id=*/1)); - ASSERT_TRUE(receive_channel_->SetRecvParameters(parameters)); + ASSERT_TRUE(receive_channel_->SetReceiverParameters(parameters)); webrtc::RtpHeaderExtensionMap extension_map(parameters.extensions); RtpPacketReceived reference_packet(&extension_map); reference_packet.SetExtension( @@ -3334,7 +3334,7 @@ TEST_F(WebRtcVideoChannelTest, LossNotificationCanBeEnabledAndDisabled) { { cricket::VideoSenderParameters parameters; parameters.codecs = engine_.send_codecs(); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); EXPECT_TRUE(send_channel_->SetSend(true)); } @@ -3350,7 +3350,7 @@ TEST_F(WebRtcVideoChannelTest, LossNotificationCanBeEnabledAndDisabled) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8"))); EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); recv_stream = fake_call_->GetVideoReceiveStreams()[0]; EXPECT_FALSE(recv_stream->GetConfig().rtp.lntf.enabled); send_stream = fake_call_->GetVideoSendStreams()[0]; @@ -3358,7 +3358,7 @@ TEST_F(WebRtcVideoChannelTest, LossNotificationCanBeEnabledAndDisabled) { // Setting the default codecs again, including VP8, turns LNTF back on. parameters.codecs = engine_.send_codecs(); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); recv_stream = fake_call_->GetVideoReceiveStreams()[0]; EXPECT_TRUE(recv_stream->GetConfig().rtp.lntf.enabled); send_stream = fake_call_->GetVideoSendStreams()[0]; @@ -3371,7 +3371,7 @@ TEST_F(WebRtcVideoChannelTest, NackIsEnabledByDefault) { cricket::VideoSenderParameters parameters; parameters.codecs = engine_.send_codecs(); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); EXPECT_TRUE(send_channel_->SetSend(true)); // Send side. @@ -3400,7 +3400,7 @@ TEST_F(WebRtcVideoChannelTest, NackCanBeEnabledAndDisabled) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8"))); EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); recv_stream = fake_call_->GetVideoReceiveStreams()[0]; EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms); send_stream = fake_call_->GetVideoSendStreams()[0]; @@ -3409,7 +3409,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(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); recv_stream = fake_call_->GetVideoReceiveStreams()[0]; EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0); send_stream = fake_call_->GetVideoSendStreams()[0]; @@ -3424,7 +3424,7 @@ TEST_F(WebRtcVideoChannelTest, NackCanBeEnabledAndDisabled) { TEST_F(WebRtcVideoChannelTest, ReconfiguresEncodersWhenNotSending) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); send_channel_->SetSend(false); FakeVideoSendStream* stream = AddSendStream(); @@ -3455,7 +3455,7 @@ TEST_F(WebRtcVideoChannelTest, UsesCorrectSettingsForScreencast) { cricket::VideoCodec codec = GetEngineCodec("VP8"); cricket::VideoSenderParameters parameters; parameters.codecs.push_back(codec); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); AddSendStream(); webrtc::test::FrameForwarder frame_forwarder; @@ -3515,7 +3515,7 @@ TEST_F(WebRtcVideoChannelTest, ConferenceModeScreencastConfiguresTemporalLayer) { static const int kConferenceScreencastTemporalBitrateBps = 200 * 1000; send_parameters_.conference_mode = true; - send_channel_->SetSendParameters(send_parameters_); + send_channel_->SetSenderParameters(send_parameters_); AddSendStream(); VideoOptions options; @@ -3564,7 +3564,7 @@ TEST_F(WebRtcVideoChannelTest, SetMediaConfigSuspendBelowMinBitrate) { fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions()); send_channel_->OnReadyToSend(true); - send_channel_->SetSendParameters(send_parameters_); + send_channel_->SetSenderParameters(send_parameters_); FakeVideoSendStream* stream = AddSendStream(); EXPECT_TRUE(stream->GetConfig().suspend_below_min_bitrate); @@ -3577,7 +3577,7 @@ TEST_F(WebRtcVideoChannelTest, SetMediaConfigSuspendBelowMinBitrate) { fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions()); send_channel_->OnReadyToSend(true); - send_channel_->SetSendParameters(send_parameters_); + send_channel_->SetSenderParameters(send_parameters_); stream = AddSendStream(); EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate); @@ -3593,7 +3593,7 @@ TEST_F(WebRtcVideoChannelTest, Vp8DenoisingEnabledByDefault) { TEST_F(WebRtcVideoChannelTest, VerifyVp8SpecificSettings) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); // Single-stream settings should apply with RTX as well (verifies that we // check number of regular SSRCs and not StreamParams::ssrcs which contains @@ -3673,7 +3673,7 @@ TEST_F(WebRtcVideoChannelTest, SetIdenticalOptionsDoesntReconfigureEncoder) { AddSendStream(); cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); EXPECT_TRUE( @@ -3711,7 +3711,7 @@ class Vp9SettingsTest : public WebRtcVideoChannelTest { void TearDown() override { // Remove references to encoder_factory_ since this will be destroyed // before send_channel_ and engine_. - ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); } }; @@ -3722,7 +3722,7 @@ TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(false, /*with_rtx=*/false); @@ -3817,7 +3817,7 @@ TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) { TEST_F(Vp9SettingsTest, MultipleSsrcsEnablesSvc) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); std::vector ssrcs = MAKE_VECTOR(kSsrcs3); @@ -3846,7 +3846,7 @@ TEST_F(Vp9SettingsTest, MultipleSsrcsEnablesSvc) { TEST_F(Vp9SettingsTest, SvcModeCreatesSingleRtpStream) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); std::vector ssrcs = MAKE_VECTOR(kSsrcs3); @@ -3876,7 +3876,7 @@ TEST_F(Vp9SettingsTest, SvcModeCreatesSingleRtpStream) { TEST_F(Vp9SettingsTest, AllEncodingParametersCopied) { cricket::VideoSenderParameters send_parameters; send_parameters.codecs.push_back(GetEngineCodec("VP9")); - ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters)); const size_t kNumSpatialLayers = 3; std::vector ssrcs = MAKE_VECTOR(kSsrcs3); @@ -3909,7 +3909,7 @@ TEST_F(Vp9SettingsTest, AllEncodingParametersCopied) { TEST_F(Vp9SettingsTest, MaxBitrateDeterminedBySvcResolutions) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); std::vector ssrcs = MAKE_VECTOR(kSsrcs3); @@ -3946,7 +3946,7 @@ TEST_F(Vp9SettingsTest, MaxBitrateDeterminedBySvcResolutions) { // Update send parameters to 2Mbps, this should cap the max bitrate of the // stream. parameters.max_bandwidth_bps = 2000000; - send_channel_->SetSendParameters(parameters); + send_channel_->SetSenderParameters(parameters); EXPECT_THAT( stream->GetVideoStreams(), ElementsAre(Field(&webrtc::VideoStream::max_bitrate_bps, Eq(2000000)))); @@ -3955,7 +3955,7 @@ TEST_F(Vp9SettingsTest, MaxBitrateDeterminedBySvcResolutions) { TEST_F(Vp9SettingsTest, Vp9SvcTargetBitrateCappedByMax) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); std::vector ssrcs = MAKE_VECTOR(kSsrcs3); @@ -4008,7 +4008,7 @@ class Vp9SettingsTestWithFieldTrial webrtc::InterLayerPredMode interLayerPred) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP9")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(false, /*with_rtx=*/false); @@ -4130,7 +4130,7 @@ TEST_F(WebRtcVideoChannelTest, PreviousAdaptationDoesNotApplyToScreenshare) { fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions()); send_channel_->OnReadyToSend(true); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); AddSendStream(); webrtc::test::FrameForwarder frame_forwarder; @@ -4184,7 +4184,7 @@ void WebRtcVideoChannelTest::TestDegradationPreference( fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions()); send_channel_->OnReadyToSend(true); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); AddSendStream(); @@ -4220,7 +4220,7 @@ void WebRtcVideoChannelTest::TestCpuAdaptation(bool enable_overuse, fake_call_.get(), media_config, VideoOptions(), webrtc::CryptoOptions()); send_channel_->OnReadyToSend(true); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); AddSendStream(); @@ -4252,7 +4252,7 @@ TEST_F(WebRtcVideoChannelTest, EstimatesNtpStartTimeCorrectly) { static const uint32_t kInitialTimestamp = 0xFFFFFFFFu; static const int64_t kInitialNtpTimeMs = 1247891230; static const int kFrameOffsetMs = 20; - EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); FakeVideoReceiveStream* stream = AddRecvStream(); cricket::FakeVideoRenderer renderer; @@ -4294,7 +4294,7 @@ TEST_F(WebRtcVideoChannelTest, EstimatesNtpStartTimeCorrectly) { TEST_F(WebRtcVideoChannelTest, SetDefaultSendCodecs) { AssignDefaultAptRtxTypes(); - ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); absl::optional codec = send_channel_->GetSendCodec(); ASSERT_TRUE(codec); @@ -4321,7 +4321,7 @@ TEST_F(WebRtcVideoChannelTest, SetDefaultSendCodecs) { TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutPacketization) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); const webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); @@ -4332,7 +4332,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithPacketization) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.back().packetization = kPacketizationParamRaw; - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); const webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); @@ -4443,7 +4443,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, EnablingFlexfecDoesNotRecreateVideoReceiveStream) { cricket::VideoReceiverParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters)); AddRecvStream( CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc)); @@ -4459,7 +4459,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, // Enable FlexFEC. recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03")); - ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetReceiverParameters(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 @@ -4485,7 +4485,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, cricket::VideoReceiverParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03")); - ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters)); AddRecvStream( CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc)); @@ -4503,7 +4503,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, // Disable FlexFEC. recv_parameters.codecs.clear(); recv_parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetReceiverParameters(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. @@ -4528,7 +4528,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, DuplicateFlexfecCodecIsDropped) { cricket::VideoCodec duplicate = GetEngineCodec("flexfec-03"); duplicate.id = kUnusedPayloadType1; recv_parameters.codecs.push_back(duplicate); - ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters)); AddRecvStream( CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc)); @@ -4575,7 +4575,7 @@ TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, SetDefaultSendCodecsWithSsrc) { TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutFec) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); @@ -4587,7 +4587,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutFec) { TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, SetSendCodecsWithoutFec) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); @@ -4602,7 +4602,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvCodecsWithFec) { cricket::VideoReceiverParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03")); - ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters)); const std::vector& flexfec_streams = fake_call_->GetFlexfecReceiveStreams(); @@ -4636,7 +4636,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("flexfec-03")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); @@ -4651,7 +4651,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("flexfec-03")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = AddSendStream( CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc)); @@ -4671,7 +4671,7 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoCodec rtx_codec = cricket::CreateVideoCodec(kUnusedPayloadType, "rtx"); parameters.codecs.push_back(rtx_codec); - EXPECT_FALSE(send_channel_->SetSendParameters(parameters)) + EXPECT_FALSE(send_channel_->SetSenderParameters(parameters)) << "RTX codec without associated payload type should be rejected."; } @@ -4687,7 +4687,7 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(rtx_codec); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); } { cricket::VideoCodec rtx_codec = @@ -4695,7 +4695,7 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(rtx_codec); - EXPECT_FALSE(send_channel_->SetSendParameters(parameters)) + EXPECT_FALSE(send_channel_->SetSenderParameters(parameters)) << "RTX without matching video codec should be rejected."; } } @@ -4719,7 +4719,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithChangedRtxPayloadType) { cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx"); rtx_codec.SetParam("apt", GetEngineCodec("VP8").id); parameters.codecs.push_back(rtx_codec); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); ASSERT_EQ(1U, fake_call_->GetVideoSendStreams().size()); const webrtc::VideoSendStream::Config& config_before = fake_call_->GetVideoSendStreams()[0]->GetConfig(); @@ -4729,7 +4729,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithChangedRtxPayloadType) { // Change payload type for RTX. parameters.codecs[1].id = kUnusedPayloadType2; - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); ASSERT_EQ(1U, fake_call_->GetVideoSendStreams().size()); const webrtc::VideoSendStream::Config& config_after = fake_call_->GetVideoSendStreams()[0]->GetConfig(); @@ -4742,7 +4742,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutFecDisablesFec) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("ulpfec")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); @@ -4750,7 +4750,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithoutFecDisablesFec) { EXPECT_EQ(GetEngineCodec("ulpfec").id, config.rtp.ulpfec.ulpfec_payload_type); parameters.codecs.pop_back(); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); stream = fake_call_->GetVideoSendStreams()[0]; ASSERT_TRUE(stream != nullptr); config = stream->GetConfig().Copy(); @@ -4763,7 +4763,7 @@ TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("flexfec-03")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = AddSendStream( CreatePrimaryWithFecFrStreamParams("cname", kSsrcs1[0], kFlexfecSsrc)); @@ -4775,7 +4775,7 @@ TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, EXPECT_EQ(kSsrcs1[0], config.rtp.flexfec.protected_media_ssrcs[0]); parameters.codecs.pop_back(); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); stream = fake_call_->GetVideoSendStreams()[0]; ASSERT_TRUE(stream != nullptr); config = stream->GetConfig().Copy(); @@ -4789,7 +4789,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsChangesExistingStreams) { codec.SetParam(kCodecParamMaxQuantization, kDefaultQpMax); parameters.codecs.push_back(codec); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); send_channel_->SetSend(true); FakeVideoSendStream* stream = AddSendStream(); @@ -4803,7 +4803,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsChangesExistingStreams) { parameters.codecs.clear(); codec.SetParam(kCodecParamMaxQuantization, kDefaultQpMax + 1); parameters.codecs.push_back(codec); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); streams = fake_call_->GetVideoSendStreams()[0]->GetVideoStreams(); EXPECT_EQ(kDefaultQpMax + 1, streams[0].max_qp); EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, nullptr, nullptr)); @@ -4833,16 +4833,16 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsCapsMinAndStartBitrate) { TEST_F(WebRtcVideoChannelTest, SetSendCodecsRejectsMaxLessThanMinBitrate) { send_parameters_.codecs[0].params[kCodecParamMinBitrate] = "300"; send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "200"; - EXPECT_FALSE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_FALSE(send_channel_->SetSenderParameters(send_parameters_)); } TEST_F(WebRtcVideoChannelTest, - SetSendParametersRemovesSelectedCodecFromRtpParameters) { + SetSenderParametersRemovesSelectedCodecFromRtpParameters) { EXPECT_TRUE(AddSendStream()); cricket::VideoSenderParameters parameters; parameters.codecs.push_back(cricket::CreateVideoCodec(100, "VP8")); parameters.codecs.push_back(cricket::CreateVideoCodec(100, "VP9")); - send_channel_->SetSendParameters(parameters); + send_channel_->SetSenderParameters(parameters); webrtc::RtpParameters initial_params = send_channel_->GetRtpSendParameters(last_ssrc_); @@ -4860,7 +4860,7 @@ TEST_F(WebRtcVideoChannelTest, parameters.codecs.clear(); parameters.codecs.push_back(cricket::CreateVideoCodec(100, "VP8")); - send_channel_->SetSendParameters(parameters); + send_channel_->SetSenderParameters(parameters); // Since VP9 is no longer negotiated, the RTP parameters should not have a // forced codec anymore. @@ -4878,24 +4878,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(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(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(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(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(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(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(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); } TEST_F(WebRtcVideoChannelTest, SetMaxSendBandwidthShouldPreserveOtherBitrates) { @@ -4905,31 +4905,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(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); } TEST_F(WebRtcVideoChannelTest, SetMaxSendBandwidthShouldBeRemovable) { send_parameters_.max_bandwidth_bps = 300000; ExpectSetMaxBitrate(300000); - EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); // -1 means to disable max bitrate (set infinite). send_parameters_.max_bandwidth_bps = -1; ExpectSetMaxBitrate(-1); - EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); } TEST_F(WebRtcVideoChannelTest, SetMaxSendBandwidthAndAddSendStream) { send_parameters_.max_bandwidth_bps = 99999; FakeVideoSendStream* stream = AddSendStream(); ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps); - ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSenderParameters(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(send_channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); EXPECT_EQ(send_parameters_.max_bandwidth_bps, stream->GetVideoStreams()[0].max_bitrate_bps); } @@ -4945,7 +4945,7 @@ TEST_F(WebRtcVideoChannelTest, send_parameters_.max_bandwidth_bps = -1; AddSendStream(); ExpectSetMaxBitrate(300000); - ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); std::vector video_send_streams = GetFakeSendStreams(); ASSERT_EQ(1u, video_send_streams.size()); @@ -4958,7 +4958,7 @@ TEST_F(WebRtcVideoChannelTest, // The VideoSenderParameters max bitrate overrides the codec's. send_parameters_.max_bandwidth_bps = 500000; ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps); - ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); ASSERT_EQ(1u, video_send_stream->GetVideoStreams().size()); EXPECT_EQ(500000, video_send_stream->GetVideoStreams()[0].max_bitrate_bps); } @@ -4974,7 +4974,7 @@ TEST_F(WebRtcVideoChannelTest, send_parameters_.max_bandwidth_bps = -1; AddSendStream(); ExpectSetMaxBitrate(300000); - ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); std::vector video_send_streams = GetFakeSendStreams(); ASSERT_EQ(1u, video_send_streams.size()); @@ -4999,7 +4999,7 @@ TEST_F(WebRtcVideoChannelTest, send_parameters_.max_bandwidth_bps = 99999; FakeVideoSendStream* stream = AddSendStream(); ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps); - ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); ASSERT_EQ(1u, stream->GetVideoStreams().size()); EXPECT_EQ(send_parameters_.max_bandwidth_bps, stream->GetVideoStreams()[0].max_bitrate_bps); @@ -5023,7 +5023,7 @@ TEST_F(WebRtcVideoChannelTest, TEST_F(WebRtcVideoChannelTest, SetMaxSendBitrateCanIncreaseSenderBitrate) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); send_channel_->SetSend(true); FakeVideoSendStream* stream = AddSendStream(); @@ -5037,7 +5037,7 @@ TEST_F(WebRtcVideoChannelTest, SetMaxSendBitrateCanIncreaseSenderBitrate) { EXPECT_GT(initial_max_bitrate_bps, 0); parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2; - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); // Insert a frame to update the encoder config. frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); streams = stream->GetVideoStreams(); @@ -5049,7 +5049,7 @@ TEST_F(WebRtcVideoChannelTest, SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); send_channel_->SetSend(true); FakeVideoSendStream* stream = AddSendStream( @@ -5068,7 +5068,7 @@ TEST_F(WebRtcVideoChannelTest, EXPECT_GT(initial_max_bitrate_bps, 0); parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2; - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); // Insert a frame to update the encoder config. frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); streams = stream->GetVideoStreams(); @@ -5083,7 +5083,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithMaxQuantization) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization; - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); EXPECT_EQ(atoi(kMaxQuantization), AddSendStream()->GetVideoStreams().back().max_qp); @@ -5099,7 +5099,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(send_channel_->SetSendParameters(parameters)) + EXPECT_FALSE(send_channel_->SetSenderParameters(parameters)) << "Bad payload type '" << kIncorrectPayloads[i] << "' accepted."; } } @@ -5109,7 +5109,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(send_channel_->SetSendParameters(parameters)) + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)) << "Payload type '" << payload_type << "' rejected."; } } @@ -5123,21 +5123,21 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoSenderParameters parameters1; parameters1.codecs.push_back(GetEngineCodec("VP8")); parameters1.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters1)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters1)); AddSendStream(); EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); cricket::VideoSenderParameters parameters2; parameters2.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters2)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters2)); EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithOnlyVp8) { cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); } // Test that we set our inbound RTX codecs properly. @@ -5152,22 +5152,22 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithRtx) { cricket::VideoCodec rtx_codec = cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx"); parameters.codecs.push_back(rtx_codec); - EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)) + EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters)) << "RTX codec without associated payload should be rejected."; parameters.codecs[1].SetParam("apt", kUnusedPayloadType2); - EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)) + EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters)) << "RTX codec with invalid associated payload type should be rejected."; parameters.codecs[1].SetParam("apt", GetEngineCodec("VP8").id); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); cricket::VideoCodec rtx_codec2 = cricket::CreateVideoCodec(kUnusedPayloadType2, "rtx"); rtx_codec2.SetParam("apt", rtx_codec.id); parameters.codecs.push_back(rtx_codec2); - EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)) + EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters)) << "RTX codec with another RTX as associated payload type should be " "rejected."; } @@ -5178,7 +5178,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithPacketization) { cricket::VideoReceiverParameters parameters; parameters.codecs = {vp8_codec, GetEngineCodec("VP9")}; - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); const cricket::StreamParams params = cricket::StreamParams::CreateLegacy(kSsrcs1[0]); @@ -5195,7 +5195,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithPacketizationRecreatesStream) { cricket::VideoReceiverParameters parameters; parameters.codecs = {GetEngineCodec("VP8"), GetEngineCodec("VP9")}; parameters.codecs.back().packetization = kPacketizationParamRaw; - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); const cricket::StreamParams params = cricket::StreamParams::CreateLegacy(kSsrcs1[0]); @@ -5204,7 +5204,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithPacketizationRecreatesStream) { EXPECT_EQ(fake_call_->GetNumCreatedReceiveStreams(), 1); parameters.codecs.back().packetization.reset(); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); EXPECT_EQ(fake_call_->GetNumCreatedReceiveStreams(), 2); } @@ -5218,7 +5218,7 @@ TEST_F(WebRtcVideoChannelTest, DuplicateUlpfecCodecIsDropped) { kFirstUlpfecPayloadType, cricket::kUlpfecCodecName)); parameters.codecs.push_back(cricket::CreateVideoCodec( kSecondUlpfecPayloadType, cricket::kUlpfecCodecName)); - ASSERT_TRUE(receive_channel_->SetRecvParameters(parameters)); + ASSERT_TRUE(receive_channel_->SetReceiverParameters(parameters)); FakeVideoReceiveStream* recv_stream = AddRecvStream(); EXPECT_EQ(kFirstUlpfecPayloadType, @@ -5235,7 +5235,7 @@ TEST_F(WebRtcVideoChannelTest, DuplicateRedCodecIsDropped) { cricket::CreateVideoCodec(kFirstRedPayloadType, cricket::kRedCodecName)); parameters.codecs.push_back( cricket::CreateVideoCodec(kSecondRedPayloadType, cricket::kRedCodecName)); - ASSERT_TRUE(receive_channel_->SetRecvParameters(parameters)); + ASSERT_TRUE(receive_channel_->SetReceiverParameters(parameters)); FakeVideoReceiveStream* recv_stream = AddRecvStream(); EXPECT_EQ(kFirstRedPayloadType, @@ -5261,7 +5261,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithChangedRtxPayloadType) { cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx"); rtx_codec.SetParam("apt", GetEngineCodec("VP8").id); parameters.codecs.push_back(rtx_codec); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); ASSERT_EQ(1U, fake_call_->GetVideoReceiveStreams().size()); const webrtc::VideoReceiveStreamInterface::Config& config_before = fake_call_->GetVideoReceiveStreams()[0]->GetConfig(); @@ -5274,7 +5274,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithChangedRtxPayloadType) { // Change payload type for RTX. parameters.codecs[1].id = kUnusedPayloadType2; - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); ASSERT_EQ(1U, fake_call_->GetVideoReceiveStreams().size()); const webrtc::VideoReceiveStreamInterface::Config& config_after = fake_call_->GetVideoReceiveStreams()[0]->GetConfig(); @@ -5305,7 +5305,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRtxWithRtxTime) { cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx"); rtx_codec.SetParam("apt", GetEngineCodec("VP8").id); parameters.codecs.push_back(rtx_codec); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); ASSERT_EQ(1U, fake_call_->GetVideoReceiveStreams().size()); const webrtc::VideoReceiveStreamInterface::Config& config = fake_call_->GetVideoReceiveStreams()[0]->GetConfig(); @@ -5318,7 +5318,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRtxWithRtxTime) { // Set rtx-time. parameters.codecs[1].SetParam(kCodecParamRtxTime, kRtxTime); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); EXPECT_EQ(fake_call_->GetVideoReceiveStreams()[0] ->GetConfig() .rtp.nack.rtp_history_ms, @@ -5326,7 +5326,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRtxWithRtxTime) { // Negative values are ignored so the default value applies. parameters.codecs[1].SetParam(kCodecParamRtxTime, -1); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); EXPECT_NE(fake_call_->GetVideoReceiveStreams()[0] ->GetConfig() .rtp.nack.rtp_history_ms, @@ -5338,7 +5338,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRtxWithRtxTime) { // 0 is ignored so the default applies. parameters.codecs[1].SetParam(kCodecParamRtxTime, 0); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); EXPECT_NE(fake_call_->GetVideoReceiveStreams()[0] ->GetConfig() .rtp.nack.rtp_history_ms, @@ -5350,7 +5350,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(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); EXPECT_EQ(fake_call_->GetVideoReceiveStreams()[0] ->GetConfig() .rtp.nack.rtp_history_ms, @@ -5361,13 +5361,13 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsDifferentPayloadType) { cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs[0].id = 99; - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsAcceptDefaultCodecs) { cricket::VideoReceiverParameters parameters; parameters.codecs = engine_.recv_codecs(); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); FakeVideoReceiveStream* stream = AddRecvStream(); const webrtc::VideoReceiveStreamInterface::Config& config = @@ -5381,14 +5381,14 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectUnsupportedCodec) { cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(cricket::CreateVideoCodec(101, "WTF3")); - EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters)); } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsAcceptsMultipleVideoCodecs) { cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithoutFecDisablesFec) { @@ -5396,7 +5396,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(send_channel_->SetSendParameters(send_parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters)); FakeVideoReceiveStream* stream = AddRecvStream(); @@ -5405,7 +5405,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithoutFecDisablesFec) { cricket::VideoReceiverParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters)); stream = fake_call_->GetVideoReceiveStreams()[0]; ASSERT_TRUE(stream != nullptr); EXPECT_EQ(-1, stream->GetConfig().rtp.ulpfec_payload_type) @@ -5427,7 +5427,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvParamsWithoutFecDisablesFec) { cricket::VideoReceiverParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters)); EXPECT_TRUE(streams.empty()) << "SetSendCodec without FlexFEC should disable current FlexFEC."; } @@ -5441,7 +5441,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(receive_channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters)); stream = fake_call_->GetVideoReceiveStreams()[0]; ASSERT_TRUE(stream != nullptr); EXPECT_EQ(GetEngineCodec("ulpfec").id, @@ -5452,7 +5452,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(send_channel_->SetSendParameters(send_parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters)); stream = fake_call_->GetVideoReceiveStreams()[0]; EXPECT_EQ(GetEngineCodec("ulpfec").id, stream->GetConfig().rtp.ulpfec_payload_type) @@ -5469,7 +5469,7 @@ TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, cricket::VideoReceiverParameters recv_parameters; recv_parameters.codecs.push_back(GetEngineCodec("VP8")); recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03")); - ASSERT_TRUE(receive_channel_->SetRecvParameters(recv_parameters)); + ASSERT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters)); ASSERT_EQ(1U, streams.size()); const FakeFlexfecReceiveStream* stream_with_recv_params = streams.front(); EXPECT_EQ(GetEngineCodec("flexfec-03").id, @@ -5483,7 +5483,7 @@ TEST_F(WebRtcVideoChannelFlexfecSendRecvTest, cricket::VideoSenderParameters send_parameters; send_parameters.codecs.push_back(GetEngineCodec("VP8")); send_parameters.codecs.push_back(GetEngineCodec("flexfec-03")); - ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters)); ASSERT_EQ(1U, streams.size()); const FakeFlexfecReceiveStream* stream_with_send_params = streams.front(); EXPECT_EQ(GetEngineCodec("flexfec-03").id, @@ -5500,7 +5500,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(receive_channel_->SetRecvParameters(parameters)); + EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters)); } TEST_F(WebRtcVideoChannelFlexfecRecvTest, @@ -5509,7 +5509,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(receive_channel_->SetRecvParameters(parameters)); + EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters)); } TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectDuplicateCodecPayloads) { @@ -5517,7 +5517,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(receive_channel_->SetRecvParameters(parameters)); + EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters)); } TEST_F(WebRtcVideoChannelTest, @@ -5526,7 +5526,7 @@ TEST_F(WebRtcVideoChannelTest, parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs[1].id += 1; - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); } // Test that setting the same codecs but with a different order @@ -5536,7 +5536,7 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoReceiverParameters parameters1; parameters1.codecs.push_back(GetEngineCodec("VP8")); parameters1.codecs.push_back(GetEngineCodec("red")); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters1)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters1)); AddRecvStream(cricket::StreamParams::CreateLegacy(123)); EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams()); @@ -5544,7 +5544,7 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoReceiverParameters parameters2; parameters2.codecs.push_back(GetEngineCodec("red")); parameters2.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters2)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters2)); EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams()); } @@ -5649,7 +5649,7 @@ TEST_F(WebRtcVideoChannelTest, TestSetSendRtcpReducedSize) { // Now enable reduced size mode. send_parameters_.rtcp.reduced_size = true; - EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); stream1 = fake_call_->GetVideoSendStreams()[0]; EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream1->GetConfig().rtp.rtcp_mode); rtp_parameters = send_channel_->GetRtpSendParameters(last_ssrc_); @@ -5671,7 +5671,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(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); stream1 = fake_call_->GetVideoReceiveStreams()[0]; EXPECT_EQ(webrtc::RtcpMode::kReducedSize, stream1->GetConfig().rtp.rtcp_mode); @@ -5702,7 +5702,7 @@ TEST_F(WebRtcVideoChannelTest, OnReadyToSendSignalsNetworkState) { TEST_F(WebRtcVideoChannelTest, GetStatsReportsSentCodecName) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); AddSendStream(); @@ -6209,7 +6209,7 @@ TEST_F(WebRtcVideoChannelTest, TEST_F(WebRtcVideoChannelTest, OutboundRtpIsActiveComesFromAnyEncodingInSvc) { cricket::VideoSenderParameters send_parameters; send_parameters.codecs.push_back(GetEngineCodec("VP9")); - ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters)); constexpr uint32_t kSsrc1 = 123u; constexpr uint32_t kSsrc2 = 456u; @@ -6796,7 +6796,7 @@ TEST_F(WebRtcVideoChannelTest, TranslatesSenderBitrateStatsCorrectly) { } TEST_F(WebRtcVideoChannelTest, DefaultReceiveStreamReconfiguresToUseRtx) { - EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); const std::vector ssrcs = MAKE_VECTOR(kSsrcs1); const std::vector rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); @@ -6828,7 +6828,7 @@ TEST_F(WebRtcVideoChannelTest, DefaultReceiveStreamReconfiguresToUseRtx) { } TEST_F(WebRtcVideoChannelTest, RejectsAddingStreamsWithMissingSsrcsForRtx) { - EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); const std::vector ssrcs = MAKE_VECTOR(kSsrcs1); const std::vector rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); @@ -6842,7 +6842,7 @@ TEST_F(WebRtcVideoChannelTest, RejectsAddingStreamsWithMissingSsrcsForRtx) { } TEST_F(WebRtcVideoChannelTest, RejectsAddingStreamsWithOverlappingRtxSsrcs) { - EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); const std::vector ssrcs = MAKE_VECTOR(kSsrcs1); const std::vector rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); @@ -6870,7 +6870,7 @@ TEST_F(WebRtcVideoChannelTest, RejectsAddingStreamsWithOverlappingSimulcastSsrcs) { static const uint32_t kFirstStreamSsrcs[] = {1, 2, 3}; static const uint32_t kOverlappingStreamSsrcs[] = {4, 3, 5}; - EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); StreamParams sp = cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kFirstStreamSsrcs)); @@ -6893,7 +6893,7 @@ TEST_F(WebRtcVideoChannelTest, } TEST_F(WebRtcVideoChannelTest, ReportsSsrcGroupsInStats) { - EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); static const uint32_t kSenderSsrcs[] = {4, 7, 10}; static const uint32_t kSenderRtxSsrcs[] = {5, 8, 11}; @@ -7370,7 +7370,7 @@ void WebRtcVideoChannelTest::TestReceiveUnsignaledSsrcPacket( VideoCodec red_rtx_codec = cricket::CreateVideoRtxCodec( kRedRtxPayloadType, GetEngineCodec("red").id); recv_parameters_.codecs.push_back(red_rtx_codec); - EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size()); RtpPacketReceived packet; @@ -7515,7 +7515,7 @@ TEST_F(WebRtcVideoChannelTest, ReceiveDifferentUnsignaledSsrc) { parameters.codecs.push_back(H264codec); #endif - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); // No receive streams yet. ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size()); cricket::FakeVideoRenderer renderer; @@ -7589,7 +7589,7 @@ TEST_F(WebRtcVideoChannelTest, NewUnsignaledStreamDoesNotDestroyPreviouslyUnsignaledStream) { cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(receive_channel_->SetRecvParameters(parameters)); + ASSERT_TRUE(receive_channel_->SetReceiverParameters(parameters)); // No streams signaled and no packets received, so we should not have any // stream objects created yet. @@ -7721,7 +7721,7 @@ TEST_F(WebRtcVideoChannelTest, send_parameters_.max_bandwidth_bps = 99999; FakeVideoSendStream* stream = AddSendStream(); ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps); - ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); ASSERT_EQ(1UL, stream->GetVideoStreams().size()); EXPECT_EQ(webrtc::kDefaultMinVideoBitrateBps, stream->GetVideoStreams()[0].min_bitrate_bps); @@ -7963,7 +7963,7 @@ TEST_F(WebRtcVideoChannelTest, GetAndSetRtpSendParametersScaleResolutionDownByVP8) { VideoSenderParameters parameters; parameters.codecs.push_back(cricket::CreateVideoCodec(kVp8CodecName)); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false); webrtc::test::FrameForwarder frame_forwarder; @@ -8081,7 +8081,7 @@ TEST_F(WebRtcVideoChannelTest, // Set up WebRtcVideoChannel for 3-layer VP8 simulcast. VideoSenderParameters parameters; parameters.codecs.push_back(cricket::CreateVideoCodec(kVp8CodecName)); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false); webrtc::test::FrameForwarder frame_forwarder; EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, /*options=*/nullptr, @@ -8124,7 +8124,7 @@ TEST_F(WebRtcVideoChannelTest, encoder_factory_->AddSupportedVideoCodecType(kH264CodecName); VideoSenderParameters parameters; parameters.codecs.push_back(cricket::CreateVideoCodec(kH264CodecName)); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false); webrtc::test::FrameForwarder frame_forwarder; @@ -8242,7 +8242,7 @@ TEST_F(WebRtcVideoChannelTest, encoder_factory_->AddSupportedVideoCodecType(kH264CodecName); VideoSenderParameters parameters; parameters.codecs.push_back(cricket::CreateVideoCodec(kH264CodecName)); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false); webrtc::test::FrameForwarder frame_forwarder; EXPECT_TRUE(send_channel_->SetVideoSend(last_ssrc_, /*options=*/nullptr, @@ -8557,7 +8557,7 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoSenderParameters send_parameters; send_parameters.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters)); FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false); @@ -8611,7 +8611,7 @@ TEST_F(WebRtcVideoChannelTest, // Change codec to VP8. cricket::VideoSenderParameters vp8_parameters; vp8_parameters.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(send_channel_->SetSendParameters(vp8_parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(vp8_parameters)); frame_forwarder.IncomingCapturedFrame(frame_source_.GetFrame()); // The stream should be recreated due to codec change. @@ -8898,7 +8898,7 @@ TEST_F(WebRtcVideoChannelTest, BandwidthAboveTotalMaxBitrateGivenToMaxLayer) { send_parameters_.max_bandwidth_bps = GetTotalMaxBitrate(stream->GetVideoStreams()).bps(); ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps); - ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); // No bitrate above the total max to give to the highest layer. EXPECT_EQ(kNumSimulcastStreams, stream->GetVideoStreams().size()); @@ -8909,7 +8909,7 @@ TEST_F(WebRtcVideoChannelTest, BandwidthAboveTotalMaxBitrateGivenToMaxLayer) { send_parameters_.max_bandwidth_bps = GetTotalMaxBitrate(stream->GetVideoStreams()).bps() + 1; ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps); - ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); // The highest layer has no max bitrate set -> the bitrate above the total // max should be given to the highest layer. @@ -8947,7 +8947,7 @@ TEST_F(WebRtcVideoChannelTest, send_parameters_.max_bandwidth_bps = GetTotalMaxBitrate(stream->GetVideoStreams()).bps() + 1; ExpectSetMaxBitrate(send_parameters_.max_bandwidth_bps); - ASSERT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); // The highest layer has the max bitrate set -> the bitrate above the total // max should not be given to the highest layer. @@ -9176,7 +9176,7 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoSenderParameters parameters1; parameters1.codecs.push_back(GetEngineCodec("VP8")); parameters1.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters1)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters1)); FakeVideoSendStream* stream = AddSendStream(); EXPECT_TRUE(send_channel_->SetSend(true)); @@ -9197,7 +9197,7 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoSenderParameters parameters2; parameters2.codecs.push_back(GetEngineCodec("VP9")); parameters2.codecs.push_back(GetEngineCodec("VP8")); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters2)); + EXPECT_TRUE(send_channel_->SetSenderParameters(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. @@ -9215,7 +9215,7 @@ TEST_F(WebRtcVideoChannelTest, GetRtpSendParametersCodecs) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); webrtc::RtpParameters rtp_parameters = send_channel_->GetRtpSendParameters(last_ssrc_); @@ -9293,7 +9293,7 @@ TEST_F(WebRtcVideoChannelTest, SetAndGetRtpSendParameters) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); webrtc::RtpParameters initial_params = send_channel_->GetRtpSendParameters(last_ssrc_); @@ -9306,16 +9306,16 @@ TEST_F(WebRtcVideoChannelTest, SetAndGetRtpSendParameters) { EXPECT_EQ(initial_params, send_channel_->GetRtpSendParameters(last_ssrc_)); } -// Test that GetRtpReceiveParameters returns the currently configured codecs. +// Test that GetRtpReceiverParameters returns the currently configured codecs. TEST_F(WebRtcVideoChannelTest, GetRtpReceiveParametersCodecs) { AddRecvStream(); cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); webrtc::RtpParameters rtp_parameters = - receive_channel_->GetRtpReceiveParameters(last_ssrc_); + receive_channel_->GetRtpReceiverParameters(last_ssrc_); ASSERT_EQ(2u, rtp_parameters.codecs.size()); EXPECT_EQ(GetEngineCodec("VP8").ToCodecParameters(), rtp_parameters.codecs[0]); @@ -9335,13 +9335,13 @@ TEST_F(WebRtcVideoChannelTest, DISABLED_GetRtpReceiveFmtpSprop) { cricket::VideoCodec kH264sprop2 = cricket::CreateVideoCodec(102, "H264"); kH264sprop2.SetParam(kH264FmtpSpropParameterSets, "xyz"); parameters.codecs.push_back(kH264sprop2); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); FakeVideoReceiveStream* recv_stream = AddRecvStream(); const webrtc::VideoReceiveStreamInterface::Config& cfg = recv_stream->GetConfig(); webrtc::RtpParameters rtp_parameters = - receive_channel_->GetRtpReceiveParameters(last_ssrc_); + receive_channel_->GetRtpReceiverParameters(last_ssrc_); ASSERT_EQ(2u, rtp_parameters.codecs.size()); EXPECT_EQ(kH264sprop1.ToCodecParameters(), rtp_parameters.codecs[0]); ASSERT_EQ(2u, cfg.decoders.size()); @@ -9366,7 +9366,7 @@ TEST_F(WebRtcVideoChannelTest, GetRtpReceiveParametersSsrc) { AddRecvStream(); webrtc::RtpParameters rtp_parameters = - receive_channel_->GetRtpReceiveParameters(last_ssrc_); + receive_channel_->GetRtpReceiverParameters(last_ssrc_); ASSERT_EQ(1u, rtp_parameters.encodings.size()); EXPECT_EQ(last_ssrc_, rtp_parameters.encodings[0].ssrc); } @@ -9377,15 +9377,15 @@ TEST_F(WebRtcVideoChannelTest, SetAndGetRtpReceiveParameters) { cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); webrtc::RtpParameters initial_params = - receive_channel_->GetRtpReceiveParameters(last_ssrc_); + receive_channel_->GetRtpReceiverParameters(last_ssrc_); // ... And this shouldn't change the params returned by - // GetRtpReceiveParameters. + // GetRtpReceiverParameters. EXPECT_EQ(initial_params, - receive_channel_->GetRtpReceiveParameters(last_ssrc_)); + receive_channel_->GetRtpReceiverParameters(last_ssrc_)); } // Test that GetDefaultRtpReceiveParameters returns parameters correctly when @@ -9399,9 +9399,9 @@ TEST_F(WebRtcVideoChannelTest, cricket::VideoReceiverParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP9")); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); - // Call GetRtpReceiveParameters before configured to receive an unsignaled + // Call GetRtpReceiverParameters before configured to receive an unsignaled // stream. Should return nothing. EXPECT_EQ(webrtc::RtpParameters(), receive_channel_->GetDefaultRtpReceiveParameters()); @@ -9448,7 +9448,7 @@ TEST_F(WebRtcVideoChannelTest, void WebRtcVideoChannelTest::TestReceiverLocalSsrcConfiguration( bool receiver_first) { - EXPECT_TRUE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_TRUE(send_channel_->SetSenderParameters(send_parameters_)); const uint32_t kSenderSsrc = 0xC0FFEE; const uint32_t kSecondSenderSsrc = 0xBADCAFE; @@ -9657,7 +9657,7 @@ class WebRtcVideoChannelSimulcastTest : public ::testing::Test { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(codec); parameters.conference_mode = conference_mode; - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); std::vector ssrcs = MAKE_VECTOR(kSsrcs3); RTC_DCHECK(num_configured_streams <= ssrcs.size()); @@ -9890,7 +9890,7 @@ TEST_F(WebRtcVideoChannelBaseTest, EncoderSelectorSwitchCodec) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(vp9); - EXPECT_TRUE(send_channel_->SetSendParameters(parameters)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); send_channel_->SetSend(true); absl::optional codec = send_channel_->GetSendCodec(); @@ -9915,7 +9915,7 @@ TEST_F(WebRtcVideoChannelBaseTest, EncoderSelectorSwitchCodec) { TEST_F(WebRtcVideoChannelTest, RequestedResolutionSinglecast) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); webrtc::test::FrameForwarder frame_forwarder; @@ -9974,7 +9974,7 @@ TEST_F(WebRtcVideoChannelTest, RequestedResolutionSinglecast) { TEST_F(WebRtcVideoChannelTest, RequestedResolutionSinglecastCropping) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); webrtc::test::FrameForwarder frame_forwarder; @@ -10032,7 +10032,7 @@ TEST_F(WebRtcVideoChannelTest, RequestedResolutionSinglecastCropping) { TEST_F(WebRtcVideoChannelTest, RequestedResolutionSimulcast) { cricket::VideoSenderParameters parameters; parameters.codecs.push_back(GetEngineCodec("VP8")); - ASSERT_TRUE(send_channel_->SetSendParameters(parameters)); + ASSERT_TRUE(send_channel_->SetSenderParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(true, /*with_rtx=*/false); webrtc::test::FrameForwarder frame_forwarder; diff --git a/media/engine/webrtc_voice_engine.cc b/media/engine/webrtc_voice_engine.cc index 65363c286e..f9b6adb864 100644 --- a/media/engine/webrtc_voice_engine.cc +++ b/media/engine/webrtc_voice_engine.cc @@ -1262,11 +1262,11 @@ bool WebRtcVoiceSendChannel::SetOptions(const AudioOptions& options) { return true; } -bool WebRtcVoiceSendChannel::SetSendParameters( +bool WebRtcVoiceSendChannel::SetSenderParameters( const AudioSenderParameter& params) { - TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::SetSendParameters"); + TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::SetSenderParameters"); RTC_DCHECK_RUN_ON(worker_thread_); - RTC_LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetSendParameters: " + RTC_LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetSenderParameters: " << params.ToString(); // TODO(pthatcher): Refactor this to be more clean now that we have // all the information at once. @@ -1342,7 +1342,7 @@ absl::optional WebRtcVoiceSendChannel::GetSendCodec() const { return absl::nullopt; } -// Utility function called from SetSendParameters() to extract current send +// Utility function called from SetSenderParameters() to extract current send // codec settings from the given list of codecs (originally from SDP). Both send // and receive streams may be reconfigured based on the new settings. bool WebRtcVoiceSendChannel::SetSendCodecs( @@ -2042,11 +2042,11 @@ WebRtcVoiceReceiveChannel::~WebRtcVoiceReceiveChannel() { } } -bool WebRtcVoiceReceiveChannel::SetRecvParameters( +bool WebRtcVoiceReceiveChannel::SetReceiverParameters( const AudioReceiverParameters& params) { - TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::SetRecvParameters"); + TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::SetReceiverParameters"); RTC_DCHECK_RUN_ON(worker_thread_); - RTC_LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetRecvParameters: " + RTC_LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetReceiverParameters: " << params.ToString(); // TODO(pthatcher): Refactor this to be more clean now that we have // all the information at once. @@ -2069,7 +2069,7 @@ bool WebRtcVoiceReceiveChannel::SetRecvParameters( return true; } -webrtc::RtpParameters WebRtcVoiceReceiveChannel::GetRtpReceiveParameters( +webrtc::RtpParameters WebRtcVoiceReceiveChannel::GetRtpReceiverParameters( uint32_t ssrc) const { RTC_DCHECK_RUN_ON(worker_thread_); webrtc::RtpParameters rtp_params; diff --git a/media/engine/webrtc_voice_engine.h b/media/engine/webrtc_voice_engine.h index 868c78b30b..a3e6d3acab 100644 --- a/media/engine/webrtc_voice_engine.h +++ b/media/engine/webrtc_voice_engine.h @@ -227,7 +227,7 @@ class WebRtcVoiceSendChannel final : public MediaChannelUtil, const AudioOptions& options() const { return options_; } - bool SetSendParameters(const AudioSenderParameter& params) override; + bool SetSenderParameters(const AudioSenderParameter& params) override; webrtc::RtpParameters GetRtpSendParameters(uint32_t ssrc) const override; webrtc::RTCError SetRtpSendParameters( uint32_t ssrc, @@ -378,8 +378,8 @@ class WebRtcVoiceReceiveChannel final void SetInterface(MediaChannelNetworkInterface* iface) override { MediaChannelUtil::SetInterface(iface); } - bool SetRecvParameters(const AudioReceiverParameters& params) override; - webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override; + bool SetReceiverParameters(const AudioReceiverParameters& params) override; + webrtc::RtpParameters GetRtpReceiverParameters(uint32_t ssrc) const override; webrtc::RtpParameters GetDefaultRtpReceiveParameters() const override; void SetPlayout(bool playout) override; diff --git a/media/engine/webrtc_voice_engine_unittest.cc b/media/engine/webrtc_voice_engine_unittest.cc index d3902e4db0..e1d7805180 100644 --- a/media/engine/webrtc_voice_engine_unittest.cc +++ b/media/engine/webrtc_voice_engine_unittest.cc @@ -340,9 +340,9 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { send_channel_->SetSend(enable); } - void SetSendParameters(const cricket::AudioSenderParameter& params) { + void SetSenderParameters(const cricket::AudioSenderParameter& params) { ASSERT_TRUE(send_channel_); - EXPECT_TRUE(send_channel_->SetSendParameters(params)); + EXPECT_TRUE(send_channel_->SetSenderParameters(params)); } void SetAudioSend(uint32_t ssrc, @@ -368,12 +368,12 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { } // Test we can only InsertDtmf when the other side supports telephone-event. - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); SetSend(true); EXPECT_FALSE(send_channel_->CanInsertDtmf()); EXPECT_FALSE(send_channel_->InsertDtmf(ssrc, 1, 111)); send_parameters_.codecs.push_back(codec); - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); EXPECT_TRUE(send_channel_->CanInsertDtmf()); if (!caller) { @@ -400,12 +400,12 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { void TestExtmapAllowMixedCaller(bool extmap_allow_mixed) { // For a caller, the answer will be applied in set remote description - // where SetSendParameters() is called. + // where SetSenderParameters() is called. EXPECT_TRUE(SetupChannel()); EXPECT_TRUE(send_channel_->AddSendStream( cricket::StreamParams::CreateLegacy(kSsrcX))); send_parameters_.extmap_allow_mixed = extmap_allow_mixed; - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); const webrtc::AudioSendStream::Config& config = GetSendStreamConfig(kSsrcX); EXPECT_EQ(extmap_allow_mixed, config.rtp.extmap_allow_mixed); } @@ -435,9 +435,9 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { parameters.codecs.push_back(codec); parameters.max_bandwidth_bps = max_bitrate; if (expected_result) { - SetSendParameters(parameters); + SetSenderParameters(parameters); } else { - EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSenderParameters(parameters)); } EXPECT_EQ(expected_bitrate, GetCodecBitrate(kSsrcX)); } @@ -456,7 +456,7 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { cricket::AudioSenderParameter send_parameters; send_parameters.codecs.push_back(codec); send_parameters.max_bandwidth_bps = bitrate; - SetSendParameters(send_parameters); + SetSenderParameters(send_parameters); } void CheckSendCodecBitrate(int32_t ssrc, @@ -527,7 +527,7 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { Field(&BitrateConstraints::max_bitrate_bps, expected_max_bitrate_bps)))); - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); } void TestSetSendRtpHeaderExtensions(const std::string& ext) { @@ -539,18 +539,18 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { // Ensure unknown extensions won't cause an error. send_parameters_.extensions.push_back( webrtc::RtpExtension("urn:ietf:params:unknownextention", 1)); - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); EXPECT_EQ(0u, GetSendStreamConfig(kSsrcX).rtp.extensions.size()); // Ensure extensions stay off with an empty list of headers. send_parameters_.extensions.clear(); - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); EXPECT_EQ(0u, GetSendStreamConfig(kSsrcX).rtp.extensions.size()); // Ensure extension is set properly. const int id = 1; send_parameters_.extensions.push_back(webrtc::RtpExtension(ext, id)); - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); EXPECT_EQ(1u, GetSendStreamConfig(kSsrcX).rtp.extensions.size()); EXPECT_EQ(ext, GetSendStreamConfig(kSsrcX).rtp.extensions[0].uri); EXPECT_EQ(id, GetSendStreamConfig(kSsrcX).rtp.extensions[0].id); @@ -567,7 +567,7 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { // Ensure all extensions go back off with an empty list. send_parameters_.codecs.push_back(kPcmuCodec); send_parameters_.extensions.clear(); - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); EXPECT_EQ(0u, GetSendStreamConfig(kSsrcX).rtp.extensions.size()); EXPECT_EQ(0u, GetSendStreamConfig(kSsrcY).rtp.extensions.size()); } @@ -577,46 +577,46 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam { // Ensure extensions are off by default. EXPECT_THAT( - receive_channel_->GetRtpReceiveParameters(kSsrcX).header_extensions, + receive_channel_->GetRtpReceiverParameters(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(receive_channel_->SetRecvParameters(recv_parameters_)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); EXPECT_THAT( - receive_channel_->GetRtpReceiveParameters(kSsrcX).header_extensions, + receive_channel_->GetRtpReceiverParameters(kSsrcX).header_extensions, IsEmpty()); // Ensure extensions stay off with an empty list of headers. recv_parameters_.extensions.clear(); - EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); EXPECT_THAT( - receive_channel_->GetRtpReceiveParameters(kSsrcX).header_extensions, + receive_channel_->GetRtpReceiverParameters(kSsrcX).header_extensions, IsEmpty()); // Ensure extension is set properly. const int id = 2; recv_parameters_.extensions.push_back(webrtc::RtpExtension(ext, id)); - EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); EXPECT_EQ( - receive_channel_->GetRtpReceiveParameters(kSsrcX).header_extensions, + receive_channel_->GetRtpReceiverParameters(kSsrcX).header_extensions, recv_parameters_.extensions); // Ensure extension is set properly on new stream. EXPECT_TRUE(AddRecvStream(kSsrcY)); EXPECT_EQ( - receive_channel_->GetRtpReceiveParameters(kSsrcY).header_extensions, + receive_channel_->GetRtpReceiverParameters(kSsrcY).header_extensions, recv_parameters_.extensions); // Ensure all extensions go back off with an empty list. recv_parameters_.extensions.clear(); - EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); EXPECT_THAT( - receive_channel_->GetRtpReceiveParameters(kSsrcX).header_extensions, + receive_channel_->GetRtpReceiverParameters(kSsrcX).header_extensions, IsEmpty()); EXPECT_THAT( - receive_channel_->GetRtpReceiveParameters(kSsrcY).header_extensions, + receive_channel_->GetRtpReceiverParameters(kSsrcY).header_extensions, IsEmpty()); } @@ -910,7 +910,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(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); EXPECT_TRUE(AddRecvStream(kSsrcX)); EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, (ContainerEq>( @@ -926,7 +926,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsUnsupportedCodec) { cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(cricket::CreateAudioCodec(127, "XYZ", 32000, 1)); - EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters)); } // Test that we fail if we have duplicate types in the inbound list. @@ -936,7 +936,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsDuplicatePayloadType) { parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kCn16000Codec); parameters.codecs[1].id = kOpusCodec.id; - EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters)); } // Test that we can decode OPUS without stereo parameters. @@ -945,7 +945,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpusNoStereo) { cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kOpusCodec); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); EXPECT_TRUE(AddRecvStream(kSsrcX)); EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, (ContainerEq>( @@ -959,7 +959,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus0Stereo) { parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kOpusCodec); parameters.codecs[1].params["stereo"] = "0"; - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); EXPECT_TRUE(AddRecvStream(kSsrcX)); EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, (ContainerEq>( @@ -974,7 +974,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus1Stereo) { parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kOpusCodec); parameters.codecs[1].params["stereo"] = "1"; - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); EXPECT_TRUE(AddRecvStream(kSsrcX)); EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, (ContainerEq>( @@ -992,7 +992,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(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); for (const auto& ssrc : {kSsrcX, kSsrcY}) { EXPECT_TRUE(AddRecvStream(ssrc)); EXPECT_THAT(GetRecvStreamConfig(ssrc).decoder_map, @@ -1009,7 +1009,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsAfterAddingStreams) { cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].id = 106; // collide with existing CN 32k - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); const auto& dm = GetRecvStreamConfig(kSsrcX).decoder_map; ASSERT_EQ(1u, dm.count(106)); @@ -1022,14 +1022,14 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWhilePlaying) { cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kCn16000Codec); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); receive_channel_->SetPlayout(true); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); // Remapping a payload type to a different codec should fail. parameters.codecs[0] = kOpusCodec; parameters.codecs[0].id = kPcmuCodec.id; - EXPECT_FALSE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters)); EXPECT_TRUE(GetRecvStream(kSsrcX).started()); } @@ -1039,11 +1039,11 @@ TEST_P(WebRtcVoiceEngineTestFake, AddRecvCodecsWhilePlaying) { cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kCn16000Codec); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); receive_channel_->SetPlayout(true); parameters.codecs.push_back(kOpusCodec); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); EXPECT_TRUE(GetRecvStream(kSsrcX).started()); } @@ -1053,10 +1053,10 @@ TEST_P(WebRtcVoiceEngineTestFake, ChangeRecvCodecPayloadType) { EXPECT_TRUE(SetupRecvStream()); cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); ++parameters.codecs[0].id; - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); } // Test that we do allow setting Opus/Red by default. @@ -1066,7 +1066,7 @@ TEST_P(WebRtcVoiceEngineTestFake, RecvRedDefault) { parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kRed48000Codec); parameters.codecs[1].params[""] = "111/111"; - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, (ContainerEq>( {{111, {"opus", 48000, 2}}, @@ -1119,7 +1119,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) { cricket::AudioSenderParameter parameters; parameters.codecs = engine_->send_codecs(); parameters.max_bandwidth_bps = kDesiredBitrate; - SetSendParameters(parameters); + SetSenderParameters(parameters); EXPECT_TRUE(send_channel_->AddSendStream( cricket::StreamParams::CreateLegacy(kSsrcX))); @@ -1134,15 +1134,15 @@ TEST_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) { EXPECT_TRUE(SetupSendStream()); // PCMU, default bitrate == 64000. - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); send_parameters_.max_bandwidth_bps = 128000; - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); send_parameters_.max_bandwidth_bps = 128; - EXPECT_FALSE(send_channel_->SetSendParameters(send_parameters_)); + EXPECT_FALSE(send_channel_->SetSenderParameters(send_parameters_)); EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); } @@ -1254,7 +1254,7 @@ TEST_P(WebRtcVoiceEngineTestFake, EXPECT_TRUE(SetupSendStream()); send_parameters_.options.audio_network_adaptor = true; send_parameters_.options.audio_network_adaptor_config = {"1234"}; - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, GetAudioNetworkAdaptorConfig(kSsrcX)); @@ -1308,7 +1308,7 @@ TEST_P(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) { cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); - SetSendParameters(parameters); + SetSenderParameters(parameters); webrtc::RtpParameters rtp_parameters = send_channel_->GetRtpSendParameters(kSsrcX); @@ -1358,7 +1358,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetAndGetRtpSendParameters) { cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); - SetSendParameters(parameters); + SetSenderParameters(parameters); webrtc::RtpParameters initial_params = send_channel_->GetRtpSendParameters(kSsrcX); @@ -1380,7 +1380,7 @@ TEST_P(WebRtcVoiceEngineTestFake, cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); - SetSendParameters(parameters); + SetSenderParameters(parameters); webrtc::RtpParameters initial_params = send_channel_->GetRtpSendParameters(kSsrcX); @@ -1398,7 +1398,7 @@ TEST_P(WebRtcVoiceEngineTestFake, parameters.codecs.clear(); parameters.codecs.push_back(kPcmuCodec); - SetSendParameters(parameters); + SetSenderParameters(parameters); // Since Opus is no longer negotiated, the RTP parameters should not have a // forced codec anymore. @@ -1413,7 +1413,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRtpSendParameterUpdatesMaxBitrate) { EXPECT_TRUE(SetupSendStream()); cricket::AudioSenderParameter send_parameters; send_parameters.codecs.push_back(kOpusCodec); - SetSendParameters(send_parameters); + SetSenderParameters(send_parameters); webrtc::RtpParameters rtp_parameters = send_channel_->GetRtpSendParameters(kSsrcX); @@ -1468,26 +1468,26 @@ TEST_P(WebRtcVoiceEngineTestFake, SetRtpSendParameterUpdatesBitratePriority) { EXPECT_EQ(new_bitrate_priority, GetSendStreamConfig(kSsrcX).bitrate_priority); } -// Test that GetRtpReceiveParameters returns the currently configured codecs. +// Test that GetRtpReceiverParameters returns the currently configured codecs. TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersCodecs) { EXPECT_TRUE(SetupRecvStream()); cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); webrtc::RtpParameters rtp_parameters = - receive_channel_->GetRtpReceiveParameters(kSsrcX); + receive_channel_->GetRtpReceiverParameters(kSsrcX); ASSERT_EQ(2u, rtp_parameters.codecs.size()); EXPECT_EQ(kOpusCodec.ToCodecParameters(), rtp_parameters.codecs[0]); EXPECT_EQ(kPcmuCodec.ToCodecParameters(), rtp_parameters.codecs[1]); } -// Test that GetRtpReceiveParameters returns an SSRC. +// Test that GetRtpReceiverParameters returns an SSRC. TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersSsrc) { EXPECT_TRUE(SetupRecvStream()); webrtc::RtpParameters rtp_parameters = - receive_channel_->GetRtpReceiveParameters(kSsrcX); + receive_channel_->GetRtpReceiverParameters(kSsrcX); ASSERT_EQ(1u, rtp_parameters.encodings.size()); EXPECT_EQ(kSsrcX, rtp_parameters.encodings[0].ssrc); } @@ -1498,19 +1498,19 @@ TEST_P(WebRtcVoiceEngineTestFake, SetAndGetRtpReceiveParameters) { cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); webrtc::RtpParameters initial_params = - receive_channel_->GetRtpReceiveParameters(kSsrcX); + receive_channel_->GetRtpReceiverParameters(kSsrcX); // ... And this shouldn't change the params returned by - // GetRtpReceiveParameters. + // GetRtpReceiverParameters. webrtc::RtpParameters new_params = - receive_channel_->GetRtpReceiveParameters(kSsrcX); - EXPECT_EQ(initial_params, receive_channel_->GetRtpReceiveParameters(kSsrcX)); + receive_channel_->GetRtpReceiverParameters(kSsrcX); + EXPECT_EQ(initial_params, receive_channel_->GetRtpReceiverParameters(kSsrcX)); } -// Test that GetRtpReceiveParameters returns parameters correctly when SSRCs +// Test that GetRtpReceiverParameters returns parameters correctly when SSRCs // aren't signaled. It should return an empty "RtpEncodingParameters" when // configured to receive an unsignaled stream and no packets have been received // yet, and start returning the SSRC once a packet has been received. @@ -1521,7 +1521,7 @@ TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersWithUnsignaledSsrc) { cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); // Call GetDefaultRtpReceiveParameters before configured to receive an // unsignaled stream. Should return nothing. @@ -1552,7 +1552,7 @@ TEST_P(WebRtcVoiceEngineTestFake, OnPacketReceivedIdentifiesExtensions) { cricket::AudioReceiverParameters parameters = recv_parameters_; parameters.extensions.push_back( RtpExtension(RtpExtension::kAudioLevelUri, /*id=*/1)); - ASSERT_TRUE(receive_channel_->SetRecvParameters(parameters)); + ASSERT_TRUE(receive_channel_->SetReceiverParameters(parameters)); webrtc::RtpHeaderExtensionMap extension_map(parameters.extensions); webrtc::RtpPacketReceived reference_packet(&extension_map); constexpr uint8_t kAudioLevel = 123; @@ -1581,7 +1581,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecs) { parameters.codecs.push_back(kCn8000Codec); parameters.codecs[0].id = 96; parameters.codecs[0].bitrate = 22000; - SetSendParameters(parameters); + SetSenderParameters(parameters); const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(96, send_codec_spec.payload_type); EXPECT_EQ(22000, send_codec_spec.target_bitrate_bps); @@ -1599,7 +1599,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRed) { parameters.codecs.push_back(kRed48000Codec); parameters.codecs[0].params[""] = "111/111"; parameters.codecs.push_back(kOpusCodec); - SetSendParameters(parameters); + SetSenderParameters(parameters); const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(111, send_codec_spec.payload_type); EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str()); @@ -1613,7 +1613,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedNoFmtp) { cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kRed48000Codec); parameters.codecs.push_back(kOpusCodec); - SetSendParameters(parameters); + SetSenderParameters(parameters); const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(111, send_codec_spec.payload_type); EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str()); @@ -1627,7 +1627,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedDefault) { parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kRed48000Codec); parameters.codecs[1].params[""] = "111/111"; - SetSendParameters(parameters); + SetSenderParameters(parameters); const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(111, send_codec_spec.payload_type); EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str()); @@ -1641,7 +1641,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedFmtpMismatch) { parameters.codecs.push_back(kRed48000Codec); parameters.codecs[0].params[""] = "8/8"; parameters.codecs.push_back(kOpusCodec); - SetSendParameters(parameters); + SetSenderParameters(parameters); const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(111, send_codec_spec.payload_type); EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str()); @@ -1655,21 +1655,21 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedFmtpAmountOfRedundancy) { parameters.codecs.push_back(kRed48000Codec); parameters.codecs[0].params[""] = "111"; parameters.codecs.push_back(kOpusCodec); - SetSendParameters(parameters); + SetSenderParameters(parameters); const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(111, send_codec_spec.payload_type); EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str()); EXPECT_EQ(absl::nullopt, send_codec_spec.red_payload_type); for (int i = 1; i < 32; i++) { parameters.codecs[0].params[""] += "/111"; - SetSendParameters(parameters); + SetSenderParameters(parameters); const auto& send_codec_spec2 = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(111, send_codec_spec2.payload_type); EXPECT_STRCASEEQ("opus", send_codec_spec2.format.name.c_str()); EXPECT_EQ(112, send_codec_spec2.red_payload_type); } parameters.codecs[0].params[""] += "/111"; - SetSendParameters(parameters); + SetSenderParameters(parameters); const auto& send_codec_spec3 = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(111, send_codec_spec3.payload_type); EXPECT_STRCASEEQ("opus", send_codec_spec3.format.name.c_str()); @@ -1687,11 +1687,11 @@ TEST_P(WebRtcVoiceEngineTestFake, DontRecreateSendStream) { parameters.codecs[0].id = 96; parameters.codecs[0].bitrate = 48000; const int initial_num = call_.GetNumCreatedSendStreams(); - SetSendParameters(parameters); + SetSenderParameters(parameters); EXPECT_EQ(initial_num, call_.GetNumCreatedSendStreams()); // Calling SetSendCodec again with same codec which is already set. // In this case media channel shouldn't send codec to VoE. - SetSendParameters(parameters); + SetSenderParameters(parameters); EXPECT_EQ(initial_num, call_.GetNumCreatedSendStreams()); } @@ -1705,7 +1705,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; parameters.codecs[0].clockrate = 50000; - EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSenderParameters(parameters)); } // Test that if channels=0 for opus, we fail. @@ -1715,7 +1715,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0ChannelsNoStereo) { parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; parameters.codecs[0].channels = 0; - EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSenderParameters(parameters)); } // Test that if channels=0 for opus, we fail. @@ -1726,7 +1726,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0Channels1Stereo) { parameters.codecs[0].bitrate = 0; parameters.codecs[0].channels = 0; parameters.codecs[0].params["stereo"] = "1"; - EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSenderParameters(parameters)); } // Test that if channel is 1 for opus and there's no stereo, we fail. @@ -1736,7 +1736,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpus1ChannelNoStereo) { parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; parameters.codecs[0].channels = 1; - EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSenderParameters(parameters)); } // Test that if channel is 1 for opus and stereo=0, we fail. @@ -1747,7 +1747,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel0Stereo) { parameters.codecs[0].bitrate = 0; parameters.codecs[0].channels = 1; parameters.codecs[0].params["stereo"] = "0"; - EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSenderParameters(parameters)); } // Test that if channel is 1 for opus and stereo=1, we fail. @@ -1758,7 +1758,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) { parameters.codecs[0].bitrate = 0; parameters.codecs[0].channels = 1; parameters.codecs[0].params["stereo"] = "1"; - EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSenderParameters(parameters)); } // Test that with bitrate=0 and no stereo, bitrate is 32000. @@ -1767,7 +1767,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) { cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; - SetSendParameters(parameters); + SetSenderParameters(parameters); CheckSendCodecBitrate(kSsrcX, "opus", 32000); } @@ -1778,7 +1778,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) { parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; parameters.codecs[0].params["stereo"] = "0"; - SetSendParameters(parameters); + SetSenderParameters(parameters); CheckSendCodecBitrate(kSsrcX, "opus", 32000); } @@ -1790,11 +1790,11 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) { parameters.codecs[0].params["stereo"] = "0"; // bitrate that's out of the range between 6000 and 510000 will be clamped. parameters.codecs[0].bitrate = 5999; - SetSendParameters(parameters); + SetSenderParameters(parameters); CheckSendCodecBitrate(kSsrcX, "opus", 6000); parameters.codecs[0].bitrate = 510001; - SetSendParameters(parameters); + SetSenderParameters(parameters); CheckSendCodecBitrate(kSsrcX, "opus", 510000); } @@ -1805,7 +1805,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) { parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 0; parameters.codecs[0].params["stereo"] = "1"; - SetSendParameters(parameters); + SetSenderParameters(parameters); CheckSendCodecBitrate(kSsrcX, "opus", 64000); } @@ -1817,11 +1817,11 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) { parameters.codecs[0].params["stereo"] = "1"; // bitrate that's out of the range between 6000 and 510000 will be clamped. parameters.codecs[0].bitrate = 5999; - SetSendParameters(parameters); + SetSenderParameters(parameters); CheckSendCodecBitrate(kSsrcX, "opus", 6000); parameters.codecs[0].bitrate = 510001; - SetSendParameters(parameters); + SetSenderParameters(parameters); CheckSendCodecBitrate(kSsrcX, "opus", 510000); } @@ -1831,7 +1831,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 96000; - SetSendParameters(parameters); + SetSenderParameters(parameters); const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(111, spec.payload_type); EXPECT_EQ(96000, spec.target_bitrate_bps); @@ -1847,7 +1847,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 30000; parameters.codecs[0].params["stereo"] = "0"; - SetSendParameters(parameters); + SetSenderParameters(parameters); CheckSendCodecBitrate(kSsrcX, "opus", 30000); } @@ -1857,7 +1857,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) { cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 30000; - SetSendParameters(parameters); + SetSenderParameters(parameters); CheckSendCodecBitrate(kSsrcX, "opus", 30000); } @@ -1868,7 +1868,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].bitrate = 30000; parameters.codecs[0].params["stereo"] = "1"; - SetSendParameters(parameters); + SetSenderParameters(parameters); CheckSendCodecBitrate(kSsrcX, "opus", 30000); } @@ -1901,7 +1901,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthForAudioDoesntAffectBwe) { AllOf(Field(&BitrateConstraints::min_bitrate_bps, 100000), Field(&BitrateConstraints::start_bitrate_bps, -1), Field(&BitrateConstraints::max_bitrate_bps, 200000)))); - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); } // Test that we can enable NACK with opus as callee. @@ -1912,7 +1912,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) { parameters.codecs[0].AddFeedbackParam(cricket::FeedbackParam( cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)); EXPECT_EQ(0, GetRecvStreamConfig(kSsrcX).rtp.nack.rtp_history_ms); - SetSendParameters(parameters); + SetSenderParameters(parameters); // NACK should be enabled even with no send stream. EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcX).rtp.nack.rtp_history_ms); @@ -1929,7 +1929,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackRecvStreams) { parameters.codecs[0].AddFeedbackParam(cricket::FeedbackParam( cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)); EXPECT_EQ(0, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms); - SetSendParameters(parameters); + SetSenderParameters(parameters); EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms); } @@ -1941,12 +1941,12 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecDisableNackRecvStreams) { parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].AddFeedbackParam(cricket::FeedbackParam( cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)); - SetSendParameters(parameters); + SetSenderParameters(parameters); EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms); parameters.codecs.clear(); parameters.codecs.push_back(kOpusCodec); - SetSendParameters(parameters); + SetSenderParameters(parameters); EXPECT_EQ(0, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms); } @@ -1958,7 +1958,7 @@ TEST_P(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) { parameters.codecs.push_back(kCn16000Codec); parameters.codecs[0].AddFeedbackParam(cricket::FeedbackParam( cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)); - SetSendParameters(parameters); + SetSenderParameters(parameters); EXPECT_TRUE(AddRecvStream(kSsrcY)); EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms); @@ -1972,7 +1972,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsOpusPcmuSwitching) { cricket::AudioSenderParameter opus_parameters; opus_parameters.codecs.push_back(kOpusCodec); - SetSendParameters(opus_parameters); + SetSenderParameters(opus_parameters); { const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(111, spec.payload_type); @@ -1983,14 +1983,14 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsOpusPcmuSwitching) { pcmu_parameters.codecs.push_back(kPcmuCodec); pcmu_parameters.codecs.push_back(kCn16000Codec); pcmu_parameters.codecs.push_back(kOpusCodec); - SetSendParameters(pcmu_parameters); + SetSenderParameters(pcmu_parameters); { const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(0, spec.payload_type); EXPECT_STRCASEEQ("PCMU", spec.format.name.c_str()); } - SetSendParameters(opus_parameters); + SetSenderParameters(opus_parameters); { const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(111, spec.payload_type); @@ -2003,7 +2003,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { EXPECT_TRUE(SetupSendStream()); cricket::AudioSenderParameter parameters; parameters.codecs.push_back(kPcmuCodec); - SetSendParameters(parameters); + SetSenderParameters(parameters); { const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(0, spec.payload_type); @@ -2012,7 +2012,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { } parameters.codecs[0].bitrate = 0; // bitrate == default - SetSendParameters(parameters); + SetSenderParameters(parameters); { const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(0, spec.payload_type); @@ -2022,7 +2022,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { parameters.codecs[0] = kOpusCodec; parameters.codecs[0].bitrate = 0; // bitrate == default - SetSendParameters(parameters); + SetSenderParameters(parameters); { const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(111, spec.payload_type); @@ -2035,7 +2035,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { EXPECT_TRUE(SetupSendStream()); cricket::AudioSenderParameter parameters; - EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSenderParameters(parameters)); } // Test that we can set send codecs even with telephone-event codec as the first @@ -2048,7 +2048,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { parameters.codecs.push_back(kPcmuCodec); parameters.codecs[0].id = 98; // DTMF parameters.codecs[1].id = 96; - SetSendParameters(parameters); + SetSenderParameters(parameters); const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(96, spec.payload_type); EXPECT_STRCASEEQ("OPUS", spec.format.name.c_str()); @@ -2064,7 +2064,7 @@ TEST_P(WebRtcVoiceEngineTestFake, DTMFControlledBySendFlag) { parameters.codecs.push_back(kPcmuCodec); parameters.codecs[0].id = 98; // DTMF parameters.codecs[1].id = 96; - SetSendParameters(parameters); + SetSenderParameters(parameters); EXPECT_FALSE(send_channel_->CanInsertDtmf()); SetSend(true); EXPECT_TRUE(send_channel_->CanInsertDtmf()); @@ -2080,17 +2080,17 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { parameters.codecs.push_back(kOpusCodec); parameters.codecs[0].id = 0; // DTMF parameters.codecs[1].id = 96; - SetSendParameters(parameters); + SetSenderParameters(parameters); SetSend(true); EXPECT_TRUE(send_channel_->CanInsertDtmf()); parameters.codecs[0].id = 128; // DTMF - EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSenderParameters(parameters)); EXPECT_FALSE(send_channel_->CanInsertDtmf()); parameters.codecs[0].id = 127; - SetSendParameters(parameters); + SetSenderParameters(parameters); EXPECT_TRUE(send_channel_->CanInsertDtmf()); parameters.codecs[0].id = -1; // DTMF - EXPECT_FALSE(send_channel_->SetSendParameters(parameters)); + EXPECT_FALSE(send_channel_->SetSenderParameters(parameters)); EXPECT_FALSE(send_channel_->CanInsertDtmf()); } @@ -2102,7 +2102,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { parameters.codecs.push_back(kCn8000Codec); parameters.codecs.push_back(kPcmuCodec); parameters.codecs[0].id = 98; // narrowband CN - SetSendParameters(parameters); + SetSenderParameters(parameters); const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(0, send_codec_spec.payload_type); EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); @@ -2120,7 +2120,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { parameters.codecs[0].id = 96; parameters.codecs[2].id = 97; // narrowband CN parameters.codecs[3].id = 98; // DTMF - SetSendParameters(parameters); + SetSenderParameters(parameters); const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(96, send_codec_spec.payload_type); EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); @@ -2141,7 +2141,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { parameters.codecs[0].id = 96; parameters.codecs[2].id = 97; // narrowband CN parameters.codecs[3].id = 98; // DTMF - SetSendParameters(parameters); + SetSenderParameters(parameters); EXPECT_TRUE(send_channel_->AddSendStream( cricket::StreamParams::CreateLegacy(kSsrcX))); @@ -2163,7 +2163,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kCn16000Codec); parameters.codecs[1].id = 97; - SetSendParameters(parameters); + SetSenderParameters(parameters); { const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); @@ -2171,7 +2171,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { } // Set PCMU(8K) and CN(8K). VAD should be activated. parameters.codecs[1] = kCn8000Codec; - SetSendParameters(parameters); + SetSenderParameters(parameters); { const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); @@ -2180,7 +2180,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { } // Set OPUS(48K) and CN(8K). VAD should not be activated. parameters.codecs[0] = kOpusCodec; - SetSendParameters(parameters); + SetSenderParameters(parameters); { const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_STRCASEEQ("OPUS", send_codec_spec.format.name.c_str()); @@ -2200,7 +2200,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { parameters.codecs[0].id = 96; parameters.codecs[2].id = 97; // narrowband CN parameters.codecs[3].id = 98; // DTMF - SetSendParameters(parameters); + SetSenderParameters(parameters); const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; EXPECT_EQ(96, send_codec_spec.payload_type); EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); @@ -2241,7 +2241,7 @@ TEST_P(WebRtcVoiceEngineTestFake, RecvTransportSequenceNumberHeaderExtensions) { // Test that we can create a channel and start sending on it. TEST_P(WebRtcVoiceEngineTestFake, Send) { EXPECT_TRUE(SetupSendStream()); - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); SetSend(true); EXPECT_TRUE(GetSendStream(kSsrcX).IsSending()); SetSend(false); @@ -2252,7 +2252,7 @@ TEST_P(WebRtcVoiceEngineTestFake, Send) { // for sending. TEST_P(WebRtcVoiceEngineTestFake, SendStateWithAndWithoutSource) { EXPECT_TRUE(SetupSendStream()); - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); SetAudioSend(kSsrcX, true, nullptr); SetSend(true); EXPECT_FALSE(GetSendStream(kSsrcX).IsSending()); @@ -2265,7 +2265,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SendStateWithAndWithoutSource) { // Test that a channel is muted/unmuted. TEST_P(WebRtcVoiceEngineTestFake, SendStateMuteUnmute) { EXPECT_TRUE(SetupSendStream()); - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); EXPECT_FALSE(GetSendStream(kSsrcX).muted()); SetAudioSend(kSsrcX, true, nullptr); EXPECT_FALSE(GetSendStream(kSsrcX).muted()); @@ -2273,7 +2273,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SendStateMuteUnmute) { EXPECT_TRUE(GetSendStream(kSsrcX).muted()); } -// Test that SetSendParameters() does not alter a stream's send state. +// Test that SetSenderParameters() does not alter a stream's send state. TEST_P(WebRtcVoiceEngineTestFake, SendStateWhenStreamsAreRecreated) { EXPECT_TRUE(SetupSendStream()); EXPECT_FALSE(GetSendStream(kSsrcX).IsSending()); @@ -2285,7 +2285,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SendStateWhenStreamsAreRecreated) { // Changing RTP header extensions will recreate the AudioSendStream. send_parameters_.extensions.push_back( webrtc::RtpExtension(webrtc::RtpExtension::kAudioLevelUri, 12)); - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); EXPECT_TRUE(GetSendStream(kSsrcX).IsSending()); // Turn off sending. @@ -2294,14 +2294,14 @@ TEST_P(WebRtcVoiceEngineTestFake, SendStateWhenStreamsAreRecreated) { // Changing RTP header extensions will recreate the AudioSendStream. send_parameters_.extensions.clear(); - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); EXPECT_FALSE(GetSendStream(kSsrcX).IsSending()); } // Test that we can create a channel and start playing out on it. TEST_P(WebRtcVoiceEngineTestFake, Playout) { EXPECT_TRUE(SetupRecvStream()); - EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); receive_channel_->SetPlayout(true); EXPECT_TRUE(GetRecvStream(kSsrcX).started()); receive_channel_->SetPlayout(false); @@ -2348,7 +2348,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) { parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kCn8000Codec); parameters.codecs[1].id = 97; - SetSendParameters(parameters); + SetSenderParameters(parameters); // Verify PCMU and VAD are corrected configured on all send channels. for (uint32_t ssrc : kSsrcs4) { @@ -2363,7 +2363,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) { // Change to PCMU(8K) and CN(16K). parameters.codecs[0] = kPcmuCodec; parameters.codecs[1] = kCn16000Codec; - SetSendParameters(parameters); + SetSenderParameters(parameters); for (uint32_t ssrc : kSsrcs4) { ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); const auto& send_codec_spec = @@ -2415,8 +2415,8 @@ TEST_P(WebRtcVoiceEngineTestFake, GetStatsWithMultipleSendStreams) { EXPECT_TRUE(AddRecvStream(kSsrcY)); // We need send codec to be set to get all stats. - SetSendParameters(send_parameters_); - EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); + SetSenderParameters(send_parameters_); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); SetAudioSendStreamStats(); SetAudioReceiveStreamStats(); @@ -2481,7 +2481,7 @@ TEST_P(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) { EXPECT_TRUE(SetupSendStream()); // Start playout without a receive stream. - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); receive_channel_->SetPlayout(true); // Adding another stream should enable playout on the new stream only. @@ -2520,7 +2520,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetAudioNetworkAdaptorViaOptions) { EXPECT_TRUE(SetupSendStream()); send_parameters_.options.audio_network_adaptor = true; send_parameters_.options.audio_network_adaptor_config = {"1234"}; - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, GetAudioNetworkAdaptorConfig(kSsrcX)); } @@ -2529,7 +2529,7 @@ TEST_P(WebRtcVoiceEngineTestFake, AudioSendResetAudioNetworkAdaptor) { EXPECT_TRUE(SetupSendStream()); send_parameters_.options.audio_network_adaptor = true; send_parameters_.options.audio_network_adaptor_config = {"1234"}; - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, GetAudioNetworkAdaptorConfig(kSsrcX)); cricket::AudioOptions options; @@ -2542,7 +2542,7 @@ TEST_P(WebRtcVoiceEngineTestFake, AudioNetworkAdaptorNotGetOverridden) { EXPECT_TRUE(SetupSendStream()); send_parameters_.options.audio_network_adaptor = true; send_parameters_.options.audio_network_adaptor_config = {"1234"}; - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, GetAudioNetworkAdaptorConfig(kSsrcX)); const int initial_num = call_.GetNumCreatedSendStreams(); @@ -2570,8 +2570,8 @@ TEST_P(WebRtcVoiceEngineTestFake, GetStats) { // SetupSendStream adds a send stream with kSsrcX, so the receive // stream has to use a different SSRC. EXPECT_TRUE(AddRecvStream(kSsrcY)); - SetSendParameters(send_parameters_); - EXPECT_TRUE(receive_channel_->SetRecvParameters(recv_parameters_)); + SetSenderParameters(send_parameters_); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); SetAudioSendStreamStats(); // Check stats for the added streams. @@ -2933,7 +2933,7 @@ TEST_P(WebRtcVoiceEngineTestFake, AddRecvStreamUnsupportedCodec) { cricket::AudioReceiverParameters parameters; parameters.codecs.push_back(kOpusCodec); parameters.codecs.push_back(kPcmuCodec); - EXPECT_TRUE(receive_channel_->SetRecvParameters(parameters)); + EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); EXPECT_TRUE(AddRecvStream(kSsrcX)); EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, (ContainerEq>( @@ -2944,7 +2944,7 @@ TEST_P(WebRtcVoiceEngineTestFake, AddRecvStreamUnsupportedCodec) { // not explicitly removed. TEST_P(WebRtcVoiceEngineTestFake, StreamCleanup) { EXPECT_TRUE(SetupSendStream()); - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); EXPECT_TRUE(AddRecvStream(1)); EXPECT_TRUE(AddRecvStream(2)); @@ -3019,7 +3019,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetAudioOptions) { // Nothing set in AudioOptions, so everything should be as default. send_parameters_.options = cricket::AudioOptions(); - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); EXPECT_TRUE(IsHighPassFilterEnabled()); @@ -3029,7 +3029,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetAudioOptions) { // Turn echo cancellation off send_parameters_.options.echo_cancellation = false; - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/false); } @@ -3037,25 +3037,25 @@ TEST_P(WebRtcVoiceEngineTestFake, SetAudioOptions) { // Turn echo cancellation back on, with settings, and make sure // nothing else changed. send_parameters_.options.echo_cancellation = true; - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); } // Turn off echo cancellation and delay agnostic aec. send_parameters_.options.echo_cancellation = false; - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/false); } // Restore AEC to be on to work with the following tests. send_parameters_.options.echo_cancellation = true; - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); // Turn off AGC send_parameters_.options.auto_gain_control = false; - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); EXPECT_FALSE(apm_config_.gain_controller1.enabled); @@ -3063,7 +3063,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetAudioOptions) { // Turn AGC back on send_parameters_.options.auto_gain_control = true; - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); EXPECT_TRUE(apm_config_.gain_controller1.enabled); @@ -3073,7 +3073,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetAudioOptions) { send_parameters_.options.noise_suppression = false; send_parameters_.options.highpass_filter = false; send_parameters_.options.stereo_swapping = true; - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); EXPECT_FALSE(IsHighPassFilterEnabled()); @@ -3083,7 +3083,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetAudioOptions) { } // Set options again to ensure it has no impact. - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); EXPECT_TRUE(apm_config_.gain_controller1.enabled); @@ -3161,7 +3161,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { parameters_options_all.options.echo_cancellation = true; parameters_options_all.options.auto_gain_control = true; parameters_options_all.options.noise_suppression = true; - EXPECT_TRUE(send_channel1->SetSendParameters(parameters_options_all)); + EXPECT_TRUE(send_channel1->SetSenderParameters(parameters_options_all)); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); VerifyGainControlEnabledCorrectly(); @@ -3169,7 +3169,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { EXPECT_EQ(apm_config_.noise_suppression.level, kDefaultNsLevel); EXPECT_EQ(parameters_options_all.options, SendImplFromPointer(send_channel1.get())->options()); - EXPECT_TRUE(send_channel2->SetSendParameters(parameters_options_all)); + EXPECT_TRUE(send_channel2->SetSenderParameters(parameters_options_all)); VerifyEchoCancellationSettings(/*enabled=*/true); VerifyGainControlEnabledCorrectly(); EXPECT_EQ(parameters_options_all.options, @@ -3179,7 +3179,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { // unset NS cricket::AudioSenderParameter parameters_options_no_ns = send_parameters_; parameters_options_no_ns.options.noise_suppression = false; - EXPECT_TRUE(send_channel1->SetSendParameters(parameters_options_no_ns)); + EXPECT_TRUE(send_channel1->SetSenderParameters(parameters_options_no_ns)); cricket::AudioOptions expected_options = parameters_options_all.options; if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); @@ -3196,7 +3196,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { // unset AGC cricket::AudioSenderParameter parameters_options_no_agc = send_parameters_; parameters_options_no_agc.options.auto_gain_control = false; - EXPECT_TRUE(send_channel2->SetSendParameters(parameters_options_no_agc)); + EXPECT_TRUE(send_channel2->SetSenderParameters(parameters_options_no_agc)); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); EXPECT_FALSE(apm_config_.gain_controller1.enabled); @@ -3209,7 +3209,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { SendImplFromPointer(send_channel2.get())->options()); } - EXPECT_TRUE(send_channel_->SetSendParameters(parameters_options_all)); + EXPECT_TRUE(send_channel_->SetSenderParameters(parameters_options_all)); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); VerifyGainControlEnabledCorrectly(); @@ -3239,7 +3239,7 @@ TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { parameters_options_no_agc_nor_ns.options.auto_gain_control = false; parameters_options_no_agc_nor_ns.options.noise_suppression = false; EXPECT_TRUE( - send_channel2->SetSendParameters(parameters_options_no_agc_nor_ns)); + send_channel2->SetSenderParameters(parameters_options_no_agc_nor_ns)); if (!use_null_apm_) { VerifyEchoCancellationSettings(/*enabled=*/true); EXPECT_FALSE(apm_config_.gain_controller1.enabled); @@ -3460,7 +3460,7 @@ TEST_P(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) { ssrcs.push_back(224); EXPECT_TRUE(SetupSendStream()); - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); for (uint32_t ssrc : ssrcs) { EXPECT_TRUE(receive_channel_->AddRecvStream( cricket::StreamParams::CreateLegacy(ssrc))); @@ -3469,7 +3469,7 @@ TEST_P(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) { EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size()); for (uint32_t ssrc : ssrcs) { EXPECT_THAT( - receive_channel_->GetRtpReceiveParameters(ssrc).header_extensions, + receive_channel_->GetRtpReceiverParameters(ssrc).header_extensions, IsEmpty()); } @@ -3478,19 +3478,19 @@ TEST_P(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) { GetDefaultEnabledRtpHeaderExtensions(*engine_); cricket::AudioReceiverParameters recv_parameters; recv_parameters.extensions = header_extensions; - receive_channel_->SetRecvParameters(recv_parameters); + receive_channel_->SetReceiverParameters(recv_parameters); EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size()); for (uint32_t ssrc : ssrcs) { EXPECT_THAT( - receive_channel_->GetRtpReceiveParameters(ssrc).header_extensions, + receive_channel_->GetRtpReceiverParameters(ssrc).header_extensions, testing::UnorderedElementsAreArray(header_extensions)); } // Disable receive extensions. - receive_channel_->SetRecvParameters(cricket::AudioReceiverParameters()); + receive_channel_->SetReceiverParameters(cricket::AudioReceiverParameters()); for (uint32_t ssrc : ssrcs) { EXPECT_THAT( - receive_channel_->GetRtpReceiveParameters(ssrc).header_extensions, + receive_channel_->GetRtpReceiverParameters(ssrc).header_extensions, IsEmpty()); } } @@ -3507,7 +3507,7 @@ TEST_P(WebRtcVoiceEngineTestFake, DeliverAudioPacket_Call) { EXPECT_TRUE(SetupSendStream()); cricket::VoiceMediaReceiveChannelInterface* media_channel = ReceiveImpl(); - SetSendParameters(send_parameters_); + SetSenderParameters(send_parameters_); EXPECT_TRUE(media_channel->AddRecvStream( cricket::StreamParams::CreateLegacy(kAudioSsrc))); @@ -3668,7 +3668,7 @@ TEST_P(WebRtcVoiceEngineTestFake, PreservePlayoutWhenRecreateRecvStream) { cricket::AudioReceiverParameters parameters; parameters.extensions.push_back( webrtc::RtpExtension(webrtc::RtpExtension::kAudioLevelUri, 12)); - receive_channel_->SetRecvParameters(parameters); + receive_channel_->SetReceiverParameters(parameters); EXPECT_TRUE(GetRecvStream(kSsrcX).started()); } @@ -3862,7 +3862,7 @@ TEST(WebRtcVoiceEngineTest, SetRecvCodecs) { // - The codecs provided by the engine is usable by Channel. // It does not check that the codecs in the RecvParameters are actually // what we sent in - though it's probably reasonable to expect so, if - // SetRecvParameters returns true. + // SetReceiverParameters returns true. // I think it will become clear once audio decoder injection is completed. rtc::scoped_refptr adm = webrtc::test::MockAudioDeviceModule::CreateNice(); @@ -3886,7 +3886,7 @@ TEST(WebRtcVoiceEngineTest, SetRecvCodecs) { webrtc::AudioCodecPairId::Create()); cricket::AudioReceiverParameters parameters; parameters.codecs = engine.recv_codecs(); - EXPECT_TRUE(channel.SetRecvParameters(parameters)); + EXPECT_TRUE(channel.SetReceiverParameters(parameters)); } } @@ -3924,7 +3924,7 @@ TEST(WebRtcVoiceEngineTest, SetRtpSendParametersMaxBitrate) { params.codecs.push_back(cricket::CreateAudioCodec(1, "opus", 48000, 2)); params.extensions.push_back(webrtc::RtpExtension( webrtc::RtpExtension::kTransportSequenceNumberUri, 1)); - EXPECT_TRUE(channel.SetSendParameters(params)); + EXPECT_TRUE(channel.SetSenderParameters(params)); } constexpr int kSsrc = 1234; { diff --git a/pc/audio_rtp_receiver.cc b/pc/audio_rtp_receiver.cc index 804d31352d..a8659de5f9 100644 --- a/pc/audio_rtp_receiver.cc +++ b/pc/audio_rtp_receiver.cc @@ -139,7 +139,7 @@ RtpParameters AudioRtpReceiver::GetParameters() const { return RtpParameters(); auto current_ssrc = ssrc(); return current_ssrc.has_value() - ? media_channel_->GetRtpReceiveParameters(current_ssrc.value()) + ? media_channel_->GetRtpReceiverParameters(current_ssrc.value()) : media_channel_->GetDefaultRtpReceiveParameters(); } diff --git a/pc/channel.cc b/pc/channel.cc index 46cd377693..afe9d034fd 100644 --- a/pc/channel.cc +++ b/pc/channel.cc @@ -888,7 +888,7 @@ bool VoiceChannel::SetLocalContent_w(const MediaContentDescription* content, webrtc::RtpTransceiverDirectionHasRecv(content->direction()), &recv_params); - if (!media_receive_channel()->SetRecvParameters(recv_params)) { + if (!media_receive_channel()->SetReceiverParameters(recv_params)) { error_desc = StringFormat( "Failed to set local audio description recv parameters for m-section " "with mid='%s'.", @@ -941,7 +941,7 @@ bool VoiceChannel::SetRemoteContent_w(const MediaContentDescription* content, send_params.mid = mid(); bool parameters_applied = - media_send_channel()->SetSendParameters(send_params); + media_send_channel()->SetSenderParameters(send_params); if (!parameters_applied) { error_desc = StringFormat( "Failed to set remote audio description send parameters for m-section " @@ -1050,7 +1050,7 @@ bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content, } } - if (!media_receive_channel()->SetRecvParameters(recv_params)) { + if (!media_receive_channel()->SetReceiverParameters(recv_params)) { error_desc = StringFormat( "Failed to set local video description recv parameters for m-section " "with mid='%s'.", @@ -1069,7 +1069,7 @@ bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content, last_recv_params_ = recv_params; if (needs_send_params_update) { - if (!media_send_channel()->SetSendParameters(send_params)) { + if (!media_send_channel()->SetSenderParameters(send_params)) { error_desc = StringFormat( "Failed to set send parameters for m-section with mid='%s'.", mid().c_str()); @@ -1135,7 +1135,7 @@ bool VideoChannel::SetRemoteContent_w(const MediaContentDescription* content, } } - if (!media_send_channel()->SetSendParameters(send_params)) { + if (!media_send_channel()->SetSenderParameters(send_params)) { error_desc = StringFormat( "Failed to set remote video description send parameters for m-section " "with mid='%s'.", @@ -1151,7 +1151,7 @@ bool VideoChannel::SetRemoteContent_w(const MediaContentDescription* content, last_send_params_ = send_params; if (needs_recv_params_update) { - if (!media_receive_channel()->SetRecvParameters(recv_params)) { + if (!media_receive_channel()->SetReceiverParameters(recv_params)) { error_desc = StringFormat( "Failed to set recv parameters for m-section with mid='%s'.", mid().c_str()); diff --git a/pc/channel.h b/pc/channel.h index 5078225e61..23ae69fa5d 100644 --- a/pc/channel.h +++ b/pc/channel.h @@ -430,10 +430,10 @@ class VoiceChannel : public BaseChannel { RTC_RUN_ON(worker_thread()) override; // Last AudioSenderParameter sent down to the media_channel() via - // SetSendParameters. + // SetSenderParameters. AudioSenderParameter last_send_params_ RTC_GUARDED_BY(worker_thread()); // Last AudioReceiverParameters sent down to the media_channel() via - // SetRecvParameters. + // SetReceiverParameters. AudioReceiverParameters last_recv_params_ RTC_GUARDED_BY(worker_thread()); }; @@ -499,10 +499,10 @@ class VideoChannel : public BaseChannel { RTC_RUN_ON(worker_thread()) override; // Last VideoSenderParameters sent down to the media_channel() via - // SetSendParameters. + // SetSenderParameters. VideoSenderParameters last_send_params_ RTC_GUARDED_BY(worker_thread()); // Last VideoReceiverParameters sent down to the media_channel() via - // SetRecvParameters. + // SetReceiverParameters. VideoReceiverParameters last_recv_params_ RTC_GUARDED_BY(worker_thread()); }; diff --git a/pc/rtp_sender_receiver_unittest.cc b/pc/rtp_sender_receiver_unittest.cc index 18a5505f39..3092e53c2d 100644 --- a/pc/rtp_sender_receiver_unittest.cc +++ b/pc/rtp_sender_receiver_unittest.cc @@ -176,7 +176,7 @@ class RtpSenderReceiverTest const cricket::AudioCodec kTelephoneEventCodec = cricket::CreateAudioCodec(106, "telephone-event", 8000, 1); params.codecs.push_back(kTelephoneEventCodec); - voice_media_send_channel()->SetSendParameters(params); + voice_media_send_channel()->SetSenderParameters(params); } void AddVideoTrack() { AddVideoTrack(false); } diff --git a/pc/test/mock_voice_media_receive_channel_interface.h b/pc/test/mock_voice_media_receive_channel_interface.h index 98723bcc36..adb1201239 100644 --- a/pc/test/mock_voice_media_receive_channel_interface.h +++ b/pc/test/mock_voice_media_receive_channel_interface.h @@ -34,11 +34,11 @@ class MockVoiceMediaReceiveChannelInterface // VoiceMediaReceiveChannelInterface MOCK_METHOD(bool, - SetRecvParameters, + SetReceiverParameters, (const AudioReceiverParameters& params), (override)); MOCK_METHOD(webrtc::RtpParameters, - GetRtpReceiveParameters, + GetRtpReceiverParameters, (uint32_t ssrc), (const, override)); MOCK_METHOD(std::vector, diff --git a/pc/video_rtp_receiver.cc b/pc/video_rtp_receiver.cc index 8a2e65c162..4432982027 100644 --- a/pc/video_rtp_receiver.cc +++ b/pc/video_rtp_receiver.cc @@ -78,7 +78,7 @@ RtpParameters VideoRtpReceiver::GetParameters() const { return RtpParameters(); auto current_ssrc = ssrc(); return current_ssrc.has_value() - ? media_channel_->GetRtpReceiveParameters(current_ssrc.value()) + ? media_channel_->GetRtpReceiverParameters(current_ssrc.value()) : media_channel_->GetDefaultRtpReceiveParameters(); }