diff --git a/api/test/loopback_media_transport_unittest.cc b/api/test/loopback_media_transport_unittest.cc
index f036de3..4649429 100644
--- a/api/test/loopback_media_transport_unittest.cc
+++ b/api/test/loopback_media_transport_unittest.cc
@@ -23,33 +23,41 @@
 class MockMediaTransportAudioSinkInterface
     : public MediaTransportAudioSinkInterface {
  public:
-  MOCK_METHOD2(OnData, void(uint64_t, MediaTransportEncodedAudioFrame));
+  MOCK_METHOD(void,
+              OnData,
+              (uint64_t, MediaTransportEncodedAudioFrame),
+              (override));
 };
 
 class MockMediaTransportVideoSinkInterface
     : public MediaTransportVideoSinkInterface {
  public:
-  MOCK_METHOD2(OnData, void(uint64_t, MediaTransportEncodedVideoFrame));
+  MOCK_METHOD(void,
+              OnData,
+              (uint64_t, MediaTransportEncodedVideoFrame),
+              (override));
 };
 
 class MockMediaTransportKeyFrameRequestCallback
     : public MediaTransportKeyFrameRequestCallback {
  public:
-  MOCK_METHOD1(OnKeyFrameRequested, void(uint64_t));
+  MOCK_METHOD(void, OnKeyFrameRequested, (uint64_t), (override));
 };
 
 class MockDataChannelSink : public DataChannelSink {
  public:
-  MOCK_METHOD3(OnDataReceived,
-               void(int, DataMessageType, const rtc::CopyOnWriteBuffer&));
-  MOCK_METHOD1(OnChannelClosing, void(int));
-  MOCK_METHOD1(OnChannelClosed, void(int));
-  MOCK_METHOD0(OnReadyToSend, void());
+  MOCK_METHOD(void,
+              OnDataReceived,
+              (int, DataMessageType, const rtc::CopyOnWriteBuffer&),
+              (override));
+  MOCK_METHOD(void, OnChannelClosing, (int), (override));
+  MOCK_METHOD(void, OnChannelClosed, (int), (override));
+  MOCK_METHOD(void, OnReadyToSend, (), (override));
 };
 
 class MockStateCallback : public MediaTransportStateCallback {
  public:
-  MOCK_METHOD1(OnStateChanged, void(MediaTransportState));
+  MOCK_METHOD(void, OnStateChanged, (MediaTransportState), (override));
 };
 
 }  // namespace
diff --git a/api/test/mock_audio_mixer.h b/api/test/mock_audio_mixer.h
index aee717b..88dc108 100644
--- a/api/test/mock_audio_mixer.h
+++ b/api/test/mock_audio_mixer.h
@@ -19,12 +19,9 @@
 
 class MockAudioMixer : public AudioMixer {
  public:
-  MOCK_METHOD(bool, AddSource, (Source * audio_source), (override));
-  MOCK_METHOD(void, RemoveSource, (Source * audio_source), (override));
-  MOCK_METHOD(void,
-              Mix,
-              (size_t number_of_channels, AudioFrame* audio_frame_for_mixing),
-              (override));
+  MOCK_METHOD(bool, AddSource, (Source*), (override));
+  MOCK_METHOD(void, RemoveSource, (Source*), (override));
+  MOCK_METHOD(void, Mix, (size_t number_of_channels, AudioFrame*), (override));
 };
 }  // namespace test
 }  // namespace webrtc
diff --git a/api/test/mock_video_bitrate_allocator_factory.h b/api/test/mock_video_bitrate_allocator_factory.h
index c7d883a..16af191 100644
--- a/api/test/mock_video_bitrate_allocator_factory.h
+++ b/api/test/mock_video_bitrate_allocator_factory.h
@@ -26,7 +26,7 @@
               CreateVideoBitrateAllocator,
               (const VideoCodec&),
               (override));
-  MOCK_METHOD(void, Die, (), ());
+  MOCK_METHOD(void, Die, ());
 };
 
 }  // namespace webrtc
diff --git a/api/test/mock_video_decoder_factory.h b/api/test/mock_video_decoder_factory.h
index 1f832a1..98a5d40 100644
--- a/api/test/mock_video_decoder_factory.h
+++ b/api/test/mock_video_decoder_factory.h
@@ -27,12 +27,12 @@
   MOCK_METHOD(std::vector<webrtc::SdpVideoFormat>,
               GetSupportedFormats,
               (),
-              (const override));
+              (const, override));
   MOCK_METHOD(std::unique_ptr<webrtc::VideoDecoder>,
               CreateVideoDecoder,
               (const webrtc::SdpVideoFormat&),
               (override));
