In common_audio/ and modules/audio_* replace mock macros with unified MOCK_METHOD macro

Bug: webrtc:11564
Change-Id: Ib0ffce4de50a13b018926f6ea2865a2ec2fb2ec7
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/175621
Reviewed-by: Henrik Lundin <henrik.lundin@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31333}

common_audio/mocks/mock_smoothing_filter.h

@@ -18,9 +18,9 @@ namespace webrtc {
 
 class MockSmoothingFilter : public SmoothingFilter {
  public:
-  MOCK_METHOD1(AddSample, void(float));
+  MOCK_METHOD(void, AddSample, (float), (override));
-  MOCK_METHOD0(GetAverage, absl::optional<float>());
+  MOCK_METHOD(absl::optional<float>, GetAverage, (), (override));
-  MOCK_METHOD1(SetTimeConstantMs, bool(int));
+  MOCK_METHOD(bool, SetTimeConstantMs, (int), (override));
 };
 
 }  // namespace webrtc

common_audio/resampler/sinc_resampler_unittest.cc

@@ -40,7 +40,7 @@ static const double kKernelInterpolationFactor = 0.5;
 // Helper class to ensure ChunkedResample() functions properly.
 class MockSource : public SincResamplerCallback {
  public:
-  MOCK_METHOD2(Run, void(size_t frames, float* destination));
+  MOCK_METHOD(void, Run, (size_t frames, float* destination), (override));
 };
 
 ACTION(ClearBuffer) {

common_audio/vad/mock/mock_vad.h

@@ -18,14 +18,14 @@ namespace webrtc {
 
 class MockVad : public Vad {
  public:
-  virtual ~MockVad() { Die(); }
+  ~MockVad() override { Die(); }
-  MOCK_METHOD0(Die, void());
+  MOCK_METHOD(void, Die, ());
 
-  MOCK_METHOD3(VoiceActivity,
+  MOCK_METHOD(enum Activity,
-               enum Activity(const int16_t* audio,
+              VoiceActivity,
-                             size_t num_samples,
+              (const int16_t* audio, size_t num_samples, int sample_rate_hz),
-                             int sample_rate_hz));
+              (override));
-  MOCK_METHOD0(Reset, void());
+  MOCK_METHOD(void, Reset, (), (override));
 };
 
 }  // namespace webrtc

modules/audio_coding/audio_network_adaptor/mock/mock_audio_network_adaptor.h

@@ -18,27 +18,38 @@ namespace webrtc {
 
 class MockAudioNetworkAdaptor : public AudioNetworkAdaptor {
  public:
-  virtual ~MockAudioNetworkAdaptor() { Die(); }
+  ~MockAudioNetworkAdaptor() override { Die(); }
-  MOCK_METHOD0(Die, void());
+  MOCK_METHOD(void, Die, ());
 
-  MOCK_METHOD1(SetUplinkBandwidth, void(int uplink_bandwidth_bps));
+  MOCK_METHOD(void, SetUplinkBandwidth, (int uplink_bandwidth_bps), (override));
 
-  MOCK_METHOD1(SetUplinkPacketLossFraction,
+  MOCK_METHOD(void,
-               void(float uplink_packet_loss_fraction));
+              SetUplinkPacketLossFraction,
+              (float uplink_packet_loss_fraction),
+              (override));
 
-  MOCK_METHOD1(SetRtt, void(int rtt_ms));
+  MOCK_METHOD(void, SetRtt, (int rtt_ms), (override));
 
-  MOCK_METHOD1(SetTargetAudioBitrate, void(int target_audio_bitrate_bps));
+  MOCK_METHOD(void,
+              SetTargetAudioBitrate,
+              (int target_audio_bitrate_bps),
+              (override));
 
-  MOCK_METHOD1(SetOverhead, void(size_t overhead_bytes_per_packet));
+  MOCK_METHOD(void,
+              SetOverhead,
+              (size_t overhead_bytes_per_packet),
+              (override));
 
-  MOCK_METHOD0(GetEncoderRuntimeConfig, AudioEncoderRuntimeConfig());
+  MOCK_METHOD(AudioEncoderRuntimeConfig,
+              GetEncoderRuntimeConfig,
+              (),
+              (override));
 
-  MOCK_METHOD1(StartDebugDump, void(FILE* file_handle));
+  MOCK_METHOD(void, StartDebugDump, (FILE * file_handle), (override));
 
-  MOCK_METHOD0(StopDebugDump, void());
+  MOCK_METHOD(void, StopDebugDump, (), (override));
 
-  MOCK_CONST_METHOD0(GetStats, ANAStats());
+  MOCK_METHOD(ANAStats, GetStats, (), (const, override));
 };
 
 }  // namespace webrtc

modules/audio_coding/audio_network_adaptor/mock/mock_controller.h

@@ -18,11 +18,16 @@ namespace webrtc {
 
 class MockController : public Controller {
  public:
-  virtual ~MockController() { Die(); }
+  ~MockController() override { Die(); }
-  MOCK_METHOD0(Die, void());
+  MOCK_METHOD(void, Die, ());
-  MOCK_METHOD1(UpdateNetworkMetrics,
+  MOCK_METHOD(void,
-               void(const NetworkMetrics& network_metrics));
+              UpdateNetworkMetrics,
-  MOCK_METHOD1(MakeDecision, void(AudioEncoderRuntimeConfig* config));
+              (const NetworkMetrics& network_metrics),
+              (override));
+  MOCK_METHOD(void,
+              MakeDecision,
+              (AudioEncoderRuntimeConfig * config),
+              (override));
 };
 
 }  // namespace webrtc

modules/audio_coding/audio_network_adaptor/mock/mock_controller_manager.h

@@ -20,12 +20,13 @@ namespace webrtc {
 
 class MockControllerManager : public ControllerManager {
  public:
-  virtual ~MockControllerManager() { Die(); }
+  ~MockControllerManager() override { Die(); }
-  MOCK_METHOD0(Die, void());
+  MOCK_METHOD(void, Die, ());
-  MOCK_METHOD1(
+  MOCK_METHOD(std::vector<Controller*>,
               GetSortedControllers,
-      std::vector<Controller*>(const Controller::NetworkMetrics& metrics));
+              (const Controller::NetworkMetrics& metrics),
-  MOCK_CONST_METHOD0(GetControllers, std::vector<Controller*>());
+              (override));
+  MOCK_METHOD(std::vector<Controller*>, GetControllers, (), (const, override));
 };
 
 }  // namespace webrtc

modules/audio_coding/audio_network_adaptor/mock/mock_debug_dump_writer.h

@@ -18,20 +18,24 @@ namespace webrtc {
 
 class MockDebugDumpWriter : public DebugDumpWriter {
  public:
-  virtual ~MockDebugDumpWriter() { Die(); }
+  ~MockDebugDumpWriter() override { Die(); }
-  MOCK_METHOD0(Die, void());
+  MOCK_METHOD(void, Die, ());
 
-  MOCK_METHOD2(DumpEncoderRuntimeConfig,
+  MOCK_METHOD(void,
-               void(const AudioEncoderRuntimeConfig& config,
+              DumpEncoderRuntimeConfig,
-                    int64_t timestamp));
+              (const AudioEncoderRuntimeConfig& config, int64_t timestamp),
-  MOCK_METHOD2(DumpNetworkMetrics,
+              (override));
-               void(const Controller::NetworkMetrics& metrics,
+  MOCK_METHOD(void,
-                    int64_t timestamp));
+              DumpNetworkMetrics,
+              (const Controller::NetworkMetrics& metrics, int64_t timestamp),
+              (override));
 #if WEBRTC_ENABLE_PROTOBUF
-  MOCK_METHOD2(DumpControllerManagerConfig,
+  MOCK_METHOD(void,
-               void(const audio_network_adaptor::config::ControllerManager&
+              DumpControllerManagerConfig,
+              (const audio_network_adaptor::config::ControllerManager&
                    controller_manager_config,
-                    int64_t timestamp));
+               int64_t timestamp),
+              (override));
 #endif
 };
 

modules/audio_coding/neteq/mock/mock_decoder_database.h

@@ -23,22 +23,28 @@ class MockDecoderDatabase : public DecoderDatabase {
   explicit MockDecoderDatabase(
       rtc::scoped_refptr<AudioDecoderFactory> factory = nullptr)
       : DecoderDatabase(factory, absl::nullopt) {}
-  virtual ~MockDecoderDatabase() { Die(); }
+  ~MockDecoderDatabase() override { Die(); }
-  MOCK_METHOD0(Die, void());
+  MOCK_METHOD(void, Die, ());
-  MOCK_CONST_METHOD0(Empty, bool());
+  MOCK_METHOD(bool, Empty, (), (const, override));
-  MOCK_CONST_METHOD0(Size, int());
+  MOCK_METHOD(int, Size, (), (const, override));
-  MOCK_METHOD0(Reset, void());
+  MOCK_METHOD(void, Reset, (), (override));
-  MOCK_METHOD2(RegisterPayload,
+  MOCK_METHOD(int,
-               int(int rtp_payload_type, const SdpAudioFormat& audio_format));
+              RegisterPayload,
-  MOCK_METHOD1(Remove, int(uint8_t rtp_payload_type));
+              (int rtp_payload_type, const SdpAudioFormat& audio_format),
-  MOCK_METHOD0(RemoveAll, void());
+              (override));
-  MOCK_CONST_METHOD1(GetDecoderInfo,
+  MOCK_METHOD(int, Remove, (uint8_t rtp_payload_type), (override));
-                     const DecoderInfo*(uint8_t rtp_payload_type));
+  MOCK_METHOD(void, RemoveAll, (), (override));
-  MOCK_METHOD2(SetActiveDecoder,
+  MOCK_METHOD(const DecoderInfo*,
-               int(uint8_t rtp_payload_type, bool* new_decoder));
+              GetDecoderInfo,
-  MOCK_CONST_METHOD0(GetActiveDecoder, AudioDecoder*());
+              (uint8_t rtp_payload_type),
-  MOCK_METHOD1(SetActiveCngDecoder, int(uint8_t rtp_payload_type));
+              (const, override));
-  MOCK_CONST_METHOD0(GetActiveCngDecoder, ComfortNoiseDecoder*());
+  MOCK_METHOD(int,
+              SetActiveDecoder,
+              (uint8_t rtp_payload_type, bool* new_decoder),
+              (override));
+  MOCK_METHOD(AudioDecoder*, GetActiveDecoder, (), (const, override));
+  MOCK_METHOD(int, SetActiveCngDecoder, (uint8_t rtp_payload_type), (override));
+  MOCK_METHOD(ComfortNoiseDecoder*, GetActiveCngDecoder, (), (const, override));
 };
 
 }  // namespace webrtc

modules/audio_coding/neteq/mock/mock_dtmf_buffer.h

@@ -19,13 +19,16 @@ namespace webrtc {
 class MockDtmfBuffer : public DtmfBuffer {
  public:
   MockDtmfBuffer(int fs) : DtmfBuffer(fs) {}
-  virtual ~MockDtmfBuffer() { Die(); }
+  ~MockDtmfBuffer() override { Die(); }
-  MOCK_METHOD0(Die, void());
+  MOCK_METHOD(void, Die, ());
-  MOCK_METHOD0(Flush, void());
+  MOCK_METHOD(void, Flush, (), (override));
-  MOCK_METHOD1(InsertEvent, int(const DtmfEvent& event));
+  MOCK_METHOD(int, InsertEvent, (const DtmfEvent& event), (override));
-  MOCK_METHOD2(GetEvent, bool(uint32_t current_timestamp, DtmfEvent* event));
+  MOCK_METHOD(bool,
-  MOCK_CONST_METHOD0(Length, size_t());
+              GetEvent,
-  MOCK_CONST_METHOD0(Empty, bool());
+              (uint32_t current_timestamp, DtmfEvent* event),
+              (override));
+  MOCK_METHOD(size_t, Length, (), (const, override));
+  MOCK_METHOD(bool, Empty, (), (const, override));
 };
 
 }  // namespace webrtc

modules/audio_coding/neteq/mock/mock_dtmf_tone_generator.h

@@ -18,12 +18,15 @@ namespace webrtc {
 
 class MockDtmfToneGenerator : public DtmfToneGenerator {
  public:
-  virtual ~MockDtmfToneGenerator() { Die(); }
+  ~MockDtmfToneGenerator() override { Die(); }
-  MOCK_METHOD0(Die, void());
+  MOCK_METHOD(void, Die, ());
-  MOCK_METHOD3(Init, int(int fs, int event, int attenuation));
+  MOCK_METHOD(int, Init, (int fs, int event, int attenuation), (override));
-  MOCK_METHOD0(Reset, void());
+  MOCK_METHOD(void, Reset, (), (override));
-  MOCK_METHOD2(Generate, int(size_t num_samples, AudioMultiVector* output));
+  MOCK_METHOD(int,
-  MOCK_CONST_METHOD0(initialized, bool());
+              Generate,
+              (size_t num_samples, AudioMultiVector* output),
+              (override));
+  MOCK_METHOD(bool, initialized, (), (const, override));
 };
 
 }  // namespace webrtc

modules/audio_coding/neteq/mock/mock_expand.h

@@ -30,13 +30,13 @@ class MockExpand : public Expand {
                statistics,
                fs,
                num_channels) {}
-  virtual ~MockExpand() { Die(); }
+  ~MockExpand() override { Die(); }
-  MOCK_METHOD0(Die, void());
+  MOCK_METHOD(void, Die, ());
-  MOCK_METHOD0(Reset, void());
+  MOCK_METHOD(void, Reset, (), (override));
-  MOCK_METHOD1(Process, int(AudioMultiVector* output));
+  MOCK_METHOD(int, Process, (AudioMultiVector * output), (override));
-  MOCK_METHOD0(SetParametersForNormalAfterExpand, void());
+  MOCK_METHOD(void, SetParametersForNormalAfterExpand, (), (override));
-  MOCK_METHOD0(SetParametersForMergeAfterExpand, void());
+  MOCK_METHOD(void, SetParametersForMergeAfterExpand, (), (override));
-  MOCK_CONST_METHOD0(overlap_length, size_t());
+  MOCK_METHOD(size_t, overlap_length, (), (const, override));
 };
 
 }  // namespace webrtc
