diff --git a/pc/media_stream_unittest.cc b/pc/media_stream_unittest.cc
index b70171d..5522699 100644
--- a/pc/media_stream_unittest.cc
+++ b/pc/media_stream_unittest.cc
@@ -46,7 +46,7 @@
     }
   }
 
-  MOCK_METHOD0(OnChanged, void());
+  MOCK_METHOD(void, OnChanged, (), (override));
 
  private:
   NotifierInterface* notifier_;
diff --git a/pc/peer_connection_integrationtest.cc b/pc/peer_connection_integrationtest.cc
index 3a82cda..2fa4fb6 100644
--- a/pc/peer_connection_integrationtest.cc
+++ b/pc/peer_connection_integrationtest.cc
@@ -1082,8 +1082,8 @@
 class MockRtcEventLogOutput : public webrtc::RtcEventLogOutput {
  public:
   virtual ~MockRtcEventLogOutput() = default;
-  MOCK_CONST_METHOD0(IsActive, bool());
-  MOCK_METHOD1(Write, bool(const std::string&));
+  MOCK_METHOD(bool, IsActive, (), (const, override));
+  MOCK_METHOD(bool, Write, (const std::string&), (override));
 };
 
 // This helper object is used for both specifying how many audio/video frames
@@ -1216,7 +1216,7 @@
     return new rtc::RefCountedObject<MockIceTransport>(transport_name,
                                                        component);
   }
-  MOCK_METHOD0(RecordIceTransportCreated, void());
+  MOCK_METHOD(void, RecordIceTransportCreated, ());
 };
 
 // Tests two PeerConnections connecting to each other end-to-end, using a
diff --git a/pc/peer_connection_interface_unittest.cc b/pc/peer_connection_interface_unittest.cc
index 2a36970..2f4fdf7 100644
--- a/pc/peer_connection_interface_unittest.cc
+++ b/pc/peer_connection_interface_unittest.cc
@@ -627,7 +627,7 @@
     }
   }
 
-  MOCK_METHOD0(OnChanged, void());
+  MOCK_METHOD(void, OnChanged, (), (override));
 
  private:
   NotifierInterface* notifier_;
diff --git a/pc/proxy_unittest.cc b/pc/proxy_unittest.cc
index a00b47f..500828a 100644
--- a/pc/proxy_unittest.cc
+++ b/pc/proxy_unittest.cc
@@ -46,16 +46,16 @@
     return new rtc::RefCountedObject<Fake>();
   }
   // Used to verify destructor is called on the correct thread.
-  MOCK_METHOD0(Destroy, void());
+  MOCK_METHOD(void, Destroy, ());
 
-  MOCK_METHOD0(VoidMethod0, void());
-  MOCK_METHOD0(Method0, std::string());
-  MOCK_CONST_METHOD0(ConstMethod0, std::string());
+  MOCK_METHOD(void, VoidMethod0, (), (override));
+  MOCK_METHOD(std::string, Method0, (), (override));
+  MOCK_METHOD(std::string, ConstMethod0, (), (const, override));
 
-  MOCK_METHOD1(Method1, std::string(std::string));
-  MOCK_CONST_METHOD1(ConstMethod1, std::string(std::string));
+  MOCK_METHOD(std::string, Method1, (std::string), (override));
+  MOCK_METHOD(std::string, ConstMethod1, (std::string), (const, override));
 
-  MOCK_METHOD2(Method2, std::string(std::string, std::string));
+  MOCK_METHOD(std::string, Method2, (std::string, std::string), (override));
 
  protected:
   Fake() {}
@@ -266,7 +266,7 @@
 class Foo : public FooInterface {
  public:
   Foo() {}
-  MOCK_METHOD0(Bar, void());
+  MOCK_METHOD(void, Bar, (), (override));
 };
 
 BEGIN_OWNED_PROXY_MAP(Foo)
diff --git a/pc/rtp_sender_receiver_unittest.cc b/pc/rtp_sender_receiver_unittest.cc
index 9736f18..98560f8 100644
--- a/pc/rtp_sender_receiver_unittest.cc
+++ b/pc/rtp_sender_receiver_unittest.cc
@@ -88,7 +88,7 @@
 class MockSetStreamsObserver
     : public webrtc::RtpSenderBase::SetStreamsObserver {
  public:
-  MOCK_METHOD0(OnSetStreams, void());
+  MOCK_METHOD(void, OnSetStreams, (), (override));
 };
 
 }  // namespace
