From 8fb1a6ad27a7b1690e168ec54eed1d14b7473e87 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Niels=20M=C3=B6ller?= Date: Tue, 5 Mar 2019 14:29:42 +0100 Subject: [PATCH] Delete a few return values from audio streams and video send streams. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bug: webrtc:10198 Change-Id: I583dbb717aea26c9d282a3786062d285121fbf66 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/125723 Reviewed-by: Erik Språng Reviewed-by: Fredrik Solenberg Commit-Queue: Niels Moller Cr-Commit-Position: refs/heads/master@{#26986} --- audio/audio_receive_stream.cc | 4 ++-- audio/audio_receive_stream.h | 2 +- audio/audio_receive_stream_unittest.cc | 4 ++-- audio/audio_send_stream.cc | 10 +++++----- audio/audio_send_stream.h | 2 +- audio/audio_send_stream_unittest.cc | 5 ++--- audio/channel_receive.cc | 10 ++++------ audio/channel_receive.h | 2 +- audio/channel_send.cc | 20 ++++++++------------ audio/channel_send.h | 6 +++--- audio/mock_voe_channel_proxy.h | 10 +++++----- call/call.cc | 12 ++++++------ video/video_send_stream.cc | 4 ++-- video/video_send_stream.h | 2 +- video/video_send_stream_impl.cc | 3 +-- video/video_send_stream_impl.h | 2 +- 16 files changed, 45 insertions(+), 53 deletions(-) diff --git a/audio/audio_receive_stream.cc b/audio/audio_receive_stream.cc index 47530c3290..00991886d8 100644 --- a/audio/audio_receive_stream.cc +++ b/audio/audio_receive_stream.cc @@ -310,12 +310,12 @@ void AudioReceiveStream::SignalNetworkState(NetworkState state) { RTC_DCHECK_RUN_ON(&worker_thread_checker_); } -bool AudioReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) { +void AudioReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) { // TODO(solenberg): Tests call this function on a network thread, libjingle // calls on the worker thread. We should move towards always using a network // thread. Then this check can be enabled. // RTC_DCHECK(!thread_checker_.CalledOnValidThread()); - return channel_receive_->ReceivedRTCPPacket(packet, length); + channel_receive_->ReceivedRTCPPacket(packet, length); } void AudioReceiveStream::OnRtpPacket(const RtpPacketReceived& packet) { diff --git a/audio/audio_receive_stream.h b/audio/audio_receive_stream.h index 1745c0f698..0924c03d5c 100644 --- a/audio/audio_receive_stream.h +++ b/audio/audio_receive_stream.h @@ -91,7 +91,7 @@ class AudioReceiveStream final : public webrtc::AudioReceiveStream, void AssociateSendStream(AudioSendStream* send_stream); void SignalNetworkState(NetworkState state); - bool DeliverRtcp(const uint8_t* packet, size_t length); + void DeliverRtcp(const uint8_t* packet, size_t length); const webrtc::AudioReceiveStream::Config& config() const; const AudioSendStream* GetAssociatedSendStreamForTesting() const; diff --git a/audio/audio_receive_stream_unittest.cc b/audio/audio_receive_stream_unittest.cc index 4594e56ed8..1ba9b69c77 100644 --- a/audio/audio_receive_stream_unittest.cc +++ b/audio/audio_receive_stream_unittest.cc @@ -255,8 +255,8 @@ TEST(AudioReceiveStreamTest, ReceiveRtcpPacket) { std::vector rtcp_packet = CreateRtcpSenderReport(); EXPECT_CALL(*helper.channel_receive(), ReceivedRTCPPacket(&rtcp_packet[0], rtcp_packet.size())) - .WillOnce(Return(true)); - EXPECT_TRUE(recv_stream->DeliverRtcp(&rtcp_packet[0], rtcp_packet.size())); + .WillOnce(Return()); + recv_stream->DeliverRtcp(&rtcp_packet[0], rtcp_packet.size()); } TEST(AudioReceiveStreamTest, GetStats) { diff --git a/audio/audio_send_stream.cc b/audio/audio_send_stream.cc index bb791492a9..8157e6a324 100644 --- a/audio/audio_send_stream.cc +++ b/audio/audio_send_stream.cc @@ -353,9 +353,9 @@ bool AudioSendStream::SendTelephoneEvent(int payload_type, int event, int duration_ms) { RTC_DCHECK(worker_thread_checker_.CalledOnValidThread()); - return channel_send_->SetSendTelephoneEventPayloadType(payload_type, - payload_frequency) && - channel_send_->SendTelephoneEventOutband(event, duration_ms); + channel_send_->SetSendTelephoneEventPayloadType(payload_type, + payload_frequency); + return channel_send_->SendTelephoneEventOutband(event, duration_ms); } void AudioSendStream::SetMuted(bool muted) { @@ -422,12 +422,12 @@ void AudioSendStream::SignalNetworkState(NetworkState state) { RTC_DCHECK(worker_thread_checker_.CalledOnValidThread()); } -bool AudioSendStream::DeliverRtcp(const uint8_t* packet, size_t length) { +void AudioSendStream::DeliverRtcp(const uint8_t* packet, size_t length) { // TODO(solenberg): Tests call this function on a network thread, libjingle // calls on the worker thread. We should move towards always using a network // thread. Then this check can be enabled. // RTC_DCHECK(!worker_thread_checker_.CalledOnValidThread()); - return channel_send_->ReceivedRTCPPacket(packet, length); + channel_send_->ReceivedRTCPPacket(packet, length); } uint32_t AudioSendStream::OnBitrateUpdated(BitrateAllocationUpdate update) { diff --git a/audio/audio_send_stream.h b/audio/audio_send_stream.h index c227e6114f..54a26c2a6f 100644 --- a/audio/audio_send_stream.h +++ b/audio/audio_send_stream.h @@ -78,7 +78,7 @@ class AudioSendStream final : public webrtc::AudioSendStream, bool has_remote_tracks) const override; void SignalNetworkState(NetworkState state); - bool DeliverRtcp(const uint8_t* packet, size_t length); + void DeliverRtcp(const uint8_t* packet, size_t length); // Implements BitrateAllocatorObserver. uint32_t OnBitrateUpdated(BitrateAllocationUpdate update) override; diff --git a/audio/audio_send_stream_unittest.cc b/audio/audio_send_stream_unittest.cc index ddd8137e50..1d4d5b76e9 100644 --- a/audio/audio_send_stream_unittest.cc +++ b/audio/audio_send_stream_unittest.cc @@ -240,8 +240,7 @@ struct ConfigHelper { EXPECT_TRUE(channel_send_); EXPECT_CALL(*channel_send_, SetSendTelephoneEventPayloadType( kTelephoneEventPayloadType, - kTelephoneEventPayloadFrequency)) - .WillOnce(Return(true)); + kTelephoneEventPayloadFrequency)); EXPECT_CALL( *channel_send_, SendTelephoneEventOutband(kTelephoneEventCode, kTelephoneEventDuration)) @@ -500,7 +499,7 @@ TEST(AudioSendStreamTest, DontRecreateEncoder) { // to ConfigHelper (say to WillRepeatedly) would silently make this test // useless. EXPECT_CALL(*helper.channel_send(), SetEncoderForMock(_, _)) - .WillOnce(Return(true)); + .WillOnce(Return()); helper.config().send_codec_spec = AudioSendStream::Config::SendCodecSpec(9, kG722Format); diff --git a/audio/channel_receive.cc b/audio/channel_receive.cc index 79523c8280..679666e3e1 100644 --- a/audio/channel_receive.cc +++ b/audio/channel_receive.cc @@ -106,7 +106,7 @@ class ChannelReceive : public ChannelReceiveInterface, absl::optional> GetReceiveCodec() const override; - bool ReceivedRTCPPacket(const uint8_t* data, size_t length) override; + void ReceivedRTCPPacket(const uint8_t* data, size_t length) override; // RtpPacketSinkInterface. void OnRtpPacket(const RtpPacketReceived& packet) override; @@ -664,8 +664,7 @@ bool ChannelReceive::ReceivePacket(const uint8_t* packet, } // May be called on either worker thread or network thread. -// TODO(nisse): Drop always-true return value. -bool ChannelReceive::ReceivedRTCPPacket(const uint8_t* data, size_t length) { +void ChannelReceive::ReceivedRTCPPacket(const uint8_t* data, size_t length) { // Store playout timestamp for the received RTCP packet UpdatePlayoutTimestamp(true); @@ -675,7 +674,7 @@ bool ChannelReceive::ReceivedRTCPPacket(const uint8_t* data, size_t length) { int64_t rtt = GetRTT(); if (rtt == 0) { // Waiting for valid RTT. - return true; + return; } uint32_t ntp_secs = 0; @@ -684,14 +683,13 @@ bool ChannelReceive::ReceivedRTCPPacket(const uint8_t* data, size_t length) { if (0 != _rtpRtcpModule->RemoteNTP(&ntp_secs, &ntp_frac, NULL, NULL, &rtp_timestamp)) { // Waiting for RTCP. - return true; + return; } { rtc::CritScope lock(&ts_stats_lock_); ntp_estimator_.UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp); } - return true; } int ChannelReceive::GetSpeechOutputLevelFullRange() const { diff --git a/audio/channel_receive.h b/audio/channel_receive.h index b3e4f9c009..a67b0db872 100644 --- a/audio/channel_receive.h +++ b/audio/channel_receive.h @@ -84,7 +84,7 @@ class ChannelReceiveInterface : public RtpPacketSinkInterface { virtual absl::optional> GetReceiveCodec() const = 0; - virtual bool ReceivedRTCPPacket(const uint8_t* data, size_t length) = 0; + virtual void ReceivedRTCPPacket(const uint8_t* data, size_t length) = 0; virtual void SetChannelOutputVolumeScaling(float scaling) = 0; virtual int GetSpeechOutputLevelFullRange() const = 0; diff --git a/audio/channel_send.cc b/audio/channel_send.cc index 0c8be1ff12..8269fd545c 100644 --- a/audio/channel_send.cc +++ b/audio/channel_send.cc @@ -103,7 +103,7 @@ class ChannelSend ~ChannelSend() override; // Send using this encoder, with this payload type. - bool SetEncoder(int payload_type, + void SetEncoder(int payload_type, std::unique_ptr encoder) override; void ModifyEncoder(rtc::FunctionView*)> modifier) override; @@ -118,7 +118,7 @@ class ChannelSend int GetBitrate() const override; // Network - bool ReceivedRTCPPacket(const uint8_t* data, size_t length) override; + void ReceivedRTCPPacket(const uint8_t* data, size_t length) override; // Muting, Volume and Level. void SetInputMute(bool enable) override; @@ -131,7 +131,7 @@ class ChannelSend // DTMF. bool SendTelephoneEventOutband(int event, int duration_ms) override; - bool SetSendTelephoneEventPayloadType(int payload_type, + void SetSendTelephoneEventPayloadType(int payload_type, int payload_frequency) override; // RTP+RTCP @@ -789,7 +789,7 @@ void ChannelSend::StopSend() { _rtpRtcpModule->SetSendingMediaStatus(false); } -bool ChannelSend::SetEncoder(int payload_type, +void ChannelSend::SetEncoder(int payload_type, std::unique_ptr encoder) { RTC_DCHECK_RUN_ON(&worker_thread_checker_); RTC_DCHECK_GE(payload_type, 0); @@ -811,7 +811,6 @@ bool ChannelSend::SetEncoder(int payload_type, media_transport_sampling_frequency_ = encoder->RtpTimestampRateHz(); } audio_coding_->SetEncoder(std::move(encoder)); - return true; } void ChannelSend::ModifyEncoder( @@ -879,13 +878,12 @@ void ChannelSend::OnUplinkPacketLossRate(float packet_loss_rate) { }); } -// TODO(nisse): Delete always-true return value. -bool ChannelSend::ReceivedRTCPPacket(const uint8_t* data, size_t length) { +void ChannelSend::ReceivedRTCPPacket(const uint8_t* data, size_t length) { // May be called on either worker thread or network thread. if (media_transport_) { // Ignore RTCP packets while media transport is used. // Those packets should not arrive, but we are seeing occasional packets. - return 0; + return; } // Deliver RTCP packet to RTP/RTCP module for parsing @@ -894,7 +892,7 @@ bool ChannelSend::ReceivedRTCPPacket(const uint8_t* data, size_t length) { int64_t rtt = GetRTT(); if (rtt == 0) { // Waiting for valid RTT. - return true; + return; } int64_t nack_window_ms = rtt; @@ -906,7 +904,6 @@ bool ChannelSend::ReceivedRTCPPacket(const uint8_t* data, size_t length) { retransmission_rate_limiter_->SetWindowSize(nack_window_ms); OnReceivedRtt(rtt); - return true; } void ChannelSend::SetInputMute(bool enable) { @@ -937,14 +934,13 @@ bool ChannelSend::SendTelephoneEventOutband(int event, int duration_ms) { return true; } -bool ChannelSend::SetSendTelephoneEventPayloadType(int payload_type, +void ChannelSend::SetSendTelephoneEventPayloadType(int payload_type, int payload_frequency) { RTC_DCHECK_RUN_ON(&worker_thread_checker_); RTC_DCHECK_LE(0, payload_type); RTC_DCHECK_GE(127, payload_type); _rtpRtcpModule->RegisterAudioSendPayload(payload_type, "telephone-event", payload_frequency, 0, 0); - return true; } void ChannelSend::SetLocalSSRC(uint32_t ssrc) { diff --git a/audio/channel_send.h b/audio/channel_send.h index 4ab53c0c45..7149bbde09 100644 --- a/audio/channel_send.h +++ b/audio/channel_send.h @@ -55,11 +55,11 @@ class ChannelSendInterface { public: virtual ~ChannelSendInterface() = default; - virtual bool ReceivedRTCPPacket(const uint8_t* packet, size_t length) = 0; + virtual void ReceivedRTCPPacket(const uint8_t* packet, size_t length) = 0; virtual CallSendStatistics GetRTCPStatistics() const = 0; - virtual bool SetEncoder(int payload_type, + virtual void SetEncoder(int payload_type, std::unique_ptr encoder) = 0; virtual void ModifyEncoder( rtc::FunctionView*)> modifier) = 0; @@ -81,7 +81,7 @@ class ChannelSendInterface { virtual void ResetSenderCongestionControlObjects() = 0; virtual std::vector GetRemoteRTCPReportBlocks() const = 0; virtual ANAStats GetANAStatistics() const = 0; - virtual bool SetSendTelephoneEventPayloadType(int payload_type, + virtual void SetSendTelephoneEventPayloadType(int payload_type, int payload_frequency) = 0; virtual bool SendTelephoneEventOutband(int event, int duration_ms) = 0; virtual void OnBitrateAllocation(BitrateAllocationUpdate update) = 0; diff --git a/audio/mock_voe_channel_proxy.h b/audio/mock_voe_channel_proxy.h index a03ce7e116..1b2f96eb20 100644 --- a/audio/mock_voe_channel_proxy.h +++ b/audio/mock_voe_channel_proxy.h @@ -42,7 +42,7 @@ class MockChannelReceive : public voe::ChannelReceiveInterface { MOCK_CONST_METHOD0(GetDelayEstimate, uint32_t()); MOCK_METHOD1(SetSink, void(AudioSinkInterface* sink)); MOCK_METHOD1(OnRtpPacket, void(const RtpPacketReceived& packet)); - MOCK_METHOD2(ReceivedRTCPPacket, bool(const uint8_t* packet, size_t length)); + MOCK_METHOD2(ReceivedRTCPPacket, void(const uint8_t* packet, size_t length)); MOCK_METHOD1(SetChannelOutputVolumeScaling, void(float scaling)); MOCK_METHOD2(GetAudioFrameWithInfo, AudioMixer::Source::AudioFrameInfo(int sample_rate_hz, @@ -67,12 +67,12 @@ class MockChannelReceive : public voe::ChannelReceiveInterface { class MockChannelSend : public voe::ChannelSendInterface { public: // GMock doesn't like move-only types, like std::unique_ptr. - virtual bool SetEncoder(int payload_type, + virtual void SetEncoder(int payload_type, std::unique_ptr encoder) { return SetEncoderForMock(payload_type, &encoder); } MOCK_METHOD2(SetEncoderForMock, - bool(int payload_type, std::unique_ptr* encoder)); + void(int payload_type, std::unique_ptr* encoder)); MOCK_METHOD1( ModifyEncoder, void(rtc::FunctionView*)> modifier)); @@ -96,11 +96,11 @@ class MockChannelSend : public voe::ChannelSendInterface { MOCK_CONST_METHOD0(GetRemoteRTCPReportBlocks, std::vector()); MOCK_CONST_METHOD0(GetANAStatistics, ANAStats()); MOCK_METHOD2(SetSendTelephoneEventPayloadType, - bool(int payload_type, int payload_frequency)); + void(int payload_type, int payload_frequency)); MOCK_METHOD2(SendTelephoneEventOutband, bool(int event, int duration_ms)); MOCK_METHOD1(OnBitrateAllocation, void(BitrateAllocationUpdate update)); MOCK_METHOD1(SetInputMute, void(bool muted)); - MOCK_METHOD2(ReceivedRTCPPacket, bool(const uint8_t* packet, size_t length)); + MOCK_METHOD2(ReceivedRTCPPacket, void(const uint8_t* packet, size_t length)); // GMock doesn't like move-only types, like std::unique_ptr. virtual void ProcessAndEncodeAudio(std::unique_ptr audio_frame) { ProcessAndEncodeAudioForMock(&audio_frame); diff --git a/call/call.cc b/call/call.cc index 98747cf7f2..08fdcd2153 100644 --- a/call/call.cc +++ b/call/call.cc @@ -1292,22 +1292,22 @@ PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type, if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) { ReadLockScoped read_lock(*receive_crit_); for (AudioReceiveStream* stream : audio_receive_streams_) { - if (stream->DeliverRtcp(packet, length)) - rtcp_delivered = true; + stream->DeliverRtcp(packet, length); + rtcp_delivered = true; } } if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) { ReadLockScoped read_lock(*send_crit_); for (VideoSendStream* stream : video_send_streams_) { - if (stream->DeliverRtcp(packet, length)) - rtcp_delivered = true; + stream->DeliverRtcp(packet, length); + rtcp_delivered = true; } } if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) { ReadLockScoped read_lock(*send_crit_); for (auto& kv : audio_send_ssrcs_) { - if (kv.second->DeliverRtcp(packet, length)) - rtcp_delivered = true; + kv.second->DeliverRtcp(packet, length); + rtcp_delivered = true; } } diff --git a/video/video_send_stream.cc b/video/video_send_stream.cc index e78a6990c0..3b6c4f5068 100644 --- a/video/video_send_stream.cc +++ b/video/video_send_stream.cc @@ -207,9 +207,9 @@ void VideoSendStream::StopPermanentlyAndGetRtpStates( thread_sync_event_.Wait(rtc::Event::kForever); } -bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) { +void VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) { // Called on a network thread. - return send_stream_->DeliverRtcp(packet, length); + send_stream_->DeliverRtcp(packet, length); } } // namespace internal diff --git a/video/video_send_stream.h b/video/video_send_stream.h index 240432f09a..f1ac4773b8 100644 --- a/video/video_send_stream.h +++ b/video/video_send_stream.h @@ -71,7 +71,7 @@ class VideoSendStream : public webrtc::VideoSendStream { ~VideoSendStream() override; - bool DeliverRtcp(const uint8_t* packet, size_t length); + void DeliverRtcp(const uint8_t* packet, size_t length); // webrtc::VideoSendStream implementation. void UpdateActiveSimulcastLayers( diff --git a/video/video_send_stream_impl.cc b/video/video_send_stream_impl.cc index 9a563417dc..507cc724cc 100644 --- a/video/video_send_stream_impl.cc +++ b/video/video_send_stream_impl.cc @@ -350,11 +350,10 @@ void VideoSendStreamImpl::DeRegisterProcessThread() { rtp_video_sender_->DeRegisterProcessThread(); } -bool VideoSendStreamImpl::DeliverRtcp(const uint8_t* packet, size_t length) { +void VideoSendStreamImpl::DeliverRtcp(const uint8_t* packet, size_t length) { // Runs on a network thread. RTC_DCHECK(!worker_queue_->IsCurrent()); rtp_video_sender_->DeliverRtcp(packet, length); - return true; } void VideoSendStreamImpl::UpdateActiveSimulcastLayers( diff --git a/video/video_send_stream_impl.h b/video/video_send_stream_impl.h index c9472fb5fa..c7510b9b94 100644 --- a/video/video_send_stream_impl.h +++ b/video/video_send_stream_impl.h @@ -97,7 +97,7 @@ class VideoSendStreamImpl : public webrtc::BitrateAllocatorObserver, void RegisterProcessThread(ProcessThread* module_process_thread); void DeRegisterProcessThread(); - bool DeliverRtcp(const uint8_t* packet, size_t length); + void DeliverRtcp(const uint8_t* packet, size_t length); void UpdateActiveSimulcastLayers(const std::vector active_layers); void Start(); void Stop();