@@ -45,13 +45,15 @@ namespace webrtc {
 
 class MockExpandFactory : public ExpandFactory {
  public:
-  MOCK_CONST_METHOD6(Create,
+  MOCK_METHOD(Expand*,
-                     Expand*(BackgroundNoise* background_noise,
+              Create,
+              (BackgroundNoise * background_noise,
                SyncBuffer* sync_buffer,
                RandomVector* random_vector,
                StatisticsCalculator* statistics,
                int fs,
-                             size_t num_channels));
+               size_t num_channels),
+              (const, override));
 };
 
 }  // namespace webrtc

modules/audio_coding/neteq/mock/mock_histogram.h

@@ -22,8 +22,8 @@ class MockHistogram : public Histogram {
       : Histogram(num_buckets, forget_factor) {}
   virtual ~MockHistogram() {}
 
-  MOCK_METHOD1(Add, void(int));
+  MOCK_METHOD(void, Add, (int), (override));
-  MOCK_METHOD1(Quantile, int(int));
+  MOCK_METHOD(int, Quantile, (int), (override));
 };
 
 }  // namespace webrtc

modules/audio_coding/neteq/mock/mock_neteq_controller.h

@@ -19,46 +19,45 @@ namespace webrtc {
 class MockNetEqController : public NetEqController {
  public:
   MockNetEqController() = default;
-  virtual ~MockNetEqController() { Die(); }
+  ~MockNetEqController() override { Die(); }
-  MOCK_METHOD0(Die, void());
+  MOCK_METHOD(void, Die, ());
-  MOCK_METHOD0(Reset, void());
+  MOCK_METHOD(void, Reset, (), (override));
-  MOCK_METHOD0(SoftReset, void());
+  MOCK_METHOD(void, SoftReset, (), (override));
-  MOCK_METHOD2(GetDecision,
+  MOCK_METHOD(NetEq::Operation,
-               NetEq::Operation(const NetEqStatus& neteq_status,
+              GetDecision,
-                                bool* reset_decoder));
+              (const NetEqStatus& neteq_status, bool* reset_decoder),
-  MOCK_METHOD6(Update,
+              (override));
-               void(uint16_t sequence_number,
+  MOCK_METHOD(void, RegisterEmptyPacket, (), (override));
-                    uint32_t timestamp,
+  MOCK_METHOD(void,
-                    uint32_t last_played_out_timestamp,
+              SetSampleRate,
-                    bool new_codec,
+              (int fs_hz, size_t output_size_samples),
-                    bool cng_or_dtmf,
+              (override));
-                    size_t packet_length_samples));
+  MOCK_METHOD(bool, SetMaximumDelay, (int delay_ms), (override));
-  MOCK_METHOD0(RegisterEmptyPacket, void());
+  MOCK_METHOD(bool, SetMinimumDelay, (int delay_ms), (override));
-  MOCK_METHOD2(SetSampleRate, void(int fs_hz, size_t output_size_samples));
+  MOCK_METHOD(bool, SetBaseMinimumDelay, (int delay_ms), (override));
-  MOCK_METHOD1(SetMaximumDelay, bool(int delay_ms));
+  MOCK_METHOD(int, GetBaseMinimumDelay, (), (const, override));
-  MOCK_METHOD1(SetMinimumDelay, bool(int delay_ms));
+  MOCK_METHOD(bool, CngRfc3389On, (), (const, override));
-  MOCK_METHOD1(SetBaseMinimumDelay, bool(int delay_ms));
+  MOCK_METHOD(bool, CngOff, (), (const, override));
-  MOCK_CONST_METHOD0(GetBaseMinimumDelay, int());
+  MOCK_METHOD(void, SetCngOff, (), (override));
-  MOCK_CONST_METHOD0(CngRfc3389On, bool());
+  MOCK_METHOD(void, ExpandDecision, (NetEq::Operation operation), (override));
-  MOCK_CONST_METHOD0(CngOff, bool());
+  MOCK_METHOD(void, AddSampleMemory, (int32_t value), (override));
-  MOCK_METHOD0(SetCngOff, void());
+  MOCK_METHOD(int, TargetLevelMs, (), (override));
-  MOCK_METHOD1(ExpandDecision, void(NetEq::Operation operation));
+  MOCK_METHOD(absl::optional<int>,
-  MOCK_METHOD1(AddSampleMemory, void(int32_t value));
+              PacketArrived,
-  MOCK_METHOD0(TargetLevelMs, int());
+              (bool last_cng_or_dtmf,
-  MOCK_METHOD6(PacketArrived,
-               absl::optional<int>(bool last_cng_or_dtmf,
                size_t packet_length_samples,
                bool should_update_stats,
                uint16_t main_sequence_number,
                uint32_t main_timestamp,
-                                   int fs_hz));
+               int fs_hz),
-  MOCK_CONST_METHOD0(PeakFound, bool());
+              (override));
-  MOCK_CONST_METHOD0(GetFilteredBufferLevel, int());
+  MOCK_METHOD(bool, PeakFound, (), (const, override));
-  MOCK_METHOD1(set_sample_memory, void(int32_t value));
+  MOCK_METHOD(int, GetFilteredBufferLevel, (), (const, override));
-  MOCK_CONST_METHOD0(noise_fast_forward, size_t());
+  MOCK_METHOD(void, set_sample_memory, (int32_t value), (override));
-  MOCK_CONST_METHOD0(packet_length_samples, size_t());
+  MOCK_METHOD(size_t, noise_fast_forward, (), (const, override));
-  MOCK_METHOD1(set_packet_length_samples, void(size_t value));
+  MOCK_METHOD(size_t, packet_length_samples, (), (const, override));
-  MOCK_METHOD1(set_prev_time_scale, void(bool value));
+  MOCK_METHOD(void, set_packet_length_samples, (size_t value), (override));
+  MOCK_METHOD(void, set_prev_time_scale, (bool value), (override));
 };
 
 }  // namespace webrtc