diff --git a/pc/test/mock_channel_interface.h b/pc/test/mock_channel_interface.h
index 255bd2f..2df3bae 100644
--- a/pc/test/mock_channel_interface.h
+++ b/pc/test/mock_channel_interface.h
@@ -24,25 +24,40 @@
 // implementation of BaseChannel.
 class MockChannelInterface : public cricket::ChannelInterface {
  public:
-  MOCK_CONST_METHOD0(media_type, cricket::MediaType());
-  MOCK_CONST_METHOD0(media_channel, MediaChannel*());
-  MOCK_CONST_METHOD0(transport_name, const std::string&());
-  MOCK_CONST_METHOD0(content_name, const std::string&());
-  MOCK_CONST_METHOD0(enabled, bool());
-  MOCK_METHOD1(Enable, bool(bool));
-  MOCK_METHOD0(SignalFirstPacketReceived,
-               sigslot::signal1<ChannelInterface*>&());
-  MOCK_METHOD3(SetLocalContent,
-               bool(const cricket::MediaContentDescription*,
-                    webrtc::SdpType,
-                    std::string*));
-  MOCK_METHOD3(SetRemoteContent,
-               bool(const cricket::MediaContentDescription*,
-                    webrtc::SdpType,
-                    std::string*));
-  MOCK_CONST_METHOD0(local_streams, const std::vector<StreamParams>&());
-  MOCK_CONST_METHOD0(remote_streams, const std::vector<StreamParams>&());
-  MOCK_METHOD1(SetRtpTransport, bool(webrtc::RtpTransportInternal*));
+  MOCK_METHOD(cricket::MediaType, media_type, (), (const, override));
+  MOCK_METHOD(MediaChannel*, media_channel, (), (const, override));
+  MOCK_METHOD(const std::string&, transport_name, (), (const, override));
+  MOCK_METHOD(const std::string&, content_name, (), (const, override));
+  MOCK_METHOD(bool, enabled, (), (const, override));
+  MOCK_METHOD(bool, Enable, (bool), (override));
+  MOCK_METHOD(sigslot::signal1<ChannelInterface*>&,
+              SignalFirstPacketReceived,
+              (),
+              (override));
+  MOCK_METHOD(bool,
+              SetLocalContent,
+              (const cricket::MediaContentDescription*,
+               webrtc::SdpType,
+               std::string*),
+              (override));
+  MOCK_METHOD(bool,
+              SetRemoteContent,
+              (const cricket::MediaContentDescription*,
+               webrtc::SdpType,
+               std::string*),
+              (override));
+  MOCK_METHOD(const std::vector<StreamParams>&,
+              local_streams,
+              (),
+              (const, override));
+  MOCK_METHOD(const std::vector<StreamParams>&,
+              remote_streams,
+              (),
+              (const, override));
+  MOCK_METHOD(bool,
+              SetRtpTransport,
+              (webrtc::RtpTransportInternal*),
+              (override));
 };
 
 }  // namespace cricket
diff --git a/pc/test/mock_data_channel.h b/pc/test/mock_data_channel.h
index 3385ec2..9ca018a 100644
--- a/pc/test/mock_data_channel.h
+++ b/pc/test/mock_data_channel.h
@@ -43,13 +43,13 @@
     EXPECT_CALL(*this, bytes_received())
         .WillRepeatedly(::testing::Return(bytes_received));
   }
-  MOCK_CONST_METHOD0(id, int());
-  MOCK_CONST_METHOD0(state, DataState());
-  MOCK_CONST_METHOD0(protocol, std::string());
-  MOCK_CONST_METHOD0(messages_sent, uint32_t());
-  MOCK_CONST_METHOD0(bytes_sent, uint64_t());
-  MOCK_CONST_METHOD0(messages_received, uint32_t());
-  MOCK_CONST_METHOD0(bytes_received, uint64_t());
+  MOCK_METHOD(int, id, (), (const, override));
+  MOCK_METHOD(DataState, state, (), (const, override));
+  MOCK_METHOD(std::string, protocol, (), (const, override));
+  MOCK_METHOD(uint32_t, messages_sent, (), (const, override));
+  MOCK_METHOD(uint64_t, bytes_sent, (), (const, override));
+  MOCK_METHOD(uint32_t, messages_received, (), (const, override));
+  MOCK_METHOD(uint64_t, bytes_received, (), (const, override));
 };
 
 }  // namespace webrtc