-  MOCK_METHOD(void, Die, (), ());
+  MOCK_METHOD(void, Die, ());
 };
 }  // namespace webrtc
 
diff --git a/api/test/mock_video_encoder.h b/api/test/mock_video_encoder.h
index c4b6b3e..26d758f 100644
--- a/api/test/mock_video_encoder.h
+++ b/api/test/mock_video_encoder.h
@@ -23,8 +23,8 @@
   MOCK_METHOD(Result,
               OnEncodedImage,
               (const EncodedImage& encodedImage,
-               const CodecSpecificInfo* codecSpecificInfo,
-               const RTPFragmentationHeader* fragmentation),
+               const CodecSpecificInfo*,
+               const RTPFragmentationHeader*),
               (override));
   MOCK_METHOD(void, OnDroppedFrame, (DropReason reason), (override));
 };
@@ -33,31 +33,41 @@
  public:
   MOCK_METHOD(void,
               SetFecControllerOverride,
-              (FecControllerOverride * fec_controller_override),
+              (FecControllerOverride*),
               (override));
   MOCK_METHOD(int32_t,
               InitEncode,
-              (const VideoCodec* codecSettings,
-               int32_t numberOfCores,
-               size_t maxPayloadSize),
+              (const VideoCodec*, int32_t numberOfCores, size_t maxPayloadSize),
               (override));
-  MOCK_METHOD2(InitEncode,
-               int32_t(const VideoCodec* codecSettings,
-                       const VideoEncoder::Settings& settings));
+  MOCK_METHOD(int32_t,
+              InitEncode,
+              (const VideoCodec*, const VideoEncoder::Settings& settings),
+              (override));
 
-  MOCK_METHOD2(Encode,
-               int32_t(const VideoFrame& inputImage,
-                       const std::vector<VideoFrameType>* frame_types));
-  MOCK_METHOD1(RegisterEncodeCompleteCallback,
-               int32_t(EncodedImageCallback* callback));
-  MOCK_METHOD0(Release, int32_t());
-  MOCK_METHOD0(Reset, int32_t());
-  MOCK_METHOD1(SetRates, void(const RateControlParameters& parameters));
-  MOCK_METHOD1(OnPacketLossRateUpdate, void(float packet_loss_rate));
-  MOCK_METHOD1(OnRttUpdate, void(int64_t rtt_ms));
-  MOCK_METHOD1(OnLossNotification,
-               void(const LossNotification& loss_notification));
-  MOCK_CONST_METHOD0(GetEncoderInfo, EncoderInfo(void));
+  MOCK_METHOD(int32_t,
+              Encode,
+              (const VideoFrame& inputImage,
+               const std::vector<VideoFrameType>*),
+              (override));
+  MOCK_METHOD(int32_t,
+              RegisterEncodeCompleteCallback,
+              (EncodedImageCallback*),
+              (override));
+  MOCK_METHOD(int32_t, Release, (), (override));
+  MOCK_METHOD(void,
+              SetRates,
+              (const RateControlParameters& parameters),
+              (override));
+  MOCK_METHOD(void,
+              OnPacketLossRateUpdate,
+              (float packet_loss_rate),
+              (override));
+  MOCK_METHOD(void, OnRttUpdate, (int64_t rtt_ms), (override));
+  MOCK_METHOD(void,
+              OnLossNotification,
+              (const LossNotification& loss_notification),
+              (override));
+  MOCK_METHOD(EncoderInfo, GetEncoderInfo, (), (const, override));
 };
 
 }  // namespace webrtc
diff --git a/api/test/mock_video_encoder_factory.h b/api/test/mock_video_encoder_factory.h
index fa08dbd..1aa1463 100644
--- a/api/test/mock_video_encoder_factory.h
+++ b/api/test/mock_video_encoder_factory.h
@@ -27,17 +27,17 @@
   MOCK_METHOD(std::vector<SdpVideoFormat>,
               GetSupportedFormats,
               (),
-              (const override));
+              (const, override));
   MOCK_METHOD(CodecInfo,
               QueryVideoEncoder,
               (const SdpVideoFormat&),
-              (const override));
+              (const, override));
   MOCK_METHOD(std::unique_ptr<VideoEncoder>,
               CreateVideoEncoder,
               (const SdpVideoFormat&),
               (override));
 