modules/audio_coding/neteq/mock/mock_packet_buffer.h

@@ -20,39 +20,47 @@ class MockPacketBuffer : public PacketBuffer {
  public:
   MockPacketBuffer(size_t max_number_of_packets, const TickTimer* tick_timer)
       : PacketBuffer(max_number_of_packets, tick_timer) {}
-  virtual ~MockPacketBuffer() { Die(); }
+  ~MockPacketBuffer() override { Die(); }
-  MOCK_METHOD0(Die, void());
+  MOCK_METHOD(void, Die, ());
-  MOCK_METHOD0(Flush, void());
+  MOCK_METHOD(void, Flush, (), (override));
-  MOCK_CONST_METHOD0(Empty, bool());
+  MOCK_METHOD(bool, Empty, (), (const, override));
-  int InsertPacket(Packet&& packet, StatisticsCalculator* stats) {
+  MOCK_METHOD(int,
-    return InsertPacketWrapped(&packet, stats);
+              InsertPacket,
-  }
+              (Packet && packet, StatisticsCalculator* stats),
-  // Since gtest does not properly support move-only types, InsertPacket is
+              (override));
-  // implemented as a wrapper. You'll have to implement InsertPacketWrapped
+  MOCK_METHOD(int,
-  // instead and move from |*packet|.
+              InsertPacketList,
-  MOCK_METHOD2(InsertPacketWrapped,
+              (PacketList * packet_list,
-               int(Packet* packet, StatisticsCalculator* stats));
-  MOCK_METHOD5(InsertPacketList,
-               int(PacketList* packet_list,
                const DecoderDatabase& decoder_database,
                absl::optional<uint8_t>* current_rtp_payload_type,
                absl::optional<uint8_t>* current_cng_rtp_payload_type,
-                   StatisticsCalculator* stats));
+               StatisticsCalculator* stats),
-  MOCK_CONST_METHOD1(NextTimestamp, int(uint32_t* next_timestamp));
+              (override));
-  MOCK_CONST_METHOD2(NextHigherTimestamp,
+  MOCK_METHOD(int,
-                     int(uint32_t timestamp, uint32_t* next_timestamp));
+              NextTimestamp,
-  MOCK_CONST_METHOD0(PeekNextPacket, const Packet*());
+              (uint32_t * next_timestamp),
-  MOCK_METHOD0(GetNextPacket, absl::optional<Packet>());
+              (const, override));
-  MOCK_METHOD1(DiscardNextPacket, int(StatisticsCalculator* stats));
+  MOCK_METHOD(int,
-  MOCK_METHOD3(DiscardOldPackets,
+              NextHigherTimestamp,
-               void(uint32_t timestamp_limit,
+              (uint32_t timestamp, uint32_t* next_timestamp),
+              (const, override));
+  MOCK_METHOD(const Packet*, PeekNextPacket, (), (const, override));
+  MOCK_METHOD(absl::optional<Packet>, GetNextPacket, (), (override));
+  MOCK_METHOD(int,
+              DiscardNextPacket,
+              (StatisticsCalculator * stats),
+              (override));
+  MOCK_METHOD(void,
+              DiscardOldPackets,
+              (uint32_t timestamp_limit,
                uint32_t horizon_samples,
-                    StatisticsCalculator* stats));
+               StatisticsCalculator* stats),
-  MOCK_METHOD2(DiscardAllOldPackets,
+              (override));
-               void(uint32_t timestamp_limit, StatisticsCalculator* stats));
+  MOCK_METHOD(void,
-  MOCK_CONST_METHOD0(NumPacketsInBuffer, size_t());
+              DiscardAllOldPackets,
-  MOCK_METHOD1(IncrementWaitingTimes, void(int));
+              (uint32_t timestamp_limit, StatisticsCalculator* stats),
-  MOCK_CONST_METHOD0(current_memory_bytes, int());
+              (override));
+  MOCK_METHOD(size_t, NumPacketsInBuffer, (), (const, override));
 };
 
 }  // namespace webrtc

