diff --git a/call/adaptation/resource_unittest.cc b/call/adaptation/resource_unittest.cc
index 8f3ae32dca..9436a02a64 100644
--- a/call/adaptation/resource_unittest.cc
+++ b/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 {
diff --git a/call/adaptation/test/fake_frame_rate_provider.h b/call/adaptation/test/fake_frame_rate_provider.h
index a08e162321..3638f478f3 100644
--- a/call/adaptation/test/fake_frame_rate_provider.h
+++ b/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_METHOD2(OnIncomingFrame, void(int, int));
-  MOCK_METHOD2(OnSendEncodedImage,
-               void(const EncodedImage&, const CodecSpecificInfo*));
-  MOCK_METHOD1(OnEncoderImplementationChanged, void(const std::string&));
-  MOCK_METHOD1(OnFrameDropped, void(DropReason));
-  MOCK_METHOD2(OnEncoderReconfigured,
-               void(const VideoEncoderConfig&,
-                    const std::vector<VideoStream>&));
-  MOCK_METHOD3(OnAdaptationChanged,
-               void(VideoAdaptationReason,
-                    const VideoAdaptationCounters&,
-                    const VideoAdaptationCounters&));
-  MOCK_METHOD0(ClearAdaptationStats, void());
-  MOCK_METHOD2(UpdateAdaptationSettings,
-               void(AdaptationSettings, AdaptationSettings));
-  MOCK_METHOD0(OnMinPixelLimitReached, void());
-  MOCK_METHOD0(OnInitialQualityResolutionAdaptDown, void());
-  MOCK_METHOD1(OnSuspendChange, void(bool));
-  MOCK_METHOD2(OnBitrateAllocationUpdated,
-               void(const VideoCodec&, const VideoBitrateAllocation&));
-  MOCK_METHOD1(OnEncoderInternalScalerUpdate, void(bool));
-  MOCK_CONST_METHOD0(GetInputFrameRate, int());
+  MOCK_METHOD(void, OnEncodedFrameTimeMeasured, (int, int), (override));
+  MOCK_METHOD(void, OnIncomingFrame, (int, int), (override));
+  MOCK_METHOD(void,
+              OnSendEncodedImage,
+              (const EncodedImage&, const CodecSpecificInfo*),
+              (override));
+  MOCK_METHOD(void,
+              OnEncoderImplementationChanged,
+              (const std::string&),
+              (override));
+  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&),
+              (override));
+  MOCK_METHOD(void, ClearAdaptationStats, (), (override));
+  MOCK_METHOD(void,
+              UpdateAdaptationSettings,
+              (AdaptationSettings, AdaptationSettings),
+              (override));
+  MOCK_METHOD(void, OnMinPixelLimitReached, (), (override));
+  MOCK_METHOD(void, OnInitialQualityResolutionAdaptDown, (), (override));
+  MOCK_METHOD(void, OnSuspendChange, (bool), (override));
+  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 {
diff --git a/call/bitrate_allocator_unittest.cc b/call/bitrate_allocator_unittest.cc
index 1479a4714a..00fb236948 100644
--- a/call/bitrate_allocator_unittest.cc
+++ b/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 {
diff --git a/call/fake_network_pipe_unittest.cc b/call/fake_network_pipe_unittest.cc
index 9c4a3bf755..852a427222 100644
--- a/call/fake_network_pipe_unittest.cc
+++ b/call/fake_network_pipe_unittest.cc
@@ -24,8 +24,10 @@ namespace webrtc {
 
 class MockReceiver : public PacketReceiver {
  public:
-  MOCK_METHOD3(DeliverPacket,
-               DeliveryStatus(MediaType, rtc::CopyOnWriteBuffer, int64_t));
+  MOCK_METHOD(DeliveryStatus,
+              DeliverPacket,
+              (MediaType, rtc::CopyOnWriteBuffer, int64_t),
+              (override));
   virtual ~MockReceiver() = default;
 };
 
diff --git a/call/rtcp_demuxer_unittest.cc b/call/rtcp_demuxer_unittest.cc
index 23c305c900..5b27c7a998 100644
--- a/call/rtcp_demuxer_unittest.cc
+++ b/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 {
diff --git a/call/rtp_demuxer_unittest.cc b/call/rtp_demuxer_unittest.cc
index 86b458a0cc..7177c0efd4 100644
--- a/call/rtp_demuxer_unittest.cc
+++ b/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_METHOD2(OnSsrcBoundToMid, void(const std::string& mid, uint32_t ssrc));
-  MOCK_METHOD3(OnSsrcBoundToMidRsid,
-               void(const std::string& mid,
-                    const std::string& rsid,
-                    uint32_t ssrc));
-  MOCK_METHOD2(OnSsrcBoundToPayloadType,
-               void(uint8_t payload_type, uint32_t ssrc));
+  MOCK_METHOD(void,
+              OnSsrcBoundToRsid,
+              (const std::string& rsid, uint32_t ssrc),
+              (override));
+  MOCK_METHOD(void,
+              OnSsrcBoundToMid,
+              (const std::string& mid, 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 {
diff --git a/call/rtp_video_sender_unittest.cc b/call/rtp_video_sender_unittest.cc
index a87196111a..048fe1a7ec 100644
--- a/call/rtp_video_sender_unittest.cc
+++ b/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,
-                 void(const FrameCounts& frame_counts, uint32_t ssrc));
+    MOCK_METHOD(void,
+                FrameCountUpdated,
+                (const FrameCounts& frame_counts, uint32_t ssrc),
+                (override));
   } callback;
 
   RtpVideoSenderTestFixture test({kSsrc1}, {kRtxSsrc1}, kPayloadType, {},
diff --git a/call/test/mock_audio_send_stream.h b/call/test/mock_audio_send_stream.h
index 489e826d0e..4164dd550e 100644
--- a/call/test/mock_audio_send_stream.h
+++ b/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_METHOD1(Reconfigure, void(const Config& config));
-  MOCK_METHOD0(Start, void());
-  MOCK_METHOD0(Stop, void());
+  MOCK_METHOD(const webrtc::AudioSendStream::Config&,
+              GetConfig,
+              (),
+              (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_METHOD4(SendTelephoneEvent,
-               bool(int payload_type,
-                    int payload_frequency,
-                    int event,
-                    int duration_ms));
-  MOCK_METHOD1(SetMuted, void(bool muted));
-  MOCK_CONST_METHOD0(GetStats, Stats());
-  MOCK_CONST_METHOD1(GetStats, Stats(bool has_remote_tracks));
+  MOCK_METHOD(void, SendAudioDataForMock, (webrtc::AudioFrame*));
+  MOCK_METHOD(
+      bool,
+      SendTelephoneEvent,
+      (int payload_type, int payload_frequency, int event, int duration_ms),
+      (override));
+  MOCK_METHOD(void, SetMuted, (bool muted), (override));
+  MOCK_METHOD(Stats, GetStats, (), (const, override));
+  MOCK_METHOD(Stats, GetStats, (bool has_remote_tracks), (const, override));
 };
 }  // namespace test
 }  // namespace webrtc
diff --git a/call/test/mock_bitrate_allocator.h b/call/test/mock_bitrate_allocator.h
index f00ed79c59..b08916fe4f 100644
--- a/call/test/mock_bitrate_allocator.h
+++ b/call/test/mock_bitrate_allocator.h
@@ -18,10 +18,15 @@
 namespace webrtc {
 class MockBitrateAllocator : public BitrateAllocatorInterface {
  public:
-  MOCK_METHOD2(AddObserver,
-               void(BitrateAllocatorObserver*, MediaStreamAllocationConfig));
-  MOCK_METHOD1(RemoveObserver, void(BitrateAllocatorObserver*));
-  MOCK_CONST_METHOD1(GetStartBitrate, int(BitrateAllocatorObserver*));
+  MOCK_METHOD(void,
+              AddObserver,
+              (BitrateAllocatorObserver*, MediaStreamAllocationConfig),
+              (override));
+  MOCK_METHOD(void, RemoveObserver, (BitrateAllocatorObserver*), (override));
+  MOCK_METHOD(int,
+              GetStartBitrate,
+              (BitrateAllocatorObserver*),
+              (const, override));
 };
 }  // namespace webrtc
 #endif  // CALL_TEST_MOCK_BITRATE_ALLOCATOR_H_
diff --git a/call/test/mock_rtp_packet_sink_interface.h b/call/test/mock_rtp_packet_sink_interface.h
index adc804f941..e6d14f05c5 100644
--- a/call/test/mock_rtp_packet_sink_interface.h
+++ b/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
diff --git a/call/test/mock_rtp_transport_controller_send.h b/call/test/mock_rtp_transport_controller_send.h
index afc8400f73..308c087a40 100644
--- a/call/test/mock_rtp_transport_controller_send.h
+++ b/call/test/mock_rtp_transport_controller_send.h
@@ -32,45 +32,73 @@ namespace webrtc {
 class MockRtpTransportControllerSend
     : public RtpTransportControllerSendInterface {
  public:
-  MOCK_METHOD10(
-      CreateRtpVideoSender,
-      RtpVideoSenderInterface*(std::map<uint32_t, RtpState>,
-                               const std::map<uint32_t, RtpPayloadState>&,
-                               const RtpConfig&,
-                               int rtcp_report_interval_ms,
-                               Transport*,
-                               const RtpSenderObservers&,
-                               RtcEventLog*,
-                               std::unique_ptr<FecController>,
-                               const RtpSenderFrameEncryptionConfig&,
-                               rtc::scoped_refptr<FrameTransformerInterface>));
-  MOCK_METHOD1(DestroyRtpVideoSender, void(RtpVideoSenderInterface*));
-  MOCK_METHOD0(GetWorkerQueue, rtc::TaskQueue*());
-  MOCK_METHOD0(packet_router, PacketRouter*());
-  MOCK_METHOD0(network_state_estimate_observer,
-               NetworkStateEstimateObserver*());
-  MOCK_METHOD0(transport_feedback_observer, TransportFeedbackObserver*());
-  MOCK_METHOD0(packet_sender, RtpPacketSender*());
-  MOCK_METHOD1(SetAllocatedSendBitrateLimits, void(BitrateAllocationLimits));
-  MOCK_METHOD1(SetPacingFactor, void(float));
-  MOCK_METHOD1(SetQueueTimeLimit, void(int));
-  MOCK_METHOD0(GetStreamFeedbackProvider, StreamFeedbackProvider*());
-  MOCK_METHOD1(RegisterTargetTransferRateObserver,
-               void(TargetTransferRateObserver*));
-  MOCK_METHOD2(OnNetworkRouteChanged,
-               void(const std::string&, const rtc::NetworkRoute&));
-  MOCK_METHOD1(OnNetworkAvailability, void(bool));
-  MOCK_METHOD0(GetBandwidthObserver, RtcpBandwidthObserver*());
-  MOCK_CONST_METHOD0(GetPacerQueuingDelayMs, int64_t());
-  MOCK_CONST_METHOD0(GetFirstPacketTime, absl::optional<Timestamp>());
-  MOCK_METHOD1(EnablePeriodicAlrProbing, void(bool));
-  MOCK_METHOD1(OnSentPacket, void(const rtc::SentPacket&));
-  MOCK_METHOD1(SetSdpBitrateParameters, void(const BitrateConstraints&));
-  MOCK_METHOD1(SetClientBitratePreferences, void(const BitrateSettings&));
-  MOCK_METHOD1(OnTransportOverheadChanged, void(size_t));
-  MOCK_METHOD1(AccountForAudioPacketsInPacedSender, void(bool));
-  MOCK_METHOD0(IncludeOverheadInPacedSender, void());
-  MOCK_METHOD1(OnReceivedPacket, void(const ReceivedPacket&));
+  MOCK_METHOD(RtpVideoSenderInterface*,
+              CreateRtpVideoSender,
+              ((std::map<uint32_t, RtpState>),
+               (const std::map<uint32_t, RtpPayloadState>&),
+               const RtpConfig&,
+               int rtcp_report_interval_ms,
+               Transport*,
+               const RtpSenderObservers&,
+               RtcEventLog*,
+               std::unique_ptr<FecController>,
+               const RtpSenderFrameEncryptionConfig&,
+               rtc::scoped_refptr<FrameTransformerInterface>),
+              (override));
+  MOCK_METHOD(void,
+              DestroyRtpVideoSender,
+              (RtpVideoSenderInterface*),
+              (override));
+  MOCK_METHOD(rtc::TaskQueue*, GetWorkerQueue, (), (override));
+  MOCK_METHOD(PacketRouter*, packet_router, (), (override));
+  MOCK_METHOD(NetworkStateEstimateObserver*,
+              network_state_estimate_observer,
+              (),
+              (override));
+  MOCK_METHOD(TransportFeedbackObserver*,
+              transport_feedback_observer,
+              (),
+              (override));
+  MOCK_METHOD(RtpPacketSender*, packet_sender, (), (override));
+  MOCK_METHOD(void,
+              SetAllocatedSendBitrateLimits,
+              (BitrateAllocationLimits),
+              (override));
+  MOCK_METHOD(void, SetPacingFactor, (float), (override));
+  MOCK_METHOD(void, SetQueueTimeLimit, (int), (override));
+  MOCK_METHOD(StreamFeedbackProvider*,
+              GetStreamFeedbackProvider,
+              (),
+              (override));
+  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_