-  MOCK_METHOD(void, Die, (), ());
+  MOCK_METHOD(void, Die, ());
 };
 
 }  // namespace webrtc
diff --git a/api/transport/test/mock_network_control.h b/api/transport/test/mock_network_control.h
index 54a416c..f613004 100644
--- a/api/transport/test/mock_network_control.h
+++ b/api/transport/test/mock_network_control.h
@@ -18,11 +18,16 @@
 
 class MockNetworkStateEstimator : public NetworkStateEstimator {
  public:
-  MOCK_METHOD0(GetCurrentEstimate, absl::optional<NetworkStateEstimate>());
-  MOCK_METHOD1(OnTransportPacketsFeedback,
-               void(const TransportPacketsFeedback&));
-  MOCK_METHOD1(OnReceivedPacket, void(const PacketResult&));
-  MOCK_METHOD1(OnRouteChange, void(const NetworkRouteChange&));
+  MOCK_METHOD(absl::optional<NetworkStateEstimate>,
+              GetCurrentEstimate,
+              (),
+              (override));
+  MOCK_METHOD(void,
+              OnTransportPacketsFeedback,
+              (const TransportPacketsFeedback&),
+              (override));
+  MOCK_METHOD(void, OnReceivedPacket, (const PacketResult&), (override));
+  MOCK_METHOD(void, OnRouteChange, (const NetworkRouteChange&), (override));
 };
 
 }  // namespace webrtc
diff --git a/api/video/test/mock_recordable_encoded_frame.h b/api/video/test/mock_recordable_encoded_frame.h
index 1788a49..2178932 100644
--- a/api/video/test/mock_recordable_encoded_frame.h
+++ b/api/video/test/mock_recordable_encoded_frame.h
@@ -17,13 +17,18 @@
 namespace webrtc {
 class MockRecordableEncodedFrame : public RecordableEncodedFrame {
  public:
-  MOCK_CONST_METHOD0(encoded_buffer,
-                     rtc::scoped_refptr<const EncodedImageBufferInterface>());
-  MOCK_CONST_METHOD0(color_space, absl::optional<webrtc::ColorSpace>());
-  MOCK_CONST_METHOD0(codec, VideoCodecType());
-  MOCK_CONST_METHOD0(is_key_frame, bool());
-  MOCK_CONST_METHOD0(resolution, EncodedResolution());
-  MOCK_CONST_METHOD0(render_time, Timestamp());
+  MOCK_METHOD(rtc::scoped_refptr<const EncodedImageBufferInterface>,
+              encoded_buffer,
+              (),
+              (const, override));
+  MOCK_METHOD(absl::optional<webrtc::ColorSpace>,
+              color_space,
+              (),
+              (const, override));
+  MOCK_METHOD(VideoCodecType, codec, (), (const, override));
+  MOCK_METHOD(bool, is_key_frame, (), (const, override));
+  MOCK_METHOD(EncodedResolution, resolution, (), (const, override));
+  MOCK_METHOD(Timestamp, render_time, (), (const, override));
 };
 }  // namespace webrtc
 #endif  // API_VIDEO_TEST_MOCK_RECORDABLE_ENCODED_FRAME_H_