modules/audio_coding/neteq/mock/mock_red_payload_splitter.h

@@ -18,10 +18,12 @@ namespace webrtc {
 
 class MockRedPayloadSplitter : public RedPayloadSplitter {
  public:
-  MOCK_METHOD1(SplitRed, bool(PacketList* packet_list));
+  MOCK_METHOD(bool, SplitRed, (PacketList * packet_list), (override));
-  MOCK_METHOD2(CheckRedPayloads,
+  MOCK_METHOD(void,
-               void(PacketList* packet_list,
+              CheckRedPayloads,
-                    const DecoderDatabase& decoder_database));
+              (PacketList * packet_list,
+               const DecoderDatabase& decoder_database),
+              (override));
 };
 
 }  // namespace webrtc

modules/audio_coding/neteq/mock/mock_statistics_calculator.h

@@ -18,9 +18,12 @@ namespace webrtc {
 
 class MockStatisticsCalculator : public StatisticsCalculator {
  public:
-  MOCK_METHOD1(PacketsDiscarded, void(size_t num_packets));
+  MOCK_METHOD(void, PacketsDiscarded, (size_t num_packets), (override));
-  MOCK_METHOD1(SecondaryPacketsDiscarded, void(size_t num_packets));
+  MOCK_METHOD(void,
-  MOCK_METHOD1(RelativePacketArrivalDelay, void(size_t delay_ms));
+              SecondaryPacketsDiscarded,
+              (size_t num_packets),
+              (override));
+  MOCK_METHOD(void, RelativePacketArrivalDelay, (size_t delay_ms), (override));
 };
 
 }  // namespace webrtc

modules/audio_coding/neteq/neteq_network_stats_unittest.cc

