diff --git a/video/adaptation/overuse_frame_detector_unittest.cc b/video/adaptation/overuse_frame_detector_unittest.cc
index bb34224..d4bf910 100644
--- a/video/adaptation/overuse_frame_detector_unittest.cc
+++ b/video/adaptation/overuse_frame_detector_unittest.cc
@@ -41,8 +41,8 @@
   MockCpuOveruseObserver() {}
   virtual ~MockCpuOveruseObserver() {}
 
-  MOCK_METHOD0(AdaptUp, void());
-  MOCK_METHOD0(AdaptDown, void());
+  MOCK_METHOD(void, AdaptUp, (), (override));
+  MOCK_METHOD(void, AdaptDown, (), (override));
 };
 
 class CpuOveruseObserverImpl : public OveruseFrameDetectorObserverInterface {
diff --git a/video/call_stats2_unittest.cc b/video/call_stats2_unittest.cc
index 73fe4b4..b3d43cb 100644
--- a/video/call_stats2_unittest.cc
+++ b/video/call_stats2_unittest.cc
@@ -33,7 +33,7 @@
   MockStatsObserver() {}
   virtual ~MockStatsObserver() {}
 
-  MOCK_METHOD2(OnRttUpdate, void(int64_t, int64_t));
+  MOCK_METHOD(void, OnRttUpdate, (int64_t, int64_t), (override));
 };
 
 class CallStats2Test : public ::testing::Test {
diff --git a/video/call_stats_unittest.cc b/video/call_stats_unittest.cc
index c560ccb..e85c4f8 100644
--- a/video/call_stats_unittest.cc
+++ b/video/call_stats_unittest.cc
@@ -32,7 +32,7 @@
   MockStatsObserver() {}
   virtual ~MockStatsObserver() {}
 
-  MOCK_METHOD2(OnRttUpdate, void(int64_t, int64_t));
+  MOCK_METHOD(void, OnRttUpdate, (int64_t, int64_t), (override));
 };
 
 class CallStatsTest : public ::testing::Test {
diff --git a/video/rtp_video_stream_receiver_unittest.cc b/video/rtp_video_stream_receiver_unittest.cc
index 255de54..510cad3 100644
--- a/video/rtp_video_stream_receiver_unittest.cc
+++ b/video/rtp_video_stream_receiver_unittest.cc
@@ -73,37 +73,45 @@
 
 class MockTransport : public Transport {
  public:
-  MOCK_METHOD3(SendRtp,
-               bool(const uint8_t* packet,
-                    size_t length,
-                    const PacketOptions& options));
-  MOCK_METHOD2(SendRtcp, bool(const uint8_t* packet, size_t length));
+  MOCK_METHOD(bool,
+              SendRtp,
+              (const uint8_t*, size_t length, const PacketOptions& options),
+              (override));
+  MOCK_METHOD(bool, SendRtcp, (const uint8_t*, size_t length), (override));
 };
 
 class MockNackSender : public NackSender {
  public:
-  MOCK_METHOD1(SendNack, void(const std::vector<uint16_t>& sequence_numbers));
-  MOCK_METHOD2(SendNack,
-               void(const std::vector<uint16_t>& sequence_numbers,
-                    bool buffering_allowed));
+  MOCK_METHOD(void,
+              SendNack,
+              (const std::vector<uint16_t>& sequence_numbers,
+               bool buffering_allowed),
+              (override));
 };
 
 class MockKeyFrameRequestSender : public KeyFrameRequestSender {
  public:
-  MOCK_METHOD0(RequestKeyFrame, void());
+  MOCK_METHOD(void, RequestKeyFrame, (), (override));
 };
 
 class MockOnCompleteFrameCallback
     : public video_coding::OnCompleteFrameCallback {
  public:
-  MOCK_METHOD1(DoOnCompleteFrame, void(video_coding::EncodedFrame* frame));
-  MOCK_METHOD1(DoOnCompleteFrameFailNullptr,
-               void(video_coding::EncodedFrame* frame));
-  MOCK_METHOD1(DoOnCompleteFrameFailLength,
-               void(video_coding::EncodedFrame* frame));
-  MOCK_METHOD1(DoOnCompleteFrameFailBitstream,
-               void(video_coding::EncodedFrame* frame));
-  void OnCompleteFrame(std::unique_ptr<video_coding::EncodedFrame> frame) {
+  MOCK_METHOD(void, DoOnCompleteFrame, (video_coding::EncodedFrame*), ());
+  MOCK_METHOD(void,
+              DoOnCompleteFrameFailNullptr,
+              (video_coding::EncodedFrame*),
+              ());
+  MOCK_METHOD(void,
+              DoOnCompleteFrameFailLength,
+              (video_coding::EncodedFrame*),
+              ());
+  MOCK_METHOD(void,
+              DoOnCompleteFrameFailBitstream,
+              (video_coding::EncodedFrame*),
+              ());
+  void OnCompleteFrame(
+      std::unique_ptr<video_coding::EncodedFrame> frame) override {
     if (!frame) {
       DoOnCompleteFrameFailNullptr(nullptr);
       return;
@@ -132,7 +140,7 @@
 
 class MockRtpPacketSink : public RtpPacketSinkInterface {
  public:
-  MOCK_METHOD1(OnRtpPacket, void(const RtpPacketReceived&));
+  MOCK_METHOD(void, OnRtpPacket, (const RtpPacketReceived&), (override));
 };
 
 constexpr uint32_t kSsrc = 111;
diff --git a/video/test/mock_video_stream_encoder.h b/video/test/mock_video_stream_encoder.h
index 8e42968..4c076ea 100644
--- a/video/test/mock_video_stream_encoder.h
+++ b/video/test/mock_video_stream_encoder.h
@@ -17,22 +17,36 @@
 
 class MockVideoStreamEncoder : public VideoStreamEncoderInterface {
  public:
-  MOCK_METHOD2(SetSource,
-               void(rtc::VideoSourceInterface<VideoFrame>*,
-                    const DegradationPreference&));
-  MOCK_METHOD2(SetSink, void(EncoderSink*, bool));
-  MOCK_METHOD1(SetStartBitrate, void(int));
-  MOCK_METHOD0(SendKeyFrame, void());
-  MOCK_METHOD1(OnLossNotification, void(const VideoEncoder::LossNotification&));
-  MOCK_METHOD6(OnBitrateUpdated,
-               void(DataRate, DataRate, DataRate, uint8_t, int64_t, double));
-  MOCK_METHOD1(OnFrame, void(const VideoFrame&));
-  MOCK_METHOD1(SetBitrateAllocationObserver,
-               void(VideoBitrateAllocationObserver*));
-  MOCK_METHOD1(SetFecControllerOverride, void(FecControllerOverride*));
-  MOCK_METHOD0(Stop, void());
+  MOCK_METHOD(void,
+              SetSource,
+              (rtc::VideoSourceInterface<VideoFrame>*,
+               const DegradationPreference&),
+              (override));
+  MOCK_METHOD(void, SetSink, (EncoderSink*, bool), (override));
+  MOCK_METHOD(void, SetStartBitrate, (int), (override));
+  MOCK_METHOD(void, SendKeyFrame, (), (override));
+  MOCK_METHOD(void,
+              OnLossNotification,
+              (const VideoEncoder::LossNotification&),
+              (override));
+  MOCK_METHOD(void,
+              OnBitrateUpdated,
+              (DataRate, DataRate, DataRate, uint8_t, int64_t, double),
+              (override));
+  MOCK_METHOD(void, OnFrame, (const VideoFrame&), (override));
+  MOCK_METHOD(void,
+              SetBitrateAllocationObserver,
+              (VideoBitrateAllocationObserver*),
+              (override));
+  MOCK_METHOD(void,
+              SetFecControllerOverride,
+              (FecControllerOverride*),
+              (override));
+  MOCK_METHOD(void, Stop, (), (override));
 
-  MOCK_METHOD2(MockedConfigureEncoder, void(const VideoEncoderConfig&, size_t));
+  MOCK_METHOD(void,
+              MockedConfigureEncoder,
+              (const VideoEncoderConfig&, size_t));
   // gtest generates implicit copy which is not allowed on VideoEncoderConfig,
   // so we can't mock ConfigureEncoder directly.
   void ConfigureEncoder(VideoEncoderConfig config,
diff --git a/video/video_receive_stream_unittest.cc b/video/video_receive_stream_unittest.cc
index 54896e8..07032fe 100644
--- a/video/video_receive_stream_unittest.cc
+++ b/video/video_receive_stream_unittest.cc
@@ -49,24 +49,30 @@
 
 class MockTransport : public Transport {
  public:
-  MOCK_METHOD3(SendRtp,
-               bool(const uint8_t* packet,
-                    size_t length,
-                    const PacketOptions& options));
-  MOCK_METHOD2(SendRtcp, bool(const uint8_t* packet, size_t length));
+  MOCK_METHOD(bool,
+              SendRtp,
+              (const uint8_t*, size_t length, const PacketOptions& options),
+              (override));
+  MOCK_METHOD(bool, SendRtcp, (const uint8_t*, size_t length), (override));
 };
 
 class MockVideoDecoder : public VideoDecoder {
  public:
-  MOCK_METHOD2(InitDecode,
-               int32_t(const VideoCodec* config, int32_t number_of_cores));
-  MOCK_METHOD3(Decode,
-               int32_t(const EncodedImage& input,
-                       bool missing_frames,
-                       int64_t render_time_ms));
-  MOCK_METHOD1(RegisterDecodeCompleteCallback,
-               int32_t(DecodedImageCallback* callback));
-  MOCK_METHOD0(Release, int32_t(void));
+  MOCK_METHOD(int32_t,
+              InitDecode,
+              (const VideoCodec*, int32_t number_of_cores),
+              (override));
+  MOCK_METHOD(int32_t,
+              Decode,
+              (const EncodedImage& input,
+               bool missing_frames,
+               int64_t render_time_ms),
+              (override));
+  MOCK_METHOD(int32_t,
+              RegisterDecodeCompleteCallback,
+              (DecodedImageCallback*),
+              (override));
+  MOCK_METHOD(int32_t, Release, (), (override));
   const char* ImplementationName() const { return "MockVideoDecoder"; }
 };
 
diff --git a/video/video_send_stream_impl_unittest.cc b/video/video_send_stream_impl_unittest.cc
index 532e035..178d386 100644
--- a/video/video_send_stream_impl_unittest.cc
+++ b/video/video_send_stream_impl_unittest.cc
@@ -58,33 +58,45 @@
 }
 class MockRtpVideoSender : public RtpVideoSenderInterface {
  public:
-  MOCK_METHOD1(RegisterProcessThread, void(ProcessThread*));
-  MOCK_METHOD0(DeRegisterProcessThread, void());
-  MOCK_METHOD1(SetActive, void(bool));
-  MOCK_METHOD1(SetActiveModules, void(const std::vector<bool>));
-  MOCK_METHOD0(IsActive, bool());
-  MOCK_METHOD1(OnNetworkAvailability, void(bool));
-  MOCK_CONST_METHOD0(GetRtpStates, std::map<uint32_t, RtpState>());
-  MOCK_CONST_METHOD0(GetRtpPayloadStates,
-                     std::map<uint32_t, RtpPayloadState>());
-  MOCK_METHOD2(DeliverRtcp, void(const uint8_t*, size_t));
-  MOCK_METHOD1(OnBitrateAllocationUpdated, void(const VideoBitrateAllocation&));
-  MOCK_METHOD3(OnEncodedImage,
-               EncodedImageCallback::Result(const EncodedImage&,
-                                            const CodecSpecificInfo*,
-                                            const RTPFragmentationHeader*));
-  MOCK_METHOD1(OnTransportOverheadChanged, void(size_t));
-  MOCK_METHOD1(OnOverheadChanged, void(size_t));
-  MOCK_METHOD2(OnBitrateUpdated, void(BitrateAllocationUpdate, int));
-  MOCK_CONST_METHOD0(GetPayloadBitrateBps, uint32_t());
-  MOCK_CONST_METHOD0(GetProtectionBitrateBps, uint32_t());
-  MOCK_METHOD3(SetEncodingData, void(size_t, size_t, size_t));
-  MOCK_CONST_METHOD2(GetSentRtpPacketInfos,
-                     std::vector<RtpSequenceNumberMap::Info>(
-                         uint32_t ssrc,
-                         rtc::ArrayView<const uint16_t> sequence_numbers));
+  MOCK_METHOD(void, RegisterProcessThread, (ProcessThread*), (override));
+  MOCK_METHOD(void, DeRegisterProcessThread, (), (override));
+  MOCK_METHOD(void, SetActive, (bool), (override));
+  MOCK_METHOD(void, SetActiveModules, (const std::vector<bool>), (override));
+  MOCK_METHOD(bool, IsActive, (), (override));
+  MOCK_METHOD(void, OnNetworkAvailability, (bool), (override));
+  MOCK_METHOD((std::map<uint32_t, RtpState>),
+              GetRtpStates,
+              (),
+              (const, override));
+  MOCK_METHOD((std::map<uint32_t, RtpPayloadState>),
+              GetRtpPayloadStates,
+              (),
+              (const, override));
+  MOCK_METHOD(void, DeliverRtcp, (const uint8_t*, size_t), (override));
+  MOCK_METHOD(void,
+              OnBitrateAllocationUpdated,
+              (const VideoBitrateAllocation&),
+              (override));
+  MOCK_METHOD(EncodedImageCallback::Result,
+              OnEncodedImage,
+              (const EncodedImage&,
+               const CodecSpecificInfo*,
+               const RTPFragmentationHeader*),
+              (override));
+  MOCK_METHOD(void, OnTransportOverheadChanged, (size_t), (override));
+  MOCK_METHOD(void,
+              OnBitrateUpdated,
+              (BitrateAllocationUpdate, int),
+              (override));
+  MOCK_METHOD(uint32_t, GetPayloadBitrateBps, (), (const, override));
+  MOCK_METHOD(uint32_t, GetProtectionBitrateBps, (), (const, override));
+  MOCK_METHOD(void, SetEncodingData, (size_t, size_t, size_t), (override));
+  MOCK_METHOD(std::vector<RtpSequenceNumberMap::Info>,
+              GetSentRtpPacketInfos,
+              (uint32_t ssrc, rtc::ArrayView<const uint16_t> sequence_numbers),
+              (const, override));
 
-  MOCK_METHOD1(SetFecAllowed, void(bool fec_allowed));
+  MOCK_METHOD(void, SetFecAllowed, (bool fec_allowed), (override));
 };
 
 BitrateAllocationUpdate CreateAllocation(int bitrate_bps) {
diff --git a/video/video_source_sink_controller_unittest.cc b/video/video_source_sink_controller_unittest.cc
index c4e2ea1..66881cd 100644
--- a/video/video_source_sink_controller_unittest.cc
+++ b/video/video_source_sink_controller_unittest.cc
@@ -30,8 +30,8 @@
  public:
   ~MockVideoSinkWithVideoFrame() override {}
 
-  MOCK_METHOD1(OnFrame, void(const VideoFrame& frame));
-  MOCK_METHOD0(OnDiscardedFrame, void());
+  MOCK_METHOD(void, OnFrame, (const VideoFrame& frame), (override));
+  MOCK_METHOD(void, OnDiscardedFrame, (), (override));
 };
 
 class MockVideoSourceWithVideoFrame
@@ -39,10 +39,15 @@
  public:
   ~MockVideoSourceWithVideoFrame() override {}
 
-  MOCK_METHOD2(AddOrUpdateSink,
-               void(rtc::VideoSinkInterface<VideoFrame>*,
-                    const rtc::VideoSinkWants&));
-  MOCK_METHOD1(RemoveSink, void(rtc::VideoSinkInterface<VideoFrame>*));
+  MOCK_METHOD(void,
+              AddOrUpdateSink,
+              (rtc::VideoSinkInterface<VideoFrame>*,
+               const rtc::VideoSinkWants&),
+              (override));
+  MOCK_METHOD(void,
+              RemoveSink,
+              (rtc::VideoSinkInterface<VideoFrame>*),
+              (override));
 };
 
 }  // namespace
diff --git a/video/video_stream_decoder_impl_unittest.cc b/video/video_stream_decoder_impl_unittest.cc
index 44e9140..a45a12c 100644
--- a/video/video_stream_decoder_impl_unittest.cc
+++ b/video/video_stream_decoder_impl_unittest.cc
@@ -27,21 +27,25 @@
 class MockVideoStreamDecoderCallbacks
     : public VideoStreamDecoderInterface::Callbacks {
  public:
-  MOCK_METHOD0(OnNonDecodableState, void());
-  MOCK_METHOD1(OnContinuousUntil,
-               void(const video_coding::VideoLayerFrameId& key));
-  MOCK_METHOD1(OnEncodedFrame, void(const video_coding::EncodedFrame& frame));
-  MOCK_METHOD3(OnDecodedFrame,
-               void(VideoFrame decodedImage,
-                    absl::optional<int> decode_time_ms,
-                    absl::optional<int> qp));
+  MOCK_METHOD(void, OnNonDecodableState, (), (override));
+  MOCK_METHOD(void,
+              OnContinuousUntil,
+              (const video_coding::VideoLayerFrameId& key),
+              (override));
+  MOCK_METHOD(void,
+              OnDecodedFrame,
+              (VideoFrame decodedImage,
+               absl::optional<int> decode_time_ms,
+               absl::optional<int> qp),
+              (override));
 };
 
 class StubVideoDecoder : public VideoDecoder {
  public:
-  MOCK_METHOD2(InitDecode,
-               int32_t(const VideoCodec* codec_settings,
-                       int32_t number_of_cores));
+  MOCK_METHOD(int32_t,
+              InitDecode,
+              (const VideoCodec*, int32_t number_of_cores),
+              (override));
 
   int32_t Decode(const EncodedImage& input_image,
                  bool missing_frames,
@@ -57,10 +61,12 @@
     return ret_code;
   }
 
-  MOCK_METHOD3(DecodeCall,
-               int32_t(const EncodedImage& input_image,
-                       bool missing_frames,
-                       int64_t render_time_ms));
+  MOCK_METHOD(int32_t,
+              DecodeCall,
+              (const EncodedImage& input_image,
+               bool missing_frames,
+               int64_t render_time_ms),
+              ());
 
   int32_t Release() override { return 0; }
 
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index 158d745..a768203 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -507,16 +507,24 @@
 
 class MockBitrateObserver : public VideoBitrateAllocationObserver {
  public:
-  MOCK_METHOD1(OnBitrateAllocationUpdated, void(const VideoBitrateAllocation&));
+  MOCK_METHOD(void,
+              OnBitrateAllocationUpdated,
+              (const VideoBitrateAllocation&),
+              (override));
 };
 
 class MockEncoderSelector
     : public VideoEncoderFactory::EncoderSelectorInterface {
  public:
-  MOCK_METHOD1(OnCurrentEncoder, void(const SdpVideoFormat& format));
-  MOCK_METHOD1(OnAvailableBitrate,
-               absl::optional<SdpVideoFormat>(const DataRate& rate));
-  MOCK_METHOD0(OnEncoderBroken, absl::optional<SdpVideoFormat>());
+  MOCK_METHOD(void,
+              OnCurrentEncoder,
+              (const SdpVideoFormat& format),
+              (override));
+  MOCK_METHOD(absl::optional<SdpVideoFormat>,
+              OnAvailableBitrate,
+              (const DataRate& rate),
+              (override));
+  MOCK_METHOD(absl::optional<SdpVideoFormat>, OnEncoderBroken, (), (override));
 };
 
 }  // namespace
@@ -5518,10 +5526,12 @@
 }
 
 struct MockEncoderSwitchRequestCallback : public EncoderSwitchRequestCallback {
-  MOCK_METHOD0(RequestEncoderFallback, void());
-  MOCK_METHOD1(RequestEncoderSwitch, void(const Config& conf));
-  MOCK_METHOD1(RequestEncoderSwitch,
-               void(const webrtc::SdpVideoFormat& format));
+  MOCK_METHOD(void, RequestEncoderFallback, (), (override));
+  MOCK_METHOD(void, RequestEncoderSwitch, (const Config& conf), (override));
+  MOCK_METHOD(void,
+              RequestEncoderSwitch,
+              (const webrtc::SdpVideoFormat& format),
+              (override));
 };
 
 TEST_F(VideoStreamEncoderTest, BitrateEncoderSwitch) {