In call/ replace mock macros with unified MOCK_METHOD macro

Bug: webrtc:11564
Change-Id: I81d06041b80ce470e4859c4d0ebad7ff0f831af9
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/175134
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31276}

call/adaptation/resource_unittest.cc

@@ -28,7 +28,8 @@ class MockResourceListener : public ResourceListener {
  public:
   MOCK_METHOD(void,
               OnResourceUsageStateMeasured,
-              (rtc::scoped_refptr<Resource> resource));
+              (rtc::scoped_refptr<Resource> resource),
+              (override));
 };
 
 class ResourceTest : public ::testing::Test {

call/adaptation/test/fake_frame_rate_provider.h

@@ -21,29 +21,41 @@ namespace webrtc {
 
 class MockVideoStreamEncoderObserver : public VideoStreamEncoderObserver {
  public:
-  MOCK_METHOD2(OnEncodedFrameTimeMeasured, void(int, int));
+  MOCK_METHOD(void, OnEncodedFrameTimeMeasured, (int, int), (override));
-  MOCK_METHOD2(OnIncomingFrame, void(int, int));
+  MOCK_METHOD(void, OnIncomingFrame, (int, int), (override));
-  MOCK_METHOD2(OnSendEncodedImage,
+  MOCK_METHOD(void,
-               void(const EncodedImage&, const CodecSpecificInfo*));
+              OnSendEncodedImage,
-  MOCK_METHOD1(OnEncoderImplementationChanged, void(const std::string&));
+              (const EncodedImage&, const CodecSpecificInfo*),
-  MOCK_METHOD1(OnFrameDropped, void(DropReason));
+              (override));
-  MOCK_METHOD2(OnEncoderReconfigured,
+  MOCK_METHOD(void,
-               void(const VideoEncoderConfig&,
+              OnEncoderImplementationChanged,
-                    const std::vector<VideoStream>&));
+              (const std::string&),
-  MOCK_METHOD3(OnAdaptationChanged,
+              (override));
-               void(VideoAdaptationReason,
+  MOCK_METHOD(void, OnFrameDropped, (DropReason), (override));
+  MOCK_METHOD(void,
+              OnEncoderReconfigured,
+              (const VideoEncoderConfig&, const std::vector<VideoStream>&),
+              (override));
+  MOCK_METHOD(void,
+              OnAdaptationChanged,
+              (VideoAdaptationReason,
                const VideoAdaptationCounters&,
-                    const VideoAdaptationCounters&));
+               const VideoAdaptationCounters&),
-  MOCK_METHOD0(ClearAdaptationStats, void());
+              (override));
-  MOCK_METHOD2(UpdateAdaptationSettings,
+  MOCK_METHOD(void, ClearAdaptationStats, (), (override));
-               void(AdaptationSettings, AdaptationSettings));
+  MOCK_METHOD(void,
-  MOCK_METHOD0(OnMinPixelLimitReached, void());
+              UpdateAdaptationSettings,
-  MOCK_METHOD0(OnInitialQualityResolutionAdaptDown, void());
+              (AdaptationSettings, AdaptationSettings),
-  MOCK_METHOD1(OnSuspendChange, void(bool));
+              (override));
-  MOCK_METHOD2(OnBitrateAllocationUpdated,
+  MOCK_METHOD(void, OnMinPixelLimitReached, (), (override));
-               void(const VideoCodec&, const VideoBitrateAllocation&));
+  MOCK_METHOD(void, OnInitialQualityResolutionAdaptDown, (), (override));
-  MOCK_METHOD1(OnEncoderInternalScalerUpdate, void(bool));
+  MOCK_METHOD(void, OnSuspendChange, (bool), (override));
-  MOCK_CONST_METHOD0(GetInputFrameRate, int());
+  MOCK_METHOD(void,
+              OnBitrateAllocationUpdated,
+              (const VideoCodec&, const VideoBitrateAllocation&),
+              (override));
+  MOCK_METHOD(void, OnEncoderInternalScalerUpdate, (bool), (override));
+  MOCK_METHOD(int, GetInputFrameRate, (), (const, override));
 };
 
 class FakeFrameRateProvider : public MockVideoStreamEncoderObserver {

call/bitrate_allocator_unittest.cc

@@ -47,7 +47,10 @@ auto AllocationLimitsEq(uint32_t min_allocatable_rate_bps,
 
 class MockLimitObserver : public BitrateAllocator::LimitObserver {
  public:
-  MOCK_METHOD1(OnAllocationLimitsChanged, void(BitrateAllocationLimits));
+  MOCK_METHOD(void,
+              OnAllocationLimitsChanged,
+              (BitrateAllocationLimits),
+              (override));
 };
 
 class TestBitrateObserver : public BitrateAllocatorObserver {

call/fake_network_pipe_unittest.cc

@@ -24,8 +24,10 @@ namespace webrtc {
 
 class MockReceiver : public PacketReceiver {
  public:
-  MOCK_METHOD3(DeliverPacket,
+  MOCK_METHOD(DeliveryStatus,
-               DeliveryStatus(MediaType, rtc::CopyOnWriteBuffer, int64_t));
+              DeliverPacket,
+              (MediaType, rtc::CopyOnWriteBuffer, int64_t),
+              (override));
   virtual ~MockReceiver() = default;
 };
 

call/rtcp_demuxer_unittest.cc

@@ -37,7 +37,7 @@ using ::testing::NiceMock;
 
 class MockRtcpPacketSink : public RtcpPacketSinkInterface {
  public:
-  MOCK_METHOD1(OnRtcpPacket, void(rtc::ArrayView<const uint8_t>));
+  MOCK_METHOD(void, OnRtcpPacket, (rtc::ArrayView<const uint8_t>), (override));
 };
 
 class RtcpDemuxerTest : public ::testing::Test {

call/rtp_demuxer_unittest.cc

@@ -37,14 +37,22 @@ using ::testing::NiceMock;
 
 class MockSsrcBindingObserver : public SsrcBindingObserver {
  public:
-  MOCK_METHOD2(OnSsrcBoundToRsid, void(const std::string& rsid, uint32_t ssrc));
+  MOCK_METHOD(void,
-  MOCK_METHOD2(OnSsrcBoundToMid, void(const std::string& mid, uint32_t ssrc));
+              OnSsrcBoundToRsid,
-  MOCK_METHOD3(OnSsrcBoundToMidRsid,
+              (const std::string& rsid, uint32_t ssrc),
-               void(const std::string& mid,
+              (override));
-                    const std::string& rsid,
+  MOCK_METHOD(void,
-                    uint32_t ssrc));
+              OnSsrcBoundToMid,
-  MOCK_METHOD2(OnSsrcBoundToPayloadType,
+              (const std::string& mid, uint32_t ssrc),
-               void(uint8_t payload_type, uint32_t ssrc));
+              (override));
+  MOCK_METHOD(void,
+              OnSsrcBoundToMidRsid,
+              (const std::string& mid, const std::string& rsid, uint32_t ssrc),
+              (override));
+  MOCK_METHOD(void,
+              OnSsrcBoundToPayloadType,
+              (uint8_t payload_type, uint32_t ssrc),
+              (override));
 };
 
 class RtpDemuxerTest : public ::testing::Test {

call/rtp_video_sender_unittest.cc

@@ -56,7 +56,7 @@ const int kDependencyDescriptorExtensionId = 8;
 
 class MockRtcpIntraFrameObserver : public RtcpIntraFrameObserver {
  public:
-  MOCK_METHOD1(OnReceivedIntraFrameRequest, void(uint32_t));
+  MOCK_METHOD(void, OnReceivedIntraFrameRequest, (uint32_t), (override));
 };
 
 RtpSenderObservers CreateObservers(
@@ -361,8 +361,10 @@ TEST(RtpVideoSenderTest, CreateWithPreviousStates) {
 TEST(RtpVideoSenderTest, FrameCountCallbacks) {
   class MockFrameCountObserver : public FrameCountObserver {
    public:
-    MOCK_METHOD2(FrameCountUpdated,
+    MOCK_METHOD(void,
-                 void(const FrameCounts& frame_counts, uint32_t ssrc));
+                FrameCountUpdated,
+                (const FrameCounts& frame_counts, uint32_t ssrc),
+                (override));
   } callback;
 
   RtpVideoSenderTestFixture test({kSsrc1}, {kRtxSsrc1}, kPayloadType, {},

call/test/mock_audio_send_stream.h

@@ -21,23 +21,26 @@ namespace test {
 
 class MockAudioSendStream : public AudioSendStream {
  public:
-  MOCK_CONST_METHOD0(GetConfig, const webrtc::AudioSendStream::Config&());
+  MOCK_METHOD(const webrtc::AudioSendStream::Config&,
-  MOCK_METHOD1(Reconfigure, void(const Config& config));
+              GetConfig,
-  MOCK_METHOD0(Start, void());
+              (),
-  MOCK_METHOD0(Stop, void());
+              (const, override));
+  MOCK_METHOD(void, Reconfigure, (const Config& config), (override));
+  MOCK_METHOD(void, Start, (), (override));
+  MOCK_METHOD(void, Stop, (), (override));
   // GMock doesn't like move-only types, such as std::unique_ptr.
-  virtual void SendAudioData(std::unique_ptr<webrtc::AudioFrame> audio_frame) {
+  void SendAudioData(std::unique_ptr<webrtc::AudioFrame> audio_frame) override {
     SendAudioDataForMock(audio_frame.get());
   }
-  MOCK_METHOD1(SendAudioDataForMock, void(webrtc::AudioFrame* audio_frame));
+  MOCK_METHOD(void, SendAudioDataForMock, (webrtc::AudioFrame*));
-  MOCK_METHOD4(SendTelephoneEvent,
+  MOCK_METHOD(
-               bool(int payload_type,
+      bool,
-                    int payload_frequency,
+      SendTelephoneEvent,
-                    int event,
+      (int payload_type, int payload_frequency, int event, int duration_ms),
-                    int duration_ms));
+      (override));
-  MOCK_METHOD1(SetMuted, void(bool muted));
+  MOCK_METHOD(void, SetMuted, (bool muted), (override));
-  MOCK_CONST_METHOD0(GetStats, Stats());
+  MOCK_METHOD(Stats, GetStats, (), (const, override));
-  MOCK_CONST_METHOD1(GetStats, Stats(bool has_remote_tracks));
+  MOCK_METHOD(Stats, GetStats, (bool has_remote_tracks), (const, override));
 };
 }  // namespace test
 }  // namespace webrtc

call/test/mock_bitrate_allocator.h

@@ -18,10 +18,15 @@
 namespace webrtc {
 class MockBitrateAllocator : public BitrateAllocatorInterface {
  public:
-  MOCK_METHOD2(AddObserver,
+  MOCK_METHOD(void,
-               void(BitrateAllocatorObserver*, MediaStreamAllocationConfig));
+              AddObserver,
-  MOCK_METHOD1(RemoveObserver, void(BitrateAllocatorObserver*));
+              (BitrateAllocatorObserver*, MediaStreamAllocationConfig),
-  MOCK_CONST_METHOD1(GetStartBitrate, int(BitrateAllocatorObserver*));
+              (override));
+  MOCK_METHOD(void, RemoveObserver, (BitrateAllocatorObserver*), (override));
+  MOCK_METHOD(int,
+              GetStartBitrate,
+              (BitrateAllocatorObserver*),
+              (const, override));
 };
 }  // namespace webrtc
 #endif  // CALL_TEST_MOCK_BITRATE_ALLOCATOR_H_

call/test/mock_rtp_packet_sink_interface.h

@@ -17,7 +17,7 @@ namespace webrtc {
 
 class MockRtpPacketSink : public RtpPacketSinkInterface {
  public:
-  MOCK_METHOD1(OnRtpPacket, void(const RtpPacketReceived&));
+  MOCK_METHOD(void, OnRtpPacket, (const RtpPacketReceived&), (override));
 };
 
 }  // namespace webrtc

call/test/mock_rtp_transport_controller_send.h

@@ -32,10 +32,10 @@ namespace webrtc {
 class MockRtpTransportControllerSend
     : public RtpTransportControllerSendInterface {
  public:
-  MOCK_METHOD10(
+  MOCK_METHOD(RtpVideoSenderInterface*,
               CreateRtpVideoSender,
-      RtpVideoSenderInterface*(std::map<uint32_t, RtpState>,
+              ((std::map<uint32_t, RtpState>),
-                               const std::map<uint32_t, RtpPayloadState>&,
+               (const std::map<uint32_t, RtpPayloadState>&),
                const RtpConfig&,
                int rtcp_report_interval_ms,
                Transport*,
@@ -43,34 +43,62 @@ class MockRtpTransportControllerSend
                RtcEventLog*,
                std::unique_ptr<FecController>,
                const RtpSenderFrameEncryptionConfig&,
-                               rtc::scoped_refptr<FrameTransformerInterface>));
+               rtc::scoped_refptr<FrameTransformerInterface>),
-  MOCK_METHOD1(DestroyRtpVideoSender, void(RtpVideoSenderInterface*));
+              (override));
-  MOCK_METHOD0(GetWorkerQueue, rtc::TaskQueue*());
+  MOCK_METHOD(void,
-  MOCK_METHOD0(packet_router, PacketRouter*());
+              DestroyRtpVideoSender,
-  MOCK_METHOD0(network_state_estimate_observer,
+              (RtpVideoSenderInterface*),
-               NetworkStateEstimateObserver*());
+              (override));
-  MOCK_METHOD0(transport_feedback_observer, TransportFeedbackObserver*());
+  MOCK_METHOD(rtc::TaskQueue*, GetWorkerQueue, (), (override));
-  MOCK_METHOD0(packet_sender, RtpPacketSender*());
+  MOCK_METHOD(PacketRouter*, packet_router, (), (override));
-  MOCK_METHOD1(SetAllocatedSendBitrateLimits, void(BitrateAllocationLimits));
+  MOCK_METHOD(NetworkStateEstimateObserver*,
-  MOCK_METHOD1(SetPacingFactor, void(float));
+              network_state_estimate_observer,
-  MOCK_METHOD1(SetQueueTimeLimit, void(int));
+              (),
-  MOCK_METHOD0(GetStreamFeedbackProvider, StreamFeedbackProvider*());
+              (override));
-  MOCK_METHOD1(RegisterTargetTransferRateObserver,
+  MOCK_METHOD(TransportFeedbackObserver*,
-               void(TargetTransferRateObserver*));
+              transport_feedback_observer,
-  MOCK_METHOD2(OnNetworkRouteChanged,
+              (),
-               void(const std::string&, const rtc::NetworkRoute&));
+              (override));
-  MOCK_METHOD1(OnNetworkAvailability, void(bool));
+  MOCK_METHOD(RtpPacketSender*, packet_sender, (), (override));
-  MOCK_METHOD0(GetBandwidthObserver, RtcpBandwidthObserver*());
+  MOCK_METHOD(void,
-  MOCK_CONST_METHOD0(GetPacerQueuingDelayMs, int64_t());
+              SetAllocatedSendBitrateLimits,
-  MOCK_CONST_METHOD0(GetFirstPacketTime, absl::optional<Timestamp>());
+              (BitrateAllocationLimits),
-  MOCK_METHOD1(EnablePeriodicAlrProbing, void(bool));
+              (override));
-  MOCK_METHOD1(OnSentPacket, void(const rtc::SentPacket&));
+  MOCK_METHOD(void, SetPacingFactor, (float), (override));
-  MOCK_METHOD1(SetSdpBitrateParameters, void(const BitrateConstraints&));
+  MOCK_METHOD(void, SetQueueTimeLimit, (int), (override));
-  MOCK_METHOD1(SetClientBitratePreferences, void(const BitrateSettings&));
+  MOCK_METHOD(StreamFeedbackProvider*,
-  MOCK_METHOD1(OnTransportOverheadChanged, void(size_t));
+              GetStreamFeedbackProvider,
-  MOCK_METHOD1(AccountForAudioPacketsInPacedSender, void(bool));
+              (),
-  MOCK_METHOD0(IncludeOverheadInPacedSender, void());
+              (override));
-  MOCK_METHOD1(OnReceivedPacket, void(const ReceivedPacket&));
+  MOCK_METHOD(void,
+              RegisterTargetTransferRateObserver,
+              (TargetTransferRateObserver*),
+              (override));
+  MOCK_METHOD(void,
+              OnNetworkRouteChanged,
+              (const std::string&, const rtc::NetworkRoute&),
+              (override));
+  MOCK_METHOD(void, OnNetworkAvailability, (bool), (override));
+  MOCK_METHOD(RtcpBandwidthObserver*, GetBandwidthObserver, (), (override));
+  MOCK_METHOD(int64_t, GetPacerQueuingDelayMs, (), (const, override));
+  MOCK_METHOD(absl::optional<Timestamp>,
+              GetFirstPacketTime,
+              (),
+              (const, override));
+  MOCK_METHOD(void, EnablePeriodicAlrProbing, (bool), (override));
+  MOCK_METHOD(void, OnSentPacket, (const rtc::SentPacket&), (override));
+  MOCK_METHOD(void,
+              SetSdpBitrateParameters,
+              (const BitrateConstraints&),
+              (override));
+  MOCK_METHOD(void,
+              SetClientBitratePreferences,
+              (const BitrateSettings&),
+              (override));
+  MOCK_METHOD(void, OnTransportOverheadChanged, (size_t), (override));
+  MOCK_METHOD(void, AccountForAudioPacketsInPacedSender, (bool), (override));
+  MOCK_METHOD(void, IncludeOverheadInPacedSender, (), (override));
+  MOCK_METHOD(void, OnReceivedPacket, (const ReceivedPacket&), (override));
 };
 }  // namespace webrtc
 #endif  // CALL_TEST_MOCK_RTP_TRANSPORT_CONTROLLER_SEND_H_