@@ -52,10 +52,10 @@ class MockAudioDecoder final : public AudioDecoder {
       : sample_rate_hz_(sample_rate_hz),
         num_channels_(num_channels),
         fec_enabled_(false) {}
-  ~MockAudioDecoder() /* override */ { Die(); }
+  ~MockAudioDecoder() override { Die(); }
-  MOCK_METHOD0(Die, void());
+  MOCK_METHOD(void, Die, ());
 
-  MOCK_METHOD0(Reset, void());
+  MOCK_METHOD(void, Reset, (), (override));
 
   class MockFrame : public AudioDecoder::EncodedAudioFrame {
    public:

modules/audio_coding/neteq/packet_buffer_unittest.cc

@@ -31,13 +31,14 @@ using ::testing::StrictMock;
 namespace {
 class MockEncodedAudioFrame : public webrtc::AudioDecoder::EncodedAudioFrame {
  public:
-  MOCK_CONST_METHOD0(Duration, size_t());
+  MOCK_METHOD(size_t, Duration, (), (const, override));
 
-  MOCK_CONST_METHOD0(IsDtxPacket, bool());
+  MOCK_METHOD(bool, IsDtxPacket, (), (const, override));
 
-  MOCK_CONST_METHOD1(
+  MOCK_METHOD(absl::optional<DecodeResult>,
               Decode,
-      absl::optional<DecodeResult>(rtc::ArrayView<int16_t> decoded));
+              (rtc::ArrayView<int16_t> decoded),
+              (const, override));
 };
 
 // Helper class to generate packets. Packets must be deleted by the user.

modules/audio_mixer/audio_mixer_impl_unittest.cc

@@ -74,11 +74,13 @@ class MockMixerAudioSource : public ::testing::NiceMock<AudioMixer::Source> {
         .WillByDefault(Return(kDefaultSampleRateHz));
   }
 
-  MOCK_METHOD2(GetAudioFrameWithInfo,
+  MOCK_METHOD(AudioFrameInfo,
-               AudioFrameInfo(int sample_rate_hz, AudioFrame* audio_frame));
+              GetAudioFrameWithInfo,
+              (int sample_rate_hz, AudioFrame* audio_frame),
+              (override));
 
-  MOCK_CONST_METHOD0(PreferredSampleRate, int());
+  MOCK_METHOD(int, PreferredSampleRate, (), (const, override));
-  MOCK_CONST_METHOD0(Ssrc, int());
+  MOCK_METHOD(int, Ssrc, (), (const, override));
 
   AudioFrame* fake_frame() { return &fake_frame_; }
   AudioFrameInfo fake_info() { return fake_audio_frame_info_; }

modules/audio_processing/aec3/mock/mock_block_processor.h

@@ -24,17 +24,26 @@ class MockBlockProcessor : public BlockProcessor {
   MockBlockProcessor();
   virtual ~MockBlockProcessor();
 
-  MOCK_METHOD4(
+  MOCK_METHOD(void,
               ProcessCapture,
-      void(bool level_change,
+              (bool level_change,
                bool saturated_microphone_signal,
                std::vector<std::vector<std::vector<float>>>* linear_output,
-           std::vector<std::vector<std::vector<float>>>* capture_block));
+               std::vector<std::vector<std::vector<float>>>* capture_block),
-  MOCK_METHOD1(BufferRender,
+              (override));
-               void(const std::vector<std::vector<std::vector<float>>>& block));
+  MOCK_METHOD(void,
-  MOCK_METHOD1(UpdateEchoLeakageStatus, void(bool leakage_detected));
+              BufferRender,
-  MOCK_CONST_METHOD1(GetMetrics, void(EchoControl::Metrics* metrics));
+              (const std::vector<std::vector<std::vector<float>>>& block),
-  MOCK_METHOD1(SetAudioBufferDelay, void(int delay_ms));
+              (override));
+  MOCK_METHOD(void,
+              UpdateEchoLeakageStatus,
+              (bool leakage_detected),
+              (override));
+  MOCK_METHOD(void,
+              GetMetrics,
+              (EchoControl::Metrics * metrics),
+              (const, override));
+  MOCK_METHOD(void, SetAudioBufferDelay, (int delay_ms), (override));
 };
 
 }  // namespace test

modules/audio_processing/aec3/mock/mock_echo_remover.h

@@ -27,16 +27,23 @@ class MockEchoRemover : public EchoRemover {
   MockEchoRemover();
   virtual ~MockEchoRemover();
 
-  MOCK_METHOD6(ProcessCapture,
+  MOCK_METHOD(void,
-               void(EchoPathVariability echo_path_variability,
+              ProcessCapture,
+              (EchoPathVariability echo_path_variability,
                bool capture_signal_saturation,
                const absl::optional<DelayEstimate>& delay_estimate,
                RenderBuffer* render_buffer,
                std::vector<std::vector<std::vector<float>>>* linear_output,
-                    std::vector<std::vector<std::vector<float>>>* capture));
+               std::vector<std::vector<std::vector<float>>>* capture),
-  MOCK_CONST_METHOD0(Delay, absl::optional<int>());
+              (override));
-  MOCK_METHOD1(UpdateEchoLeakageStatus, void(bool leakage_detected));
+  MOCK_METHOD(void,
-  MOCK_CONST_METHOD1(GetMetrics, void(EchoControl::Metrics* metrics));
+              UpdateEchoLeakageStatus,
+              (bool leakage_detected),
+              (override));
+  MOCK_METHOD(void,
+              GetMetrics,
+              (EchoControl::Metrics * metrics),
+              (const, override));
 };
 
 }  // namespace test

modules/audio_processing/aec3/mock/mock_render_delay_buffer.h

@@ -27,21 +27,26 @@ class MockRenderDelayBuffer : public RenderDelayBuffer {
   MockRenderDelayBuffer(int sample_rate_hz, size_t num_channels);
   virtual ~MockRenderDelayBuffer();
 
-  MOCK_METHOD0(Reset, void());
+  MOCK_METHOD(void, Reset, (), (override));
-  MOCK_METHOD1(Insert,
+  MOCK_METHOD(RenderDelayBuffer::BufferingEvent,
-               RenderDelayBuffer::BufferingEvent(
+              Insert,
-                   const std::vector<std::vector<std::vector<float>>>& block));
+              (const std::vector<std::vector<std::vector<float>>>& block),
-  MOCK_METHOD0(PrepareCaptureProcessing, RenderDelayBuffer::BufferingEvent());
+              (override));
-  MOCK_METHOD1(AlignFromDelay, bool(size_t delay));
+  MOCK_METHOD(RenderDelayBuffer::BufferingEvent,
-  MOCK_METHOD0(AlignFromExternalDelay, void());
+              PrepareCaptureProcessing,
-  MOCK_CONST_METHOD0(Delay, size_t());
+              (),
-  MOCK_CONST_METHOD0(MaxDelay, size_t());
+              (override));
-  MOCK_METHOD0(GetRenderBuffer, RenderBuffer*());
+  MOCK_METHOD(bool, AlignFromDelay, (size_t delay), (override));
-  MOCK_CONST_METHOD0(GetDownsampledRenderBuffer,
+  MOCK_METHOD(void, AlignFromExternalDelay, (), (override));
-                     const DownsampledRenderBuffer&());
+  MOCK_METHOD(size_t, Delay, (), (const, override));
-  MOCK_CONST_METHOD1(CausalDelay, bool(size_t delay));
+  MOCK_METHOD(size_t, MaxDelay, (), (const, override));
-  MOCK_METHOD1(SetAudioBufferDelay, void(int delay_ms));
+  MOCK_METHOD(RenderBuffer*, GetRenderBuffer, (), (override));
-  MOCK_METHOD0(HasReceivedBufferDelay, bool());
+  MOCK_METHOD(const DownsampledRenderBuffer&,
+              GetDownsampledRenderBuffer,
+              (),
+              (const, override));
+  MOCK_METHOD(void, SetAudioBufferDelay, (int delay_ms), (override));
+  MOCK_METHOD(bool, HasReceivedBufferDelay, (), (override));
 
  private:
   RenderBuffer* FakeGetRenderBuffer() { return &render_buffer_; }

modules/audio_processing/aec3/mock/mock_render_delay_controller.h

@@ -25,14 +25,15 @@ class MockRenderDelayController : public RenderDelayController {
   MockRenderDelayController();
   virtual ~MockRenderDelayController();
 
-  MOCK_METHOD1(Reset, void(bool reset_delay_statistics));
+  MOCK_METHOD(void, Reset, (bool reset_delay_statistics), (override));
-  MOCK_METHOD0(LogRenderCall, void());
+  MOCK_METHOD(void, LogRenderCall, (), (override));
-  MOCK_METHOD3(GetDelay,
+  MOCK_METHOD(absl::optional<DelayEstimate>,
-               absl::optional<DelayEstimate>(
+              GetDelay,
-                   const DownsampledRenderBuffer& render_buffer,
+              (const DownsampledRenderBuffer& render_buffer,
                size_t render_delay_buffer_delay,
-                   const std::vector<std::vector<float>>& capture));
+               const std::vector<std::vector<float>>& capture),
-  MOCK_CONST_METHOD0(HasClockdrift, bool());
+              (override));
+  MOCK_METHOD(bool, HasClockdrift, (), (const, override));
 };
 
 }  // namespace test

modules/audio_processing/aec_dump/mock_aec_dump.h

@@ -25,36 +25,54 @@ class MockAecDump : public AecDump {
   MockAecDump();
   virtual ~MockAecDump();
 
-  MOCK_METHOD2(WriteInitMessage,
+  MOCK_METHOD(void,
-               void(const ProcessingConfig& api_format, int64_t time_now_ms));
+              WriteInitMessage,
+              (const ProcessingConfig& api_format, int64_t time_now_ms),
+              (override));
 
-  MOCK_METHOD1(AddCaptureStreamInput,
+  MOCK_METHOD(void,
-               void(const AudioFrameView<const float>& src));
+              AddCaptureStreamInput,
-  MOCK_METHOD1(AddCaptureStreamOutput,
+              (const AudioFrameView<const float>& src),
-               void(const AudioFrameView<const float>& src));
+              (override));
-  MOCK_METHOD3(AddCaptureStreamInput,
+  MOCK_METHOD(void,
-               void(const int16_t* const data,
+              AddCaptureStreamOutput,
+              (const AudioFrameView<const float>& src),
+              (override));
+  MOCK_METHOD(void,
+              AddCaptureStreamInput,
+              (const int16_t* const data,
                int num_channels,
-                    int samples_per_channel));
+               int samples_per_channel),
-  MOCK_METHOD3(AddCaptureStreamOutput,
+              (override));
-               void(const int16_t* const data,
+  MOCK_METHOD(void,
+              AddCaptureStreamOutput,
+              (const int16_t* const data,
                int num_channels,
-                    int samples_per_channel));
+               int samples_per_channel),
-  MOCK_METHOD1(AddAudioProcessingState,
+              (override));
-               void(const AudioProcessingState& state));
+  MOCK_METHOD(void,
-  MOCK_METHOD0(WriteCaptureStreamMessage, void());
+              AddAudioProcessingState,
+              (const AudioProcessingState& state),
+              (override));
+  MOCK_METHOD(void, WriteCaptureStreamMessage, (), (override));
 
-  MOCK_METHOD3(WriteRenderStreamMessage,
+  MOCK_METHOD(void,
-               void(const int16_t* const data,
+              WriteRenderStreamMessage,
+              (const int16_t* const data,
                int num_channels,
-                    int samples_per_channel));
+               int samples_per_channel),
-  MOCK_METHOD1(WriteRenderStreamMessage,
+              (override));
-               void(const AudioFrameView<const float>& src));
+  MOCK_METHOD(void,
+              WriteRenderStreamMessage,
+              (const AudioFrameView<const float>& src),
+              (override));
 
-  MOCK_METHOD1(WriteConfig, void(const InternalAPMConfig& config));
+  MOCK_METHOD(void, WriteConfig, (const InternalAPMConfig& config), (override));
 
-  MOCK_METHOD1(WriteRuntimeSetting,
+  MOCK_METHOD(void,
-               void(const AudioProcessing::RuntimeSetting& config));
+              WriteRuntimeSetting,
+              (const AudioProcessing::RuntimeSetting& config),
+              (override));
 };
 
 }  // namespace test