diff --git a/pc/test/mock_delayable.h b/pc/test/mock_delayable.h
index 548f9f8..bef07c1 100644
--- a/pc/test/mock_delayable.h
+++ b/pc/test/mock_delayable.h
@@ -21,9 +21,14 @@
 
 class MockDelayable : public cricket::Delayable {
  public:
-  MOCK_METHOD2(SetBaseMinimumPlayoutDelayMs, bool(uint32_t ssrc, int delay_ms));
-  MOCK_CONST_METHOD1(GetBaseMinimumPlayoutDelayMs,
-                     absl::optional<int>(uint32_t ssrc));
+  MOCK_METHOD(bool,
+              SetBaseMinimumPlayoutDelayMs,
+              (uint32_t ssrc, int delay_ms),
+              (override));
+  MOCK_METHOD(absl::optional<int>,
+              GetBaseMinimumPlayoutDelayMs,
+              (uint32_t ssrc),
+              (const, override));
 };
 
 }  // namespace webrtc
diff --git a/pc/test/mock_rtp_receiver_internal.h b/pc/test/mock_rtp_receiver_internal.h
index ffe78b5..779dcdc 100644
--- a/pc/test/mock_rtp_receiver_internal.h
+++ b/pc/test/mock_rtp_receiver_internal.h
@@ -24,37 +24,54 @@
 class MockRtpReceiverInternal : public RtpReceiverInternal {
  public:
   // RtpReceiverInterface methods.
-  MOCK_METHOD1(SetTrack, void(MediaStreamTrackInterface*));
-  MOCK_CONST_METHOD0(track, rtc::scoped_refptr<MediaStreamTrackInterface>());
-  MOCK_CONST_METHOD0(dtls_transport,
-                     rtc::scoped_refptr<DtlsTransportInterface>());
-  MOCK_CONST_METHOD0(stream_ids, std::vector<std::string>());
-  MOCK_CONST_METHOD0(streams,
-                     std::vector<rtc::scoped_refptr<MediaStreamInterface>>());
-  MOCK_CONST_METHOD0(media_type, cricket::MediaType());
-  MOCK_CONST_METHOD0(id, std::string());
-  MOCK_CONST_METHOD0(GetParameters, RtpParameters());
-  MOCK_METHOD1(SetObserver, void(RtpReceiverObserverInterface*));
-  MOCK_METHOD1(SetJitterBufferMinimumDelay, void(absl::optional<double>));
-  MOCK_CONST_METHOD0(GetSources, std::vector<RtpSource>());
-  MOCK_METHOD1(SetFrameDecryptor,
-               void(rtc::scoped_refptr<FrameDecryptorInterface>));
-  MOCK_CONST_METHOD0(GetFrameDecryptor,
-                     rtc::scoped_refptr<FrameDecryptorInterface>());
+  MOCK_METHOD(rtc::scoped_refptr<MediaStreamTrackInterface>,
+              track,
+              (),
+              (const, override));
+  MOCK_METHOD(rtc::scoped_refptr<DtlsTransportInterface>,
+              dtls_transport,
+              (),
+              (const, override));
+  MOCK_METHOD(std::vector<std::string>, stream_ids, (), (const, override));
+  MOCK_METHOD(std::vector<rtc::scoped_refptr<MediaStreamInterface>>,
+              streams,
+              (),
+              (const, override));
+  MOCK_METHOD(cricket::MediaType, media_type, (), (const, override));
+  MOCK_METHOD(std::string, id, (), (const, override));
+  MOCK_METHOD(RtpParameters, GetParameters, (), (const, override));
+  MOCK_METHOD(void, SetObserver, (RtpReceiverObserverInterface*), (override));
+  MOCK_METHOD(void,
+              SetJitterBufferMinimumDelay,
+              (absl::optional<double>),
+              (override));
+  MOCK_METHOD(std::vector<RtpSource>, GetSources, (), (const, override));
+  MOCK_METHOD(void,
+              SetFrameDecryptor,
+              (rtc::scoped_refptr<FrameDecryptorInterface>),
+              (override));
+  MOCK_METHOD(rtc::scoped_refptr<FrameDecryptorInterface>,
+              GetFrameDecryptor,
+              (),
+              (const, override));
 
   // RtpReceiverInternal methods.
-  MOCK_METHOD0(Stop, void());
-  MOCK_METHOD1(SetMediaChannel, void(cricket::MediaChannel*));
-  MOCK_METHOD1(SetupMediaChannel, void(uint32_t));
-  MOCK_METHOD0(SetupUnsignaledMediaChannel, void());
-  MOCK_CONST_METHOD0(ssrc, uint32_t());
-  MOCK_METHOD0(NotifyFirstPacketReceived, void());
-  MOCK_METHOD1(set_stream_ids, void(std::vector<std::string>));
-  MOCK_METHOD1(set_transport, void(rtc::scoped_refptr<DtlsTransportInterface>));
-  MOCK_METHOD1(
-      SetStreams,
-      void(const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&));
-  MOCK_CONST_METHOD0(AttachmentId, int());
+  MOCK_METHOD(void, Stop, (), (override));
+  MOCK_METHOD(void, SetMediaChannel, (cricket::MediaChannel*), (override));
+  MOCK_METHOD(void, SetupMediaChannel, (uint32_t), (override));
+  MOCK_METHOD(void, SetupUnsignaledMediaChannel, (), (override));
+  MOCK_METHOD(uint32_t, ssrc, (), (const, override));
+  MOCK_METHOD(void, NotifyFirstPacketReceived, (), (override));
+  MOCK_METHOD(void, set_stream_ids, (std::vector<std::string>), (override));
+  MOCK_METHOD(void,
+              set_transport,
+              (rtc::scoped_refptr<DtlsTransportInterface>),
+              (override));
+  MOCK_METHOD(void,
+              SetStreams,
+              (const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&),
+              (override));
+  MOCK_METHOD(int, AttachmentId, (), (const, override));
 };
 
 }  // namespace webrtc
