zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

In modules/ replace mock macros with unified MOCK_METHOD macro

Browse Source 
Bug: webrtc:11564
Change-Id: I8a87389a795029feb818449ab1e5bbe69486db28
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/175908
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31364}
This commit is contained in:
Danil Chapovalov
2020-05-26 19:18:17 +02:00
committed by Commit Bot
parent e309651f33
commit 014197b581
14 changed files with 118 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_unittest.cc
View File

@ -35,10 +35,12 @@ constexpr size_t kPayloadSize = 10;
class MockBitrateEstimator : public BitrateEstimator { class MockBitrateEstimator : public BitrateEstimator {
public: public:
using BitrateEstimator::BitrateEstimator; using BitrateEstimator::BitrateEstimator;
MOCK_METHOD3(Update, MOCK_METHOD(void,
void(Timestamp at_time, DataSize data_size, bool in_alr)); Update,
MOCK_CONST_METHOD0(bitrate, absl::optional<DataRate>()); (Timestamp at_time, DataSize data_size, bool in_alr),
MOCK_METHOD0(ExpectFastRateChange, void()); (override));
MOCK_METHOD(absl::optional<DataRate>, bitrate, (), (const, override));
MOCK_METHOD(void, ExpectFastRateChange, (), (override));
}; };
struct AcknowledgedBitrateEstimatorTestStates { struct AcknowledgedBitrateEstimatorTestStates {

6
modules/congestion_controller/pcc/bitrate_controller_unittest.cc
View File

@ -67,8 +67,10 @@ std::vector<PacketResult> CreatePacketResults(
class MockUtilityFunction : public PccUtilityFunctionInterface { class MockUtilityFunction : public PccUtilityFunctionInterface {
public: public:
MOCK_CONST_METHOD1(Compute, MOCK_METHOD(double,
double(const PccMonitorInterval& monitor_interval)); Compute,
(const PccMonitorInterval& monitor_interval),
(const, override));
}; };
} // namespace } // namespace

6
modules/congestion_controller/receive_side_congestion_controller_unittest.cc
View File

@ -37,8 +37,10 @@ uint32_t AbsSendTime(int64_t t, int64_t denom) {
class MockPacketRouter : public PacketRouter { class MockPacketRouter : public PacketRouter {
public: public:
MOCK_METHOD2(OnReceiveBitrateChanged, MOCK_METHOD(void,
void(const std::vector<uint32_t>& ssrcs, uint32_t bitrate)); OnReceiveBitrateChanged,
(const std::vector<uint32_t>& ssrcs, uint32_t bitrate),
(override));
}; };
const uint32_t kInitialBitrateBps = 60000; const uint32_t kInitialBitrateBps = 60000;

6
modules/congestion_controller/rtp/transport_feedback_adapter_unittest.cc
View File

@ -83,8 +83,10 @@ namespace test {
class MockStreamFeedbackObserver : public webrtc::StreamFeedbackObserver { class MockStreamFeedbackObserver : public webrtc::StreamFeedbackObserver {
public: public:
MOCK_METHOD1(OnPacketFeedbackVector, MOCK_METHOD(void,
void(std::vector<StreamPacketInfo> packet_feedback_vector)); OnPacketFeedbackVector,
(std::vector<StreamPacketInfo> packet_feedback_vector),
(override));
}; };
class TransportFeedbackAdapterTest : public ::testing::Test { class TransportFeedbackAdapterTest : public ::testing::Test {

6
modules/congestion_controller/rtp/transport_feedback_demuxer_unittest.cc
View File

@ -21,8 +21,10 @@ static constexpr uint32_t kSsrc = 8492;
class MockStreamFeedbackObserver : public webrtc::StreamFeedbackObserver { class MockStreamFeedbackObserver : public webrtc::StreamFeedbackObserver {
public: public:
MOCK_METHOD1(OnPacketFeedbackVector, MOCK_METHOD(void,
void(std::vector<StreamPacketInfo> packet_feedback_vector)); OnPacketFeedbackVector,
(std::vector<StreamPacketInfo> packet_feedback_vector),
(override));
}; };
RtpPacketSendInfo CreatePacket(uint32_t ssrc, RtpPacketSendInfo CreatePacket(uint32_t ssrc,

15
modules/pacing/paced_sender_unittest.cc
View File

@ -39,12 +39,15 @@ constexpr size_t kDefaultPacketSize = 234;
// Mock callback implementing the raw api. // Mock callback implementing the raw api.
class MockCallback : public PacketRouter { class MockCallback : public PacketRouter {
public: public:
MOCK_METHOD2(SendPacket, MOCK_METHOD(void,
void(std::unique_ptr<RtpPacketToSend> packet, SendPacket,
const PacedPacketInfo& cluster_info)); (std::unique_ptr<RtpPacketToSend> packet,
MOCK_METHOD1( const PacedPacketInfo& cluster_info),
GeneratePadding, (override));
std::vector<std::unique_ptr<RtpPacketToSend>>(DataSize target_size)); MOCK_METHOD(std::vector<std::unique_ptr<RtpPacketToSend>>,
GeneratePadding,
(DataSize target_size),
(override));
}; };
class ProcessModeTrials : public WebRtcKeyValueConfig { class ProcessModeTrials : public WebRtcKeyValueConfig {

30
modules/pacing/pacing_controller_unittest.cc
View File

@ -90,24 +90,28 @@ class MockPacingControllerCallback : public PacingController::PacketSender {
return ret; return ret;
} }
MOCK_METHOD5(SendPacket, MOCK_METHOD(void,
void(uint32_t ssrc, SendPacket,
uint16_t sequence_number, (uint32_t ssrc,
int64_t capture_timestamp, uint16_t sequence_number,
bool retransmission, int64_t capture_timestamp,
bool padding)); bool retransmission,
MOCK_METHOD1(SendPadding, size_t(size_t target_size)); bool padding));
MOCK_METHOD(size_t, SendPadding, (size_t target_size));
}; };
// Mock callback implementing the raw api. // Mock callback implementing the raw api.
class MockPacketSender : public PacingController::PacketSender { class MockPacketSender : public PacingController::PacketSender {
public: public:
MOCK_METHOD2(SendPacket, MOCK_METHOD(void,
void(std::unique_ptr<RtpPacketToSend> packet, SendPacket,
const PacedPacketInfo& cluster_info)); (std::unique_ptr<RtpPacketToSend> packet,
MOCK_METHOD1( const PacedPacketInfo& cluster_info),
GeneratePadding, (override));
std::vector<std::unique_ptr<RtpPacketToSend>>(DataSize target_size)); MOCK_METHOD(std::vector<std::unique_ptr<RtpPacketToSend>>,
GeneratePadding,
(DataSize target_size),
(override));
}; };
class PacingControllerPadding : public PacingController::PacketSender { class PacingControllerPadding : public PacingController::PacketSender {

15
modules/pacing/task_queue_paced_sender_unittest.cc
View File

@ -38,12 +38,15 @@ constexpr size_t kDefaultPacketSize = 1234;
class MockPacketRouter : public PacketRouter { class MockPacketRouter : public PacketRouter {
public: public:
MOCK_METHOD2(SendPacket, MOCK_METHOD(void,
void(std::unique_ptr<RtpPacketToSend> packet, SendPacket,
const PacedPacketInfo& cluster_info)); (std::unique_ptr<RtpPacketToSend> packet,
MOCK_METHOD1( const PacedPacketInfo& cluster_info),
GeneratePadding, (override));
std::vector<std::unique_ptr<RtpPacketToSend>>(DataSize target_size)); MOCK_METHOD(std::vector<std::unique_ptr<RtpPacketToSend>>,
GeneratePadding,
(DataSize target_size),
(override));
}; };
} // namespace } // namespace

7
modules/remote_bitrate_estimator/remote_estimator_proxy_unittest.cc
View File

@ -65,9 +65,10 @@ std::vector<int64_t> TimestampsMs(
class MockTransportFeedbackSender : public TransportFeedbackSenderInterface { class MockTransportFeedbackSender : public TransportFeedbackSenderInterface {
public: public:
MOCK_METHOD1( MOCK_METHOD(bool,
SendCombinedRtcpPacket, SendCombinedRtcpPacket,
bool(std::vector<std::unique_ptr<rtcp::RtcpPacket>> feedback_packets)); (std::vector<std::unique_ptr<rtcp::RtcpPacket>> feedback_packets),
(override));
}; };
class RemoteEstimatorProxyTest : public ::testing::Test { class RemoteEstimatorProxyTest : public ::testing::Test {

2
modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h
View File

@ -19,7 +19,7 @@ namespace webrtc {
class MockRtcpRttStats : public RtcpRttStats { class MockRtcpRttStats : public RtcpRttStats {
public: public:
MOCK_METHOD(void, OnRttUpdate, (int64_t rtt), (override)); MOCK_METHOD(void, OnRttUpdate, (int64_t rtt), (override));
MOCK_METHOD(int64_t, LastProcessedRtt, (), (const override)); MOCK_METHOD(int64_t, LastProcessedRtt, (), (const, override));
}; };
} // namespace webrtc } // namespace webrtc
#endif // MODULES_RTP_RTCP_MOCKS_MOCK_RTCP_RTT_STATS_H_ #endif // MODULES_RTP_RTCP_MOCKS_MOCK_RTCP_RTT_STATS_H_

68
modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
View File

@ -35,7 +35,7 @@ class MockRtpRtcp : public RtpRtcp {
(override)); (override));
MOCK_METHOD(void, SetRemoteSSRC, (uint32_t ssrc), (override)); MOCK_METHOD(void, SetRemoteSSRC, (uint32_t ssrc), (override));
MOCK_METHOD(void, SetMaxRtpPacketSize, (size_t size), (override)); MOCK_METHOD(void, SetMaxRtpPacketSize, (size_t size), (override));
MOCK_METHOD(size_t, MaxRtpPacketSize, (), (const override)); MOCK_METHOD(size_t, MaxRtpPacketSize, (), (const, override));
MOCK_METHOD(void, MOCK_METHOD(void,
RegisterSendPayloadFrequency, RegisterSendPayloadFrequency,
(int payload_type, int frequency), (int payload_type, int frequency),
@ -61,32 +61,30 @@ class MockRtpRtcp : public RtpRtcp {
DeregisterSendRtpHeaderExtension, DeregisterSendRtpHeaderExtension,
(absl::string_view uri), (absl::string_view uri),
(override)); (override));
MOCK_METHOD(bool, SupportsPadding, (), (const override)); MOCK_METHOD(bool, SupportsPadding, (), (const, override));
MOCK_METHOD(bool, SupportsRtxPayloadPadding, (), (const override)); MOCK_METHOD(bool, SupportsRtxPayloadPadding, (), (const, override));
MOCK_METHOD(uint32_t, StartTimestamp, (), (const override)); MOCK_METHOD(uint32_t, StartTimestamp, (), (const, override));
MOCK_METHOD(void, SetStartTimestamp, (uint32_t timestamp), (override)); MOCK_METHOD(void, SetStartTimestamp, (uint32_t timestamp), (override));
MOCK_METHOD(uint16_t, SequenceNumber, (), (const override)); MOCK_METHOD(uint16_t, SequenceNumber, (), (const, override));
MOCK_METHOD(void, SetSequenceNumber, (uint16_t seq), (override)); MOCK_METHOD(void, SetSequenceNumber, (uint16_t seq), (override));
MOCK_METHOD(void, SetRtpState, (const RtpState& rtp_state), (override)); MOCK_METHOD(void, SetRtpState, (const RtpState& rtp_state), (override));
MOCK_METHOD(void, SetRtxState, (const RtpState& rtp_state), (override)); MOCK_METHOD(void, SetRtxState, (const RtpState& rtp_state), (override));
MOCK_METHOD(RtpState, GetRtpState, (), (const override)); MOCK_METHOD(RtpState, GetRtpState, (), (const, override));
MOCK_METHOD(RtpState, GetRtxState, (), (const override)); MOCK_METHOD(RtpState, GetRtxState, (), (const, override));
MOCK_METHOD(uint32_t, SSRC, (), (const override)); MOCK_METHOD(uint32_t, SSRC, (), (const, override));
MOCK_METHOD(void, SetRid, (const std::string& rid), (override)); MOCK_METHOD(void, SetRid, (const std::string& rid), (override));
MOCK_METHOD(void, SetMid, (const std::string& mid), (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<uint32_t>& csrcs), (override)); MOCK_METHOD(void, SetCsrcs, (const std::vector<uint32_t>& csrcs), (override));
MOCK_METHOD(void, SetRtxSendStatus, (int modes), (override)); MOCK_METHOD(void, SetRtxSendStatus, (int modes), (override));
MOCK_METHOD(int, RtxSendStatus, (), (const override)); MOCK_METHOD(int, RtxSendStatus, (), (const, override));
MOCK_METHOD(absl::optional<uint32_t>, RtxSsrc, (), (const override)); MOCK_METHOD(absl::optional<uint32_t>, RtxSsrc, (), (const, override));
MOCK_METHOD(void, SetRtxSendPayloadType, (int, int), (override)); MOCK_METHOD(void, SetRtxSendPayloadType, (int, int), (override));
MOCK_METHOD(absl::optional<uint32_t>, FlexfecSsrc, (), (const override)); MOCK_METHOD(absl::optional<uint32_t>, FlexfecSsrc, (), (const, override));
MOCK_METHOD((std::pair<int, int>), RtxSendPayloadType, (), (const override));
MOCK_METHOD(int32_t, SetSendingStatus, (bool sending), (override)); MOCK_METHOD(int32_t, SetSendingStatus, (bool sending), (override));
MOCK_METHOD(bool, Sending, (), (const override)); MOCK_METHOD(bool, Sending, (), (const, override));
MOCK_METHOD(void, SetSendingMediaStatus, (bool sending), (override)); MOCK_METHOD(void, SetSendingMediaStatus, (bool sending), (override));
MOCK_METHOD(bool, SendingMedia, (), (const override)); MOCK_METHOD(bool, SendingMedia, (), (const, override));
MOCK_METHOD(bool, IsAudioConfigured, (), (const override)); MOCK_METHOD(bool, IsAudioConfigured, (), (const, override));
MOCK_METHOD(void, SetAsPartOfAllocation, (bool), (override)); MOCK_METHOD(void, SetAsPartOfAllocation, (bool), (override));
MOCK_METHOD(void, MOCK_METHOD(void,
BitrateSent, BitrateSent,
@ -94,12 +92,8 @@ class MockRtpRtcp : public RtpRtcp {
uint32_t* video_rate, uint32_t* video_rate,
uint32_t* fec_rate, uint32_t* fec_rate,
uint32_t* nack_rate), uint32_t* nack_rate),
(const override)); (const, override));
MOCK_METHOD(RtpSendRates, GetSendRates, (), (const override)); MOCK_METHOD(RtpSendRates, GetSendRates, (), (const, override));
MOCK_METHOD(int,
EstimatedReceiveBandwidth,
(uint32_t * available_bandwidth),
(const override));
MOCK_METHOD(bool, MOCK_METHOD(bool,
OnSendingRtpFrame, OnSendingRtpFrame,
(uint32_t, int64_t, int, bool), (uint32_t, int64_t, int, bool),
@ -119,9 +113,9 @@ class MockRtpRtcp : public RtpRtcp {
MOCK_METHOD(std::vector<RtpSequenceNumberMap::Info>, MOCK_METHOD(std::vector<RtpSequenceNumberMap::Info>,
GetSentRtpPacketInfos, GetSentRtpPacketInfos,
(rtc::ArrayView<const uint16_t> sequence_numbers), (rtc::ArrayView<const uint16_t> sequence_numbers),
(const override)); (const, override));
MOCK_METHOD(size_t, ExpectedPerPacketOverhead, (), (const override)); MOCK_METHOD(size_t, ExpectedPerPacketOverhead, (), (const, override));
MOCK_METHOD(RtcpMode, RTCP, (), (const override)); MOCK_METHOD(RtcpMode, RTCP, (), (const, override));
MOCK_METHOD(void, SetRTCPStatus, (RtcpMode method), (override)); MOCK_METHOD(void, SetRTCPStatus, (RtcpMode method), (override));
MOCK_METHOD(int32_t, MOCK_METHOD(int32_t,
SetCNAME, SetCNAME,
@ -130,7 +124,7 @@ class MockRtpRtcp : public RtpRtcp {
MOCK_METHOD(int32_t, MOCK_METHOD(int32_t,
RemoteCNAME, RemoteCNAME,
(uint32_t remote_ssrc, char cname[RTCP_CNAME_SIZE]), (uint32_t remote_ssrc, char cname[RTCP_CNAME_SIZE]),
(const override)); (const, override));
MOCK_METHOD(int32_t, MOCK_METHOD(int32_t,
RemoteNTP, RemoteNTP,
(uint32_t * received_ntp_secs, (uint32_t * received_ntp_secs,
@ -138,7 +132,7 @@ class MockRtpRtcp : public RtpRtcp {
uint32_t* rtcp_arrival_time_secs, uint32_t* rtcp_arrival_time_secs,
uint32_t* rtcp_arrival_time_frac, uint32_t* rtcp_arrival_time_frac,
uint32_t* rtcp_timestamp), uint32_t* rtcp_timestamp),
(const override)); (const, override));
MOCK_METHOD(int32_t, MOCK_METHOD(int32_t,
AddMixedCNAME, AddMixedCNAME,
(uint32_t ssrc, const char cname[RTCP_CNAME_SIZE]), (uint32_t ssrc, const char cname[RTCP_CNAME_SIZE]),
@ -151,38 +145,38 @@ class MockRtpRtcp : public RtpRtcp {
int64_t* avg_rtt, int64_t* avg_rtt,
int64_t* min_rtt, int64_t* min_rtt,
int64_t* max_rtt), int64_t* max_rtt),
(const override)); (const, override));
MOCK_METHOD(int64_t, ExpectedRetransmissionTimeMs, (), (const override)); MOCK_METHOD(int64_t, ExpectedRetransmissionTimeMs, (), (const, override));
MOCK_METHOD(int32_t, SendRTCP, (RTCPPacketType packet_type), (override)); MOCK_METHOD(int32_t, SendRTCP, (RTCPPacketType packet_type), (override));
MOCK_METHOD(int32_t, MOCK_METHOD(int32_t,
DataCountersRTP, DataCountersRTP,
(size_t * bytes_sent, uint32_t* packets_sent), (size_t * bytes_sent, uint32_t* packets_sent),
(const override)); (const, override));
MOCK_METHOD(void, MOCK_METHOD(void,
GetSendStreamDataCounters, GetSendStreamDataCounters,
(StreamDataCounters*, StreamDataCounters*), (StreamDataCounters*, StreamDataCounters*),
(const override)); (const, override));
MOCK_METHOD(int32_t, MOCK_METHOD(int32_t,
RemoteRTCPStat, RemoteRTCPStat,
(std::vector<RTCPReportBlock> * receive_blocks), (std::vector<RTCPReportBlock> * receive_blocks),
(const override)); (const, override));
MOCK_METHOD(std::vector<ReportBlockData>, MOCK_METHOD(std::vector<ReportBlockData>,
GetLatestReportBlockData, GetLatestReportBlockData,
(), (),
(const override)); (const, override));
MOCK_METHOD( MOCK_METHOD(
int32_t, int32_t,
SetRTCPApplicationSpecificData, SetRTCPApplicationSpecificData,
(uint8_t sub_type, uint32_t name, const uint8_t* data, uint16_t length), (uint8_t sub_type, uint32_t name, const uint8_t* data, uint16_t length),
(override)); (override));
MOCK_METHOD(void, SetRtcpXrRrtrStatus, (bool enable), (override)); MOCK_METHOD(void, SetRtcpXrRrtrStatus, (bool enable), (override));
MOCK_METHOD(bool, RtcpXrRrtrStatus, (), (const override)); MOCK_METHOD(bool, RtcpXrRrtrStatus, (), (const, override));
MOCK_METHOD(void, MOCK_METHOD(void,
SetRemb, SetRemb,
(int64_t bitrate, std::vector<uint32_t> ssrcs), (int64_t bitrate, std::vector<uint32_t> ssrcs),
(override)); (override));
MOCK_METHOD(void, UnsetRemb, (), (override)); MOCK_METHOD(void, UnsetRemb, (), (override));
MOCK_METHOD(bool, TMMBR, (), (const override)); MOCK_METHOD(bool, TMMBR, (), (const, override));
MOCK_METHOD(void, SetTMMBRStatus, (bool enable), (override)); MOCK_METHOD(void, SetTMMBRStatus, (bool enable), (override));
MOCK_METHOD(int32_t, MOCK_METHOD(int32_t,
SendNACK, SendNACK,
@ -196,7 +190,7 @@ class MockRtpRtcp : public RtpRtcp {
SetStorePacketsStatus, SetStorePacketsStatus,
(bool enable, uint16_t number_to_store), (bool enable, uint16_t number_to_store),
(override)); (override));
MOCK_METHOD(bool, StorePackets, (), (const override)); MOCK_METHOD(bool, StorePackets, (), (const, override));
MOCK_METHOD(void, MOCK_METHOD(void,
SendCombinedRtcpPacket, SendCombinedRtcpPacket,
(std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets), (std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets),
@ -214,7 +208,7 @@ class MockRtpRtcp : public RtpRtcp {
(const VideoBitrateAllocation&), (const VideoBitrateAllocation&),
(override)); (override));
MOCK_METHOD(RTPSender*, RtpSender, (), (override)); MOCK_METHOD(RTPSender*, RtpSender, (), (override));
MOCK_METHOD(const RTPSender*, RtpSender, (), (const override)); MOCK_METHOD(const RTPSender*, RtpSender, (), (const, override));
private: private:
// Mocking this method is currently not required and having a default // Mocking this method is currently not required and having a default

12
modules/rtp_rtcp/source/rtcp_transceiver_impl_unittest.cc
View File

@ -55,15 +55,17 @@ using ::webrtc::test::RtcpPacketParser;
class MockReceiveStatisticsProvider : public webrtc::ReceiveStatisticsProvider { class MockReceiveStatisticsProvider : public webrtc::ReceiveStatisticsProvider {
public: public:
MOCK_METHOD1(RtcpReportBlocks, std::vector<ReportBlock>(size_t)); MOCK_METHOD(std::vector<ReportBlock>, RtcpReportBlocks, (size_t), (override));
}; };
class MockMediaReceiverRtcpObserver : public webrtc::MediaReceiverRtcpObserver { class MockMediaReceiverRtcpObserver : public webrtc::MediaReceiverRtcpObserver {
public: public:
MOCK_METHOD3(OnSenderReport, void(uint32_t, NtpTime, uint32_t)); MOCK_METHOD(void, OnSenderReport, (uint32_t, NtpTime, uint32_t), (override));
MOCK_METHOD1(OnBye, void(uint32_t)); MOCK_METHOD(void, OnBye, (uint32_t), (override));
MOCK_METHOD2(OnBitrateAllocation, MOCK_METHOD(void,
void(uint32_t, const VideoBitrateAllocation&)); OnBitrateAllocation,
(uint32_t, const VideoBitrateAllocation&),
(override));
}; };
// Since some tests will need to wait for this period, make it small to avoid // Since some tests will need to wait for this period, make it small to avoid

5
modules/rtp_rtcp/source/rtcp_transceiver_unittest.cc
View File

@ -42,7 +42,10 @@ using ::webrtc::test::RtcpPacketParser;
class MockMediaReceiverRtcpObserver : public webrtc::MediaReceiverRtcpObserver { class MockMediaReceiverRtcpObserver : public webrtc::MediaReceiverRtcpObserver {
public: public:
MOCK_METHOD3(OnSenderReport, void(uint32_t, webrtc::NtpTime, uint32_t)); MOCK_METHOD(void,
OnSenderReport,
(uint32_t, webrtc::NtpTime, uint32_t),
(override));
}; };
constexpr int kTimeoutMs = 1000; constexpr int kTimeoutMs = 1000;

29
modules/rtp_rtcp/source/rtp_sender_unittest.cc
View File

@ -149,33 +149,32 @@ class MockRtpPacketPacer : public RtpPacketSender {
MockRtpPacketPacer() {} MockRtpPacketPacer() {}
virtual ~MockRtpPacketPacer() {} virtual ~MockRtpPacketPacer() {}
MOCK_METHOD1(EnqueuePackets, MOCK_METHOD(void,
void(std::vector<std::unique_ptr<RtpPacketToSend>>)); EnqueuePackets,
(std::vector<std::unique_ptr<RtpPacketToSend>>),
MOCK_METHOD2(CreateProbeCluster, void(int bitrate_bps, int cluster_id)); (override));
MOCK_METHOD0(Pause, void());
MOCK_METHOD0(Resume, void());
MOCK_METHOD1(SetCongestionWindow,
void(absl::optional<int64_t> congestion_window_bytes));
MOCK_METHOD1(UpdateOutstandingData, void(int64_t outstanding_bytes));
MOCK_METHOD1(SetAccountForAudioPackets, void(bool account_for_audio));
}; };
class MockSendSideDelayObserver : public SendSideDelayObserver { class MockSendSideDelayObserver : public SendSideDelayObserver {
public: public:
MOCK_METHOD4(SendSideDelayUpdated, void(int, int, uint64_t, uint32_t)); MOCK_METHOD(void,
SendSideDelayUpdated,
(int, int, uint64_t, uint32_t),
(override));
}; };
class MockSendPacketObserver : public SendPacketObserver { class MockSendPacketObserver : public SendPacketObserver {
public: public:
MOCK_METHOD3(OnSendPacket, void(uint16_t, int64_t, uint32_t)); MOCK_METHOD(void, OnSendPacket, (uint16_t, int64_t, uint32_t), (override));
}; };
class MockTransportFeedbackObserver : public TransportFeedbackObserver { class MockTransportFeedbackObserver : public TransportFeedbackObserver {
public: public:
MOCK_METHOD1(OnAddPacket, void(const RtpPacketSendInfo&)); MOCK_METHOD(void, OnAddPacket, (const RtpPacketSendInfo&), (override));
MOCK_METHOD1(OnTransportFeedback, void(const rtcp::TransportFeedback&)); MOCK_METHOD(void,
OnTransportFeedback,
(const rtcp::TransportFeedback&),
(override));
}; };
class StreamDataTestCallback : public StreamDataCountersCallback { class StreamDataTestCallback : public StreamDataCountersCallback {