modules/audio_processing/agc/agc_manager_direct_unittest.cc

@@ -37,22 +37,23 @@ const int kMinMicLevel = 12;
 class MockGainControl : public GainControl {
  public:
   virtual ~MockGainControl() {}
-  MOCK_METHOD0(Initialize, void());
+  MOCK_METHOD(int, set_stream_analog_level, (int level), (override));
-  MOCK_CONST_METHOD0(is_enabled, bool());
+  MOCK_METHOD(int, stream_analog_level, (), (const, override));
-  MOCK_METHOD1(set_stream_analog_level, int(int level));
+  MOCK_METHOD(int, set_mode, (Mode mode), (override));
-  MOCK_CONST_METHOD0(stream_analog_level, int());
+  MOCK_METHOD(Mode, mode, (), (const, override));
-  MOCK_METHOD1(set_mode, int(Mode mode));
+  MOCK_METHOD(int, set_target_level_dbfs, (int level), (override));
-  MOCK_CONST_METHOD0(mode, Mode());
+  MOCK_METHOD(int, target_level_dbfs, (), (const, override));
-  MOCK_METHOD1(set_target_level_dbfs, int(int level));
+  MOCK_METHOD(int, set_compression_gain_db, (int gain), (override));
-  MOCK_CONST_METHOD0(target_level_dbfs, int());
+  MOCK_METHOD(int, compression_gain_db, (), (const, override));
-  MOCK_METHOD1(set_compression_gain_db, int(int gain));
+  MOCK_METHOD(int, enable_limiter, (bool enable), (override));
-  MOCK_CONST_METHOD0(compression_gain_db, int());
+  MOCK_METHOD(bool, is_limiter_enabled, (), (const, override));
-  MOCK_METHOD1(enable_limiter, int(bool enable));
+  MOCK_METHOD(int,
-  MOCK_CONST_METHOD0(is_limiter_enabled, bool());
+              set_analog_level_limits,
-  MOCK_METHOD2(set_analog_level_limits, int(int minimum, int maximum));
+              (int minimum, int maximum),
-  MOCK_CONST_METHOD0(analog_level_minimum, int());
+              (override));
-  MOCK_CONST_METHOD0(analog_level_maximum, int());
+  MOCK_METHOD(int, analog_level_minimum, (), (const, override));
-  MOCK_CONST_METHOD0(stream_is_saturated, bool());
+  MOCK_METHOD(int, analog_level_maximum, (), (const, override));
+  MOCK_METHOD(bool, stream_is_saturated, (), (const, override));
 };
 
 }  // namespace

modules/audio_processing/agc/mock_agc.h

@@ -19,14 +19,14 @@ namespace webrtc {
 class MockAgc : public Agc {
  public:
   virtual ~MockAgc() {}
-  MOCK_METHOD3(Process,
+  MOCK_METHOD(void,
-               void(const int16_t* audio, size_t length, int sample_rate_hz));
+              Process,
-  MOCK_METHOD1(GetRmsErrorDb, bool(int* error));
+              (const int16_t* audio, size_t length, int sample_rate_hz),
-  MOCK_METHOD0(Reset, void());
+              (override));
-  MOCK_METHOD1(set_target_level_dbfs, int(int level));
+  MOCK_METHOD(bool, GetRmsErrorDb, (int* error), (override));
-  MOCK_CONST_METHOD0(target_level_dbfs, int());
+  MOCK_METHOD(void, Reset, (), (override));
-  MOCK_METHOD1(EnableStandaloneVad, void(bool enable));
+  MOCK_METHOD(int, set_target_level_dbfs, (int level), (override));
-  MOCK_CONST_METHOD0(standalone_vad_enabled, bool());
+  MOCK_METHOD(int, target_level_dbfs, (), (const, override));
 };
 
 }  // namespace webrtc

modules/audio_processing/audio_processing_impl_unittest.cc

@@ -37,13 +37,13 @@ class MockInitialize : public AudioProcessingImpl {
   explicit MockInitialize(const webrtc::Config& config)
       : AudioProcessingImpl(config) {}
 
-  MOCK_METHOD0(InitializeLocked, int());
+  MOCK_METHOD(int, InitializeLocked, (), (override));
   int RealInitializeLocked() RTC_NO_THREAD_SAFETY_ANALYSIS {
     return AudioProcessingImpl::InitializeLocked();
   }
 
-  MOCK_CONST_METHOD0(AddRef, void());
+  MOCK_METHOD(void, AddRef, (), (const, override));
-  MOCK_CONST_METHOD0(Release, rtc::RefCountReleaseStatus());
+  MOCK_METHOD(rtc::RefCountReleaseStatus, Release, (), (const, override));
 };
 
 // Creates MockEchoControl instances and provides a raw pointer access to

modules/audio_processing/include/mock_audio_processing.h