diff --git a/pc/test/mock_rtp_sender_internal.h b/pc/test/mock_rtp_sender_internal.h
index 2cf0173..1a31c5d 100644
--- a/pc/test/mock_rtp_sender_internal.h
+++ b/pc/test/mock_rtp_sender_internal.h
@@ -23,37 +23,65 @@
 class MockRtpSenderInternal : public RtpSenderInternal {
  public:
   // RtpSenderInterface methods.
-  MOCK_METHOD1(SetTrack, bool(MediaStreamTrackInterface*));
-  MOCK_CONST_METHOD0(track, rtc::scoped_refptr<MediaStreamTrackInterface>());
-  MOCK_CONST_METHOD0(ssrc, uint32_t());
-  MOCK_CONST_METHOD0(dtls_transport,
-                     rtc::scoped_refptr<DtlsTransportInterface>());
-  MOCK_CONST_METHOD0(media_type, cricket::MediaType());
-  MOCK_CONST_METHOD0(id, std::string());
-  MOCK_CONST_METHOD0(stream_ids, std::vector<std::string>());
-  MOCK_CONST_METHOD0(init_send_encodings, std::vector<RtpEncodingParameters>());
-  MOCK_METHOD1(set_transport, void(rtc::scoped_refptr<DtlsTransportInterface>));
-  MOCK_CONST_METHOD0(GetParameters, RtpParameters());
-  MOCK_CONST_METHOD0(GetParametersInternal, RtpParameters());
-  MOCK_METHOD1(SetParameters, RTCError(const RtpParameters&));
-  MOCK_METHOD1(SetParametersInternal, RTCError(const RtpParameters&));
-  MOCK_CONST_METHOD0(GetDtmfSender, rtc::scoped_refptr<DtmfSenderInterface>());
-  MOCK_METHOD1(SetFrameEncryptor,
-               void(rtc::scoped_refptr<FrameEncryptorInterface>));
-  MOCK_CONST_METHOD0(GetFrameEncryptor,
-                     rtc::scoped_refptr<FrameEncryptorInterface>());
+  MOCK_METHOD(bool, SetTrack, (MediaStreamTrackInterface*), (override));
+  MOCK_METHOD(rtc::scoped_refptr<MediaStreamTrackInterface>,
+              track,
+              (),
+              (const, override));
+  MOCK_METHOD(uint32_t, ssrc, (), (const, override));
+  MOCK_METHOD(rtc::scoped_refptr<DtlsTransportInterface>,
+              dtls_transport,
+              (),
+              (const, override));
+  MOCK_METHOD(cricket::MediaType, media_type, (), (const, override));
+  MOCK_METHOD(std::string, id, (), (const, override));
+  MOCK_METHOD(std::vector<std::string>, stream_ids, (), (const, override));
+  MOCK_METHOD(std::vector<RtpEncodingParameters>,
+              init_send_encodings,
+              (),
+              (const, override));
+  MOCK_METHOD(void,
+              set_transport,
+              (rtc::scoped_refptr<DtlsTransportInterface>),
+              (override));
+  MOCK_METHOD(RtpParameters, GetParameters, (), (const, override));
+  MOCK_METHOD(RtpParameters, GetParametersInternal, (), (const, override));
+  MOCK_METHOD(RTCError, SetParameters, (const RtpParameters&), (override));
+  MOCK_METHOD(RTCError,
+              SetParametersInternal,
+              (const RtpParameters&),
+              (override));
+  MOCK_METHOD(rtc::scoped_refptr<DtmfSenderInterface>,
+              GetDtmfSender,
+              (),
+              (const, override));
+  MOCK_METHOD(void,
+              SetFrameEncryptor,
+              (rtc::scoped_refptr<FrameEncryptorInterface>),
+              (override));
+  MOCK_METHOD(rtc::scoped_refptr<FrameEncryptorInterface>,
+              GetFrameEncryptor,
+              (),
+              (const, override));
 
   // RtpSenderInternal methods.
-  MOCK_METHOD1(SetMediaChannel, void(cricket::MediaChannel*));
-  MOCK_METHOD1(SetSsrc, void(uint32_t));
-  MOCK_METHOD1(set_stream_ids, void(const std::vector<std::string>&));
-  MOCK_METHOD1(SetStreams, void(const std::vector<std::string>&));
-  MOCK_METHOD1(set_init_send_encodings,
-               void(const std::vector<RtpEncodingParameters>&));
-  MOCK_METHOD0(Stop, void());
-  MOCK_CONST_METHOD0(AttachmentId, int());
-  MOCK_METHOD1(DisableEncodingLayers,
-               RTCError(const std::vector<std::string>&));
+  MOCK_METHOD(void, SetMediaChannel, (cricket::MediaChannel*), (override));
+  MOCK_METHOD(void, SetSsrc, (uint32_t), (override));
+  MOCK_METHOD(void,
+              set_stream_ids,
+              (const std::vector<std::string>&),
+              (override));
+  MOCK_METHOD(void, SetStreams, (const std::vector<std::string>&), (override));
+  MOCK_METHOD(void,
+              set_init_send_encodings,
+              (const std::vector<RtpEncodingParameters>&),
+              (override));
+  MOCK_METHOD(void, Stop, (), (override));
+  MOCK_METHOD(int, AttachmentId, (), (const, override));
+  MOCK_METHOD(RTCError,
+              DisableEncodingLayers,
+              (const std::vector<std::string>&),
+              (override));
 };
 
 }  // namespace webrtc
