From 2454d85bb64004cdc61412a4f09c23a2e79faeae Mon Sep 17 00:00:00 2001 From: Danil Chapovalov Date: Thu, 7 May 2020 20:43:21 +0200 Subject: [PATCH] Cleanup rtp_rtcp mocks MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Modernise function to unified MOCK_METHOD macro, delete few deprecated functions on the way. Remove default constructors to stress they do nothing special Bug: None Change-Id: Ie126f38f0589acb65886f25f754ca575c17af29b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174583 Reviewed-by: Erik Språng Commit-Queue: Danil Chapovalov Cr-Commit-Position: refs/heads/master@{#31191} --- modules/rtp_rtcp/BUILD.gn | 6 - .../mocks/mock_recovered_packet_receiver.cc | 18 - .../mocks/mock_recovered_packet_receiver.h | 7 +- .../mocks/mock_rtcp_bandwidth_observer.cc | 18 - .../mocks/mock_rtcp_bandwidth_observer.h | 11 +- modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.cc | 18 - modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h | 7 +- modules/rtp_rtcp/mocks/mock_rtp_rtcp.cc | 18 - modules/rtp_rtcp/mocks/mock_rtp_rtcp.h | 330 ++++++++++-------- 9 files changed, 199 insertions(+), 234 deletions(-) delete mode 100644 modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.cc delete mode 100644 modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.cc delete mode 100644 modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.cc delete mode 100644 modules/rtp_rtcp/mocks/mock_rtp_rtcp.cc diff --git a/modules/rtp_rtcp/BUILD.gn b/modules/rtp_rtcp/BUILD.gn index 3af0509d77..0ac6900e65 100644 --- a/modules/rtp_rtcp/BUILD.gn +++ b/modules/rtp_rtcp/BUILD.gn @@ -370,12 +370,6 @@ rtc_library("fec_test_helper") { rtc_library("mock_rtp_rtcp") { testonly = true - sources = [ - "mocks/mock_recovered_packet_receiver.cc", - "mocks/mock_rtcp_bandwidth_observer.cc", - "mocks/mock_rtcp_rtt_stats.cc", - "mocks/mock_rtp_rtcp.cc", - ] public = [ "mocks/mock_recovered_packet_receiver.h", "mocks/mock_rtcp_bandwidth_observer.h", diff --git a/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.cc b/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.cc deleted file mode 100644 index e0183f89c0..0000000000 --- a/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.cc +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#include "modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h" - -namespace webrtc { - -MockRecoveredPacketReceiver::MockRecoveredPacketReceiver() = default; -MockRecoveredPacketReceiver::~MockRecoveredPacketReceiver() = default; - -} // namespace webrtc diff --git a/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h b/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h index d6442ad58a..404ded01d8 100644 --- a/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h +++ b/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h @@ -18,9 +18,10 @@ namespace webrtc { class MockRecoveredPacketReceiver : public RecoveredPacketReceiver { public: - MockRecoveredPacketReceiver(); - ~MockRecoveredPacketReceiver(); - MOCK_METHOD2(OnRecoveredPacket, void(const uint8_t* packet, size_t length)); + MOCK_METHOD(void, + OnRecoveredPacket, + (const uint8_t* packet, size_t length), + (override)); }; } // namespace webrtc diff --git a/modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.cc b/modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.cc deleted file mode 100644 index abaf129d8b..0000000000 --- a/modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.cc +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#include "modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.h" - -namespace webrtc { - -MockRtcpBandwidthObserver::MockRtcpBandwidthObserver() = default; -MockRtcpBandwidthObserver::~MockRtcpBandwidthObserver() = default; - -} // namespace webrtc diff --git a/modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.h b/modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.h index b9a8f79a1d..12f143ae8b 100644 --- a/modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.h +++ b/modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.h @@ -18,12 +18,11 @@ namespace webrtc { class MockRtcpBandwidthObserver : public RtcpBandwidthObserver { public: - MockRtcpBandwidthObserver(); - ~MockRtcpBandwidthObserver(); - - MOCK_METHOD1(OnReceivedEstimatedBitrate, void(uint32_t)); - MOCK_METHOD3(OnReceivedRtcpReceiverReport, - void(const ReportBlockList&, int64_t, int64_t)); + MOCK_METHOD(void, OnReceivedEstimatedBitrate, (uint32_t), (override)); + MOCK_METHOD(void, + OnReceivedRtcpReceiverReport, + (const ReportBlockList&, int64_t, int64_t), + (override)); }; } // namespace webrtc #endif // MODULES_RTP_RTCP_MOCKS_MOCK_RTCP_BANDWIDTH_OBSERVER_H_ diff --git a/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.cc b/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.cc deleted file mode 100644 index 1aca566bb6..0000000000 --- a/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.cc +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#include "modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h" - -namespace webrtc { - -MockRtcpRttStats::MockRtcpRttStats() = default; -MockRtcpRttStats::~MockRtcpRttStats() = default; - -} // namespace webrtc diff --git a/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h b/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h index 6ccef612c2..5b1585fa0f 100644 --- a/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h +++ b/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h @@ -18,11 +18,8 @@ namespace webrtc { class MockRtcpRttStats : public RtcpRttStats { public: - MockRtcpRttStats(); - ~MockRtcpRttStats(); - - MOCK_METHOD1(OnRttUpdate, void(int64_t rtt)); - MOCK_CONST_METHOD0(LastProcessedRtt, int64_t()); + MOCK_METHOD(void, OnRttUpdate, (int64_t rtt), (override)); + MOCK_METHOD(int64_t, LastProcessedRtt, (), (const override)); }; } // namespace webrtc #endif // MODULES_RTP_RTCP_MOCKS_MOCK_RTCP_RTT_STATS_H_ diff --git a/modules/rtp_rtcp/mocks/mock_rtp_rtcp.cc b/modules/rtp_rtcp/mocks/mock_rtp_rtcp.cc deleted file mode 100644 index 061f82765c..0000000000 --- a/modules/rtp_rtcp/mocks/mock_rtp_rtcp.cc +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#include "modules/rtp_rtcp/mocks/mock_rtp_rtcp.h" - -namespace webrtc { - -MockRtpRtcp::MockRtpRtcp() = default; -MockRtpRtcp::~MockRtpRtcp() = default; - -} // namespace webrtc diff --git a/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h b/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h index 27c2613661..4ad982021b 100644 --- a/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h +++ b/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h @@ -22,159 +22,205 @@ #include "modules/include/module.h" #include "modules/rtp_rtcp/include/rtp_rtcp.h" #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" -#include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" #include "modules/rtp_rtcp/source/rtp_packet_to_send.h" -#include "rtc_base/checks.h" #include "test/gmock.h" namespace webrtc { class MockRtpRtcp : public RtpRtcp { public: - MockRtpRtcp(); - ~MockRtpRtcp(); - - MOCK_METHOD2(IncomingRtcpPacket, - void(const uint8_t* incoming_packet, size_t packet_length)); - MOCK_METHOD1(SetRemoteSSRC, void(uint32_t ssrc)); - MOCK_METHOD1(SetMaxRtpPacketSize, void(size_t size)); - MOCK_CONST_METHOD0(MaxRtpPacketSize, size_t()); - MOCK_METHOD2(RegisterSendPayloadFrequency, - void(int payload_type, int frequency)); - MOCK_METHOD1(DeRegisterSendPayload, int32_t(int8_t payload_type)); - MOCK_METHOD1(SetExtmapAllowMixed, void(bool extmap_allow_mixed)); - MOCK_METHOD2(RegisterSendRtpHeaderExtension, - int32_t(RTPExtensionType type, uint8_t id)); - MOCK_METHOD2(RegisterRtpHeaderExtension, void(absl::string_view uri, int id)); - MOCK_METHOD1(DeregisterSendRtpHeaderExtension, - int32_t(RTPExtensionType type)); - MOCK_METHOD1(DeregisterSendRtpHeaderExtension, void(absl::string_view uri)); - MOCK_CONST_METHOD0(SupportsPadding, bool()); - MOCK_CONST_METHOD0(SupportsRtxPayloadPadding, bool()); - MOCK_CONST_METHOD0(StartTimestamp, uint32_t()); - MOCK_METHOD1(SetStartTimestamp, void(uint32_t timestamp)); - MOCK_CONST_METHOD0(SequenceNumber, uint16_t()); - MOCK_METHOD1(SetSequenceNumber, void(uint16_t seq)); - MOCK_METHOD1(SetRtpState, void(const RtpState& rtp_state)); - MOCK_METHOD1(SetRtxState, void(const RtpState& rtp_state)); - MOCK_CONST_METHOD0(GetRtpState, RtpState()); - MOCK_CONST_METHOD0(GetRtxState, RtpState()); - MOCK_CONST_METHOD0(SSRC, uint32_t()); - MOCK_METHOD1(SetSSRC, void(uint32_t ssrc)); - MOCK_METHOD1(SetRid, void(const std::string& rid)); - MOCK_METHOD1(SetMid, void(const std::string& mid)); - MOCK_CONST_METHOD1(CSRCs, int32_t(uint32_t csrcs[kRtpCsrcSize])); - MOCK_METHOD1(SetCsrcs, void(const std::vector& csrcs)); - MOCK_METHOD1(SetCSRCStatus, int32_t(bool include)); - MOCK_METHOD1(SetRtxSendStatus, void(int modes)); - MOCK_CONST_METHOD0(RtxSendStatus, int()); - MOCK_CONST_METHOD0(RtxSsrc, absl::optional()); - MOCK_METHOD1(SetRtxSsrc, void(uint32_t)); - MOCK_METHOD2(SetRtxSendPayloadType, void(int, int)); - MOCK_CONST_METHOD0(FlexfecSsrc, absl::optional()); - MOCK_CONST_METHOD0(RtxSendPayloadType, std::pair()); - MOCK_METHOD1(SetSendingStatus, int32_t(bool sending)); - MOCK_CONST_METHOD0(Sending, bool()); - MOCK_METHOD1(SetSendingMediaStatus, void(bool sending)); - MOCK_CONST_METHOD0(SendingMedia, bool()); - MOCK_CONST_METHOD0(IsAudioConfigured, bool()); - MOCK_METHOD1(SetAsPartOfAllocation, void(bool)); - MOCK_CONST_METHOD4(BitrateSent, - void(uint32_t* total_rate, - uint32_t* video_rate, - uint32_t* fec_rate, - uint32_t* nack_rate)); - MOCK_CONST_METHOD1(EstimatedReceiveBandwidth, - int(uint32_t* available_bandwidth)); - MOCK_METHOD4(OnSendingRtpFrame, bool(uint32_t, int64_t, int, bool)); - MOCK_METHOD2(TrySendPacket, - bool(RtpPacketToSend* packet, - const PacedPacketInfo& pacing_info)); - MOCK_METHOD1(OnPacketsAcknowledged, void(rtc::ArrayView)); - MOCK_METHOD1( - GeneratePadding, - std::vector>(size_t target_size_bytes)); - MOCK_CONST_METHOD1(GetSentRtpPacketInfos, - std::vector( - rtc::ArrayView sequence_numbers)); - MOCK_CONST_METHOD0(ExpectedPerPacketOverhead, size_t(void)); - MOCK_METHOD2(RegisterRtcpObservers, - void(RtcpIntraFrameObserver* intra_frame_callback, - RtcpBandwidthObserver* bandwidth_callback)); - MOCK_CONST_METHOD0(RTCP, RtcpMode()); - MOCK_METHOD1(SetRTCPStatus, void(RtcpMode method)); - MOCK_METHOD1(SetCNAME, int32_t(const char cname[RTCP_CNAME_SIZE])); - MOCK_CONST_METHOD2(RemoteCNAME, - int32_t(uint32_t remote_ssrc, - char cname[RTCP_CNAME_SIZE])); - MOCK_CONST_METHOD5(RemoteNTP, - int32_t(uint32_t* received_ntp_secs, - uint32_t* received_ntp_frac, - uint32_t* rtcp_arrival_time_secs, - uint32_t* rtcp_arrival_time_frac, - uint32_t* rtcp_timestamp)); - MOCK_METHOD2(AddMixedCNAME, - int32_t(uint32_t ssrc, const char cname[RTCP_CNAME_SIZE])); - MOCK_METHOD1(RemoveMixedCNAME, int32_t(uint32_t ssrc)); - MOCK_CONST_METHOD5(RTT, - int32_t(uint32_t remote_ssrc, - int64_t* rtt, - int64_t* avg_rtt, - int64_t* min_rtt, - int64_t* max_rtt)); - MOCK_CONST_METHOD0(ExpectedRetransmissionTimeMs, int64_t()); - MOCK_METHOD1(SendRTCP, int32_t(RTCPPacketType packet_type)); - MOCK_METHOD1(SendCompoundRTCP, - int32_t(const std::set& packet_types)); - MOCK_CONST_METHOD2(DataCountersRTP, - int32_t(size_t* bytes_sent, uint32_t* packets_sent)); - MOCK_CONST_METHOD2(GetSendStreamDataCounters, - void(StreamDataCounters*, StreamDataCounters*)); - MOCK_CONST_METHOD1(RemoteRTCPStat, - int32_t(std::vector* receive_blocks)); - MOCK_CONST_METHOD0(GetLatestReportBlockData, std::vector()); - MOCK_METHOD4(SetRTCPApplicationSpecificData, - int32_t(uint8_t sub_type, - uint32_t name, - const uint8_t* data, - uint16_t length)); - MOCK_METHOD1(SetRtcpXrRrtrStatus, void(bool enable)); - MOCK_CONST_METHOD0(RtcpXrRrtrStatus, bool()); - MOCK_METHOD2(SetRemb, void(int64_t bitrate, std::vector ssrcs)); - MOCK_METHOD0(UnsetRemb, void()); - MOCK_CONST_METHOD0(TMMBR, bool()); - MOCK_METHOD1(SetTMMBRStatus, void(bool enable)); - MOCK_METHOD1(OnBandwidthEstimateUpdate, void(uint16_t bandwidth_kbit)); - MOCK_METHOD2(SendNACK, int32_t(const uint16_t* nack_list, uint16_t size)); - MOCK_METHOD1(SendNack, void(const std::vector& sequence_numbers)); - MOCK_METHOD2(SetStorePacketsStatus, - void(bool enable, uint16_t number_to_store)); - MOCK_CONST_METHOD0(StorePackets, bool()); - MOCK_METHOD1(SendFeedbackPacket, bool(const rtcp::TransportFeedback& packet)); - MOCK_METHOD1(SendNetworkStateEstimatePacket, - bool(const rtcp::RemoteEstimate& packet)); - MOCK_METHOD1( - SendCombinedRtcpPacket, - void(std::vector> rtcp_packets)); - MOCK_METHOD1(SetTargetSendBitrate, void(uint32_t bitrate_bps)); - MOCK_METHOD4(SendLossNotification, - int32_t(uint16_t last_decoded_seq_num, - uint16_t last_received_seq_num, - bool decodability_flag, - bool buffering_allowed)); - MOCK_METHOD0(Process, void()); - MOCK_METHOD1(SetVideoBitrateAllocation, void(const VideoBitrateAllocation&)); - MOCK_METHOD0(RtpSender, RTPSender*()); - MOCK_CONST_METHOD0(RtpSender, const RTPSender*()); - - // Members. - unsigned int remote_ssrc_; + MOCK_METHOD(void, + IncomingRtcpPacket, + (const uint8_t* incoming_packet, size_t packet_length), + (override)); + MOCK_METHOD(void, SetRemoteSSRC, (uint32_t ssrc), (override)); + MOCK_METHOD(void, SetMaxRtpPacketSize, (size_t size), (override)); + MOCK_METHOD(size_t, MaxRtpPacketSize, (), (const override)); + MOCK_METHOD(void, + RegisterSendPayloadFrequency, + (int payload_type, int frequency), + (override)); + MOCK_METHOD(int32_t, + DeRegisterSendPayload, + (int8_t payload_type), + (override)); + MOCK_METHOD(void, SetExtmapAllowMixed, (bool extmap_allow_mixed), (override)); + MOCK_METHOD(int32_t, + RegisterSendRtpHeaderExtension, + (RTPExtensionType type, uint8_t id), + (override)); + MOCK_METHOD(void, + RegisterRtpHeaderExtension, + (absl::string_view uri, int id), + (override)); + MOCK_METHOD(int32_t, + DeregisterSendRtpHeaderExtension, + (RTPExtensionType type), + (override)); + MOCK_METHOD(void, + DeregisterSendRtpHeaderExtension, + (absl::string_view uri), + (override)); + MOCK_METHOD(bool, SupportsPadding, (), (const override)); + MOCK_METHOD(bool, SupportsRtxPayloadPadding, (), (const override)); + MOCK_METHOD(uint32_t, StartTimestamp, (), (const override)); + MOCK_METHOD(void, SetStartTimestamp, (uint32_t timestamp), (override)); + MOCK_METHOD(uint16_t, SequenceNumber, (), (const override)); + MOCK_METHOD(void, SetSequenceNumber, (uint16_t seq), (override)); + MOCK_METHOD(void, SetRtpState, (const RtpState& rtp_state), (override)); + MOCK_METHOD(void, SetRtxState, (const RtpState& rtp_state), (override)); + MOCK_METHOD(RtpState, GetRtpState, (), (const override)); + MOCK_METHOD(RtpState, GetRtxState, (), (const override)); + MOCK_METHOD(uint32_t, SSRC, (), (const override)); + MOCK_METHOD(void, SetRid, (const std::string& rid), (override)); + MOCK_METHOD(void, SetMid, (const std::string& mid), (override)); + MOCK_METHOD(int32_t, CSRCs, (uint32_t csrcs[kRtpCsrcSize]), (const override)); + MOCK_METHOD(void, SetCsrcs, (const std::vector& csrcs), (override)); + MOCK_METHOD(void, SetRtxSendStatus, (int modes), (override)); + MOCK_METHOD(int, RtxSendStatus, (), (const override)); + MOCK_METHOD(absl::optional, RtxSsrc, (), (const override)); + MOCK_METHOD(void, SetRtxSendPayloadType, (int, int), (override)); + MOCK_METHOD(absl::optional, FlexfecSsrc, (), (const override)); + MOCK_METHOD((std::pair), RtxSendPayloadType, (), (const override)); + MOCK_METHOD(int32_t, SetSendingStatus, (bool sending), (override)); + MOCK_METHOD(bool, Sending, (), (const override)); + MOCK_METHOD(void, SetSendingMediaStatus, (bool sending), (override)); + MOCK_METHOD(bool, SendingMedia, (), (const override)); + MOCK_METHOD(bool, IsAudioConfigured, (), (const override)); + MOCK_METHOD(void, SetAsPartOfAllocation, (bool), (override)); + MOCK_METHOD(void, + BitrateSent, + (uint32_t * total_rate, + uint32_t* video_rate, + uint32_t* fec_rate, + uint32_t* nack_rate), + (const override)); + MOCK_METHOD(int, + EstimatedReceiveBandwidth, + (uint32_t * available_bandwidth), + (const override)); + MOCK_METHOD(bool, + OnSendingRtpFrame, + (uint32_t, int64_t, int, bool), + (override)); + MOCK_METHOD(bool, + TrySendPacket, + (RtpPacketToSend * packet, const PacedPacketInfo& pacing_info), + (override)); + MOCK_METHOD(void, + OnPacketsAcknowledged, + (rtc::ArrayView), + (override)); + MOCK_METHOD(std::vector>, + GeneratePadding, + (size_t target_size_bytes), + (override)); + MOCK_METHOD(std::vector, + GetSentRtpPacketInfos, + (rtc::ArrayView sequence_numbers), + (const override)); + MOCK_METHOD(size_t, ExpectedPerPacketOverhead, (), (const override)); + MOCK_METHOD(RtcpMode, RTCP, (), (const override)); + MOCK_METHOD(void, SetRTCPStatus, (RtcpMode method), (override)); + MOCK_METHOD(int32_t, + SetCNAME, + (const char cname[RTCP_CNAME_SIZE]), + (override)); + MOCK_METHOD(int32_t, + RemoteCNAME, + (uint32_t remote_ssrc, char cname[RTCP_CNAME_SIZE]), + (const override)); + MOCK_METHOD(int32_t, + RemoteNTP, + (uint32_t * received_ntp_secs, + uint32_t* received_ntp_frac, + uint32_t* rtcp_arrival_time_secs, + uint32_t* rtcp_arrival_time_frac, + uint32_t* rtcp_timestamp), + (const override)); + MOCK_METHOD(int32_t, + AddMixedCNAME, + (uint32_t ssrc, const char cname[RTCP_CNAME_SIZE]), + (override)); + MOCK_METHOD(int32_t, RemoveMixedCNAME, (uint32_t ssrc), (override)); + MOCK_METHOD(int32_t, + RTT, + (uint32_t remote_ssrc, + int64_t* rtt, + int64_t* avg_rtt, + int64_t* min_rtt, + int64_t* max_rtt), + (const override)); + MOCK_METHOD(int64_t, ExpectedRetransmissionTimeMs, (), (const override)); + MOCK_METHOD(int32_t, SendRTCP, (RTCPPacketType packet_type), (override)); + MOCK_METHOD(int32_t, + DataCountersRTP, + (size_t * bytes_sent, uint32_t* packets_sent), + (const override)); + MOCK_METHOD(void, + GetSendStreamDataCounters, + (StreamDataCounters*, StreamDataCounters*), + (const override)); + MOCK_METHOD(int32_t, + RemoteRTCPStat, + (std::vector * receive_blocks), + (const override)); + MOCK_METHOD(std::vector, + GetLatestReportBlockData, + (), + (const override)); + MOCK_METHOD( + int32_t, + SetRTCPApplicationSpecificData, + (uint8_t sub_type, uint32_t name, const uint8_t* data, uint16_t length), + (override)); + MOCK_METHOD(void, SetRtcpXrRrtrStatus, (bool enable), (override)); + MOCK_METHOD(bool, RtcpXrRrtrStatus, (), (const override)); + MOCK_METHOD(void, + SetRemb, + (int64_t bitrate, std::vector ssrcs), + (override)); + MOCK_METHOD(void, UnsetRemb, (), (override)); + MOCK_METHOD(bool, TMMBR, (), (const override)); + MOCK_METHOD(void, SetTMMBRStatus, (bool enable), (override)); + MOCK_METHOD(int32_t, + SendNACK, + (const uint16_t* nack_list, uint16_t size), + (override)); + MOCK_METHOD(void, + SendNack, + (const std::vector& sequence_numbers), + (override)); + MOCK_METHOD(void, + SetStorePacketsStatus, + (bool enable, uint16_t number_to_store), + (override)); + MOCK_METHOD(bool, StorePackets, (), (const override)); + MOCK_METHOD(void, + SendCombinedRtcpPacket, + (std::vector> rtcp_packets), + (override)); + MOCK_METHOD(int32_t, + SendLossNotification, + (uint16_t last_decoded_seq_num, + uint16_t last_received_seq_num, + bool decodability_flag, + bool buffering_allowed), + (override)); + MOCK_METHOD(void, Process, (), (override)); + MOCK_METHOD(void, + SetVideoBitrateAllocation, + (const VideoBitrateAllocation&), + (override)); + MOCK_METHOD(RTPSender*, RtpSender, (), (override)); + MOCK_METHOD(const RTPSender*, RtpSender, (), (const override)); private: // Mocking this method is currently not required and having a default - // implementation like MOCK_METHOD0(TimeUntilNextProcess, int64_t()) + // implementation like + // MOCK_METHOD(int64_t, TimeUntilNextProcess, (), (override)) // can be dangerous since it can cause a tight loop on a process thread. - virtual int64_t TimeUntilNextProcess() { return 0xffffffff; } + int64_t TimeUntilNextProcess() override { return 0xffffffff; } }; } // namespace webrtc