@@ -24,35 +24,47 @@ namespace test {
 class MockCustomProcessing : public CustomProcessing {
  public:
   virtual ~MockCustomProcessing() {}
-  MOCK_METHOD2(Initialize, void(int sample_rate_hz, int num_channels));
+  MOCK_METHOD(void,
-  MOCK_METHOD1(Process, void(AudioBuffer* audio));
+              Initialize,
-  MOCK_METHOD1(SetRuntimeSetting,
+              (int sample_rate_hz, int num_channels),
-               void(AudioProcessing::RuntimeSetting setting));
+              (override));
-  MOCK_CONST_METHOD0(ToString, std::string());
+  MOCK_METHOD(void, Process, (AudioBuffer * audio), (override));
+  MOCK_METHOD(void,
+              SetRuntimeSetting,
+              (AudioProcessing::RuntimeSetting setting),
+              (override));
+  MOCK_METHOD(std::string, ToString, (), (const, override));
 };
 
 class MockCustomAudioAnalyzer : public CustomAudioAnalyzer {
  public:
   virtual ~MockCustomAudioAnalyzer() {}
-  MOCK_METHOD2(Initialize, void(int sample_rate_hz, int num_channels));
+  MOCK_METHOD(void,
-  MOCK_METHOD1(Analyze, void(const AudioBuffer* audio));
+              Initialize,
-  MOCK_CONST_METHOD0(ToString, std::string());
+              (int sample_rate_hz, int num_channels),
+              (override));
+  MOCK_METHOD(void, Analyze, (const AudioBuffer* audio), (override));
+  MOCK_METHOD(std::string, ToString, (), (const, override));
 };
 
 class MockEchoControl : public EchoControl {
  public:
   virtual ~MockEchoControl() {}
-  MOCK_METHOD1(AnalyzeRender, void(AudioBuffer* render));
+  MOCK_METHOD(void, AnalyzeRender, (AudioBuffer * render), (override));
-  MOCK_METHOD1(AnalyzeCapture, void(AudioBuffer* capture));
+  MOCK_METHOD(void, AnalyzeCapture, (AudioBuffer * capture), (override));
-  MOCK_METHOD2(ProcessCapture,
+  MOCK_METHOD(void,
-               void(AudioBuffer* capture, bool echo_path_change));
+              ProcessCapture,
-  MOCK_METHOD3(ProcessCapture,
+              (AudioBuffer * capture, bool echo_path_change),
-               void(AudioBuffer* capture,
+              (override));
+  MOCK_METHOD(void,
+              ProcessCapture,
+              (AudioBuffer * capture,
                AudioBuffer* linear_output,
-                    bool echo_path_change));
+               bool echo_path_change),
-  MOCK_CONST_METHOD0(GetMetrics, Metrics());
+              (override));
-  MOCK_METHOD1(SetAudioBufferDelay, void(int delay_ms));
+  MOCK_METHOD(Metrics, GetMetrics, (), (const, override));
-  MOCK_CONST_METHOD0(ActiveProcessing, bool());
+  MOCK_METHOD(void, SetAudioBufferDelay, (int delay_ms), (override));
+  MOCK_METHOD(bool, ActiveProcessing, (), (const, override));
 };
 
 class MockAudioProcessing : public ::testing::NiceMock<AudioProcessing> {
@@ -61,87 +73,93 @@ class MockAudioProcessing : public ::testing::NiceMock<AudioProcessing> {
 
   virtual ~MockAudioProcessing() {}
 
-  MOCK_METHOD0(Initialize, int());
+  MOCK_METHOD(int, Initialize, (), (override));
-  MOCK_METHOD6(Initialize,
+  MOCK_METHOD(int,
-               int(int capture_input_sample_rate_hz,
+              Initialize,
+              (int capture_input_sample_rate_hz,
                int capture_output_sample_rate_hz,
                int render_sample_rate_hz,
                ChannelLayout capture_input_layout,
                ChannelLayout capture_output_layout,
-                   ChannelLayout render_input_layout));
+               ChannelLayout render_input_layout),
-  MOCK_METHOD1(Initialize, int(const ProcessingConfig& processing_config));
+              (override));
-  MOCK_METHOD1(ApplyConfig, void(const Config& config));
+  MOCK_METHOD(int,
-  MOCK_METHOD1(SetExtraOptions, void(const webrtc::Config& config));
+              Initialize,
-  MOCK_CONST_METHOD0(proc_sample_rate_hz, int());
+              (const ProcessingConfig& processing_config),
-  MOCK_CONST_METHOD0(proc_split_sample_rate_hz, int());
+              (override));
-  MOCK_CONST_METHOD0(num_input_channels, size_t());
+  MOCK_METHOD(void, ApplyConfig, (const Config& config), (override));
-  MOCK_CONST_METHOD0(num_proc_channels, size_t());
+  MOCK_METHOD(void,
-  MOCK_CONST_METHOD0(num_output_channels, size_t());
+              SetExtraOptions,
-  MOCK_CONST_METHOD0(num_reverse_channels, size_t());
+              (const webrtc::Config& config),
-  MOCK_METHOD1(set_output_will_be_muted, void(bool muted));
+              (override));
-  MOCK_METHOD1(SetRuntimeSetting, void(RuntimeSetting setting));
+  MOCK_METHOD(int, proc_sample_rate_hz, (), (const, override));
-  MOCK_METHOD4(ProcessStream,
+  MOCK_METHOD(int, proc_split_sample_rate_hz, (), (const, override));
-               int(const int16_t* const src,
+  MOCK_METHOD(size_t, num_input_channels, (), (const, override));
+  MOCK_METHOD(size_t, num_proc_channels, (), (const, override));
+  MOCK_METHOD(size_t, num_output_channels, (), (const, override));
+  MOCK_METHOD(size_t, num_reverse_channels, (), (const, override));
+  MOCK_METHOD(void, set_output_will_be_muted, (bool muted), (override));
+  MOCK_METHOD(void, SetRuntimeSetting, (RuntimeSetting setting), (override));
+  MOCK_METHOD(int,
+              ProcessStream,
+              (const int16_t* const src,
                const StreamConfig& input_config,
                const StreamConfig& output_config,
-                   int16_t* const dest));
+               int16_t* const dest),
-  MOCK_METHOD7(ProcessStream,
+              (override));
-               int(const float* const* src,
+  MOCK_METHOD(int,
-                   size_t samples_per_channel,
+              ProcessStream,
-                   int input_sample_rate_hz,
+              (const float* const* src,
-                   ChannelLayout input_layout,
-                   int output_sample_rate_hz,
-                   ChannelLayout output_layout,
-                   float* const* dest));
-  MOCK_METHOD4(ProcessStream,
-               int(const float* const* src,
                const StreamConfig& input_config,
                const StreamConfig& output_config,
-                   float* const* dest));
+               float* const* dest),
-  MOCK_METHOD4(ProcessReverseStream,
+              (override));
-               int(const int16_t* const src,
+  MOCK_METHOD(int,
+              ProcessReverseStream,
+              (const int16_t* const src,
                const StreamConfig& input_config,
                const StreamConfig& output_config,
-                   int16_t* const dest));
+               int16_t* const dest),
-  MOCK_METHOD4(AnalyzeReverseStream,
+              (override));
-               int(const float* const* data,
+  MOCK_METHOD(int,
-                   size_t samples_per_channel,
+              AnalyzeReverseStream,
-                   int sample_rate_hz,
+              (const float* const* data, const StreamConfig& reverse_config),
-                   ChannelLayout layout));
+              (override));
-  MOCK_METHOD2(AnalyzeReverseStream,
+  MOCK_METHOD(int,
-               int(const float* const* data,
+              ProcessReverseStream,
-                   const StreamConfig& reverse_config));
+              (const float* const* src,
-  MOCK_METHOD4(ProcessReverseStream,
-               int(const float* const* src,
                const StreamConfig& input_config,
                const StreamConfig& output_config,
-                   float* const* dest));
+               float* const* dest),
-  MOCK_CONST_METHOD1(
+              (override));
+  MOCK_METHOD(bool,
               GetLinearAecOutput,
-      bool(rtc::ArrayView<std::array<float, 160>> linear_output));
+              ((rtc::ArrayView<std::array<float, 160>> linear_output)),
-  MOCK_METHOD1(set_stream_delay_ms, int(int delay));
+              (const, override));
-  MOCK_CONST_METHOD0(stream_delay_ms, int());
+  MOCK_METHOD(int, set_stream_delay_ms, (int delay), (override));
-  MOCK_CONST_METHOD0(was_stream_delay_set, bool());
+  MOCK_METHOD(int, stream_delay_ms, (), (const, override));
-  MOCK_METHOD1(set_stream_key_pressed, void(bool key_pressed));
+  MOCK_METHOD(void, set_stream_key_pressed, (bool key_pressed), (override));
-  MOCK_METHOD1(set_delay_offset_ms, void(int offset));
+  MOCK_METHOD(void, set_stream_analog_level, (int), (override));
-  MOCK_CONST_METHOD0(delay_offset_ms, int());
+  MOCK_METHOD(int, recommended_stream_analog_level, (), (const, override));
-  MOCK_METHOD1(set_stream_analog_level, void(int));
+  MOCK_METHOD(bool,
-  MOCK_CONST_METHOD0(recommended_stream_analog_level, int());
+              CreateAndAttachAecDump,
-  MOCK_METHOD3(CreateAndAttachAecDump,
+              (const std::string& file_name,
-               bool(const std::string& file_name,
                int64_t max_log_size_bytes,
-                    rtc::TaskQueue* worker_queue));
+               rtc::TaskQueue* worker_queue),
-  MOCK_METHOD3(CreateAndAttachAecDump,
+              (override));
-               bool(FILE* handle,
+  MOCK_METHOD(bool,
+              CreateAndAttachAecDump,
+              (FILE * handle,
                int64_t max_log_size_bytes,
-                    rtc::TaskQueue* worker_queue));
+               rtc::TaskQueue* worker_queue),
-  MOCK_METHOD1(AttachAecDump, void(std::unique_ptr<AecDump>));
+              (override));
-  MOCK_METHOD0(DetachAecDump, void());
+  MOCK_METHOD(void, AttachAecDump, (std::unique_ptr<AecDump>), (override));
+  MOCK_METHOD(void, DetachAecDump, (), (override));
 
-  MOCK_METHOD0(GetStatistics, AudioProcessingStats());
+  MOCK_METHOD(AudioProcessingStats, GetStatistics, (), (override));
-  MOCK_METHOD1(GetStatistics, AudioProcessingStats(bool));
+  MOCK_METHOD(AudioProcessingStats, GetStatistics, (bool), (override));
 
-  MOCK_CONST_METHOD0(GetConfig, AudioProcessing::Config());
+  MOCK_METHOD(AudioProcessing::Config, GetConfig, (), (const, override));
 };
 
 }  // namespace test

modules/audio_processing/test/conversational_speech/mock_wavreader.h

@@ -28,12 +28,12 @@ class MockWavReader : public WavReaderInterface {
   ~MockWavReader();
 
   // TODO(alessiob): use ON_CALL to return random samples if needed.
-  MOCK_METHOD1(ReadFloatSamples, size_t(rtc::ArrayView<float>));
+  MOCK_METHOD(size_t, ReadFloatSamples, (rtc::ArrayView<float>), (override));
-  MOCK_METHOD1(ReadInt16Samples, size_t(rtc::ArrayView<int16_t>));
+  MOCK_METHOD(size_t, ReadInt16Samples, (rtc::ArrayView<int16_t>), (override));
 
-  MOCK_CONST_METHOD0(SampleRate, int());
+  MOCK_METHOD(int, SampleRate, (), (const, override));
-  MOCK_CONST_METHOD0(NumChannels, size_t());
+  MOCK_METHOD(size_t, NumChannels, (), (const, override));
-  MOCK_CONST_METHOD0(NumSamples, size_t());
+  MOCK_METHOD(size_t, NumSamples, (), (const, override));
 
  private:
   const int sample_rate_;

modules/audio_processing/test/conversational_speech/mock_wavreader_factory.h

@@ -36,8 +36,10 @@ class MockWavReaderFactory : public WavReaderAbstractFactory {
   explicit MockWavReaderFactory(const Params& default_params);
   ~MockWavReaderFactory();
 
-  MOCK_CONST_METHOD1(Create,
+  MOCK_METHOD(std::unique_ptr<WavReaderInterface>,
-                     std::unique_ptr<WavReaderInterface>(const std::string&));
+              Create,
+              (const std::string&),
+              (const, override));
 
  private:
   // Creates a MockWavReader instance using the parameters in

modules/audio_processing/test/echo_control_mock.h

@@ -20,17 +20,21 @@ class AudioBuffer;
 
 class MockEchoControl : public EchoControl {
  public:
-  MOCK_METHOD1(AnalyzeRender, void(AudioBuffer* render));
+  MOCK_METHOD(void, AnalyzeRender, (AudioBuffer * render), (override));
-  MOCK_METHOD1(AnalyzeCapture, void(AudioBuffer* capture));
+  MOCK_METHOD(void, AnalyzeCapture, (AudioBuffer * capture), (override));
-  MOCK_METHOD2(ProcessCapture,
+  MOCK_METHOD(void,
-               void(AudioBuffer* capture, bool echo_path_change));
+              ProcessCapture,
-  MOCK_METHOD3(ProcessCapture,
+              (AudioBuffer * capture, bool echo_path_change),
-               void(AudioBuffer* capture,
+              (override));
+  MOCK_METHOD(void,
+              ProcessCapture,
+              (AudioBuffer * capture,
                AudioBuffer* linear_output,
-                    bool echo_path_change));
+               bool echo_path_change),
-  MOCK_CONST_METHOD0(GetMetrics, EchoControl::Metrics());
+              (override));
-  MOCK_METHOD1(SetAudioBufferDelay, void(int delay_ms));
+  MOCK_METHOD(EchoControl::Metrics, GetMetrics, (), (const, override));
-  MOCK_CONST_METHOD0(ActiveProcessing, bool());
+  MOCK_METHOD(void, SetAudioBufferDelay, (int delay_ms), (override));
+  MOCK_METHOD(bool, ActiveProcessing, (), (const, override));
 };
 
 }  // namespace webrtc