diff --git a/pc/video_rtp_receiver_unittest.cc b/pc/video_rtp_receiver_unittest.cc
index c4b7b82..b3eb6e6 100644
--- a/pc/video_rtp_receiver_unittest.cc
+++ b/pc/video_rtp_receiver_unittest.cc
@@ -32,16 +32,20 @@
     MockVideoMediaChannel(cricket::FakeVideoEngine* engine,
                           const cricket::VideoOptions& options)
         : FakeVideoMediaChannel(engine, options) {}
-    MOCK_METHOD2(SetRecordableEncodedFrameCallback,
-                 void(uint32_t,
-                      std::function<void(const RecordableEncodedFrame&)>));
-    MOCK_METHOD1(ClearRecordableEncodedFrameCallback, void(uint32_t));
-    MOCK_METHOD1(GenerateKeyFrame, void(uint32_t));
+    MOCK_METHOD(void,
+                SetRecordableEncodedFrameCallback,
+                (uint32_t, std::function<void(const RecordableEncodedFrame&)>),
+                (override));
+    MOCK_METHOD(void,
+                ClearRecordableEncodedFrameCallback,
+                (uint32_t),
+                (override));
+    MOCK_METHOD(void, GenerateKeyFrame, (uint32_t), (override));
   };
 
   class MockVideoSink : public rtc::VideoSinkInterface<RecordableEncodedFrame> {
    public:
-    MOCK_METHOD1(OnFrame, void(const RecordableEncodedFrame&));
+    MOCK_METHOD(void, OnFrame, (const RecordableEncodedFrame&), (override));
   };
 
   VideoRtpReceiverTest()
diff --git a/pc/video_rtp_track_source_unittest.cc b/pc/video_rtp_track_source_unittest.cc
index ed26db3..ea1b4ca 100644
--- a/pc/video_rtp_track_source_unittest.cc
+++ b/pc/video_rtp_track_source_unittest.cc
@@ -19,13 +19,13 @@
 
 class MockCallback : public VideoRtpTrackSource::Callback {
  public:
-  MOCK_METHOD0(OnGenerateKeyFrame, void());
-  MOCK_METHOD1(OnEncodedSinkEnabled, void(bool));
+  MOCK_METHOD(void, OnGenerateKeyFrame, (), (override));
+  MOCK_METHOD(void, OnEncodedSinkEnabled, (bool), (override));
 };
 
 class MockSink : public rtc::VideoSinkInterface<RecordableEncodedFrame> {
  public:
-  MOCK_METHOD1(OnFrame, void(const RecordableEncodedFrame&));
+  MOCK_METHOD(void, OnFrame, (const RecordableEncodedFrame&), (override));
 };
 
 rtc::scoped_refptr<VideoRtpTrackSource> MakeSource(