diff --git a/rtc_base/openssl_adapter_unittest.cc b/rtc_base/openssl_adapter_unittest.cc
index b161304..4bd8799 100644
--- a/rtc_base/openssl_adapter_unittest.cc
+++ b/rtc_base/openssl_adapter_unittest.cc
@@ -25,28 +25,34 @@
 class MockAsyncSocket : public AsyncSocket {
  public:
   virtual ~MockAsyncSocket() = default;
-  MOCK_METHOD1(Accept, AsyncSocket*(SocketAddress*));
-  MOCK_CONST_METHOD0(GetLocalAddress, SocketAddress());
-  MOCK_CONST_METHOD0(GetRemoteAddress, SocketAddress());
-  MOCK_METHOD1(Bind, int(const SocketAddress&));
-  MOCK_METHOD1(Connect, int(const SocketAddress&));
-  MOCK_METHOD2(Send, int(const void*, size_t));
-  MOCK_METHOD3(SendTo, int(const void*, size_t, const SocketAddress&));
-  MOCK_METHOD3(Recv, int(void*, size_t, int64_t*));
-  MOCK_METHOD4(RecvFrom, int(void*, size_t, SocketAddress*, int64_t*));
-  MOCK_METHOD1(Listen, int(int));
-  MOCK_METHOD0(Close, int());
-  MOCK_CONST_METHOD0(GetError, int());
-  MOCK_METHOD1(SetError, void(int));
-  MOCK_CONST_METHOD0(GetState, ConnState());
-  MOCK_METHOD2(GetOption, int(Option, int*));
-  MOCK_METHOD2(SetOption, int(Option, int));
+  MOCK_METHOD(AsyncSocket*, Accept, (SocketAddress*), (override));
+  MOCK_METHOD(SocketAddress, GetLocalAddress, (), (const, override));
+  MOCK_METHOD(SocketAddress, GetRemoteAddress, (), (const, override));
+  MOCK_METHOD(int, Bind, (const SocketAddress&), (override));
+  MOCK_METHOD(int, Connect, (const SocketAddress&), (override));
+  MOCK_METHOD(int, Send, (const void*, size_t), (override));
+  MOCK_METHOD(int,
+              SendTo,
+              (const void*, size_t, const SocketAddress&),
+              (override));
+  MOCK_METHOD(int, Recv, (void*, size_t, int64_t*), (override));
+  MOCK_METHOD(int,
+              RecvFrom,
+              (void*, size_t, SocketAddress*, int64_t*),
+              (override));
+  MOCK_METHOD(int, Listen, (int), (override));
+  MOCK_METHOD(int, Close, (), (override));
+  MOCK_METHOD(int, GetError, (), (const, override));
+  MOCK_METHOD(void, SetError, (int), (override));
+  MOCK_METHOD(ConnState, GetState, (), (const, override));
+  MOCK_METHOD(int, GetOption, (Option, int*), (override));
+  MOCK_METHOD(int, SetOption, (Option, int), (override));
 };
 
 class MockCertVerifier : public SSLCertificateVerifier {
  public:
   virtual ~MockCertVerifier() = default;
-  MOCK_METHOD1(Verify, bool(const SSLCertificate&));
+  MOCK_METHOD(bool, Verify, (const SSLCertificate&), (override));
 };
 
 }  // namespace
diff --git a/rtc_base/ssl_adapter_unittest.cc b/rtc_base/ssl_adapter_unittest.cc
index 125b4bd..498eba3 100644
--- a/rtc_base/ssl_adapter_unittest.cc
+++ b/rtc_base/ssl_adapter_unittest.cc
@@ -50,7 +50,7 @@
 class MockCertVerifier : public rtc::SSLCertificateVerifier {
  public:
   virtual ~MockCertVerifier() = default;
-  MOCK_METHOD1(Verify, bool(const rtc::SSLCertificate&));
+  MOCK_METHOD(bool, Verify, (const rtc::SSLCertificate&), (override));
 };
 
 // TODO(benwright) - Move to using INSTANTIATE_TEST_SUITE_P instead of using
diff --git a/rtc_base/synchronization/yield_policy_unittest.cc b/rtc_base/synchronization/yield_policy_unittest.cc
index e0c6225..0bf38f4 100644
--- a/rtc_base/synchronization/yield_policy_unittest.cc
+++ b/rtc_base/synchronization/yield_policy_unittest.cc
@@ -20,7 +20,7 @@
 namespace {
 class MockYieldHandler : public YieldInterface {
  public:
-  MOCK_METHOD0(YieldExecution, void());
+  MOCK_METHOD(void, YieldExecution, (), (override));
 };
 }  // namespace
 TEST(YieldPolicyTest, HandlerReceivesYieldSignalWhenSet) {
diff --git a/rtc_base/task_utils/repeating_task_unittest.cc b/rtc_base/task_utils/repeating_task_unittest.cc
index 83efb29..36d085c 100644
--- a/rtc_base/task_utils/repeating_task_unittest.cc
+++ b/rtc_base/task_utils/repeating_task_unittest.cc
@@ -40,8 +40,8 @@
 
 class MockClosure {
  public:
-  MOCK_METHOD0(Call, TimeDelta());
-  MOCK_METHOD0(Delete, void());
+  MOCK_METHOD(TimeDelta, Call, ());
+  MOCK_METHOD(void, Delete, ());
 };
 
 class MoveOnlyClosure {