diff --git a/p2p/base/mock_async_resolver.h b/p2p/base/mock_async_resolver.h
index 7d3be5b..8bc0eb9 100644
--- a/p2p/base/mock_async_resolver.h
+++ b/p2p/base/mock_async_resolver.h
@@ -29,14 +29,17 @@
   }
   ~MockAsyncResolver() = default;
 
-  MOCK_METHOD1(Start, void(const rtc::SocketAddress&));
-  MOCK_CONST_METHOD2(GetResolvedAddress, bool(int family, SocketAddress* addr));
-  MOCK_CONST_METHOD0(GetError, int());
+  MOCK_METHOD(void, Start, (const rtc::SocketAddress&), (override));
+  MOCK_METHOD(bool,
+              GetResolvedAddress,
+              (int family, SocketAddress* addr),
+              (const, override));
+  MOCK_METHOD(int, GetError, (), (const, override));
 
   // Note that this won't delete the object like AsyncResolverInterface says in
   // order to avoid sanitizer failures caused by this being a synchronous
   // implementation. The test code should delete the object instead.
-  MOCK_METHOD1(Destroy, void(bool));
+  MOCK_METHOD(void, Destroy, (bool), (override));
 };
 
 }  // namespace rtc
@@ -45,7 +48,7 @@
 
 class MockAsyncResolverFactory : public AsyncResolverFactory {
  public:
-  MOCK_METHOD0(Create, rtc::AsyncResolverInterface*());
+  MOCK_METHOD(rtc::AsyncResolverInterface*, Create, (), (override));
 };
 
 }  // namespace webrtc
diff --git a/p2p/base/mock_ice_transport.h b/p2p/base/mock_ice_transport.h
index 1436cac..ef9f1b1 100644
--- a/p2p/base/mock_ice_transport.h
+++ b/p2p/base/mock_ice_transport.h
@@ -32,15 +32,20 @@
     SignalWritableState(this);
   }
 
-  MOCK_METHOD4(SendPacket,
-               int(const char* data,
-                   size_t len,
-                   const rtc::PacketOptions& options,
-                   int flags));
-  MOCK_METHOD2(SetOption, int(rtc::Socket::Option opt, int value));
-  MOCK_METHOD0(GetError, int());
-  MOCK_CONST_METHOD0(GetIceRole, cricket::IceRole());
-  MOCK_METHOD1(GetStats, bool(cricket::IceTransportStats* ice_transport_stats));
+  MOCK_METHOD(int,
+              SendPacket,
+              (const char* data,
+               size_t len,
+               const rtc::PacketOptions& options,
+               int flags),
+              (override));
+  MOCK_METHOD(int, SetOption, (rtc::Socket::Option opt, int value), (override));
+  MOCK_METHOD(int, GetError, (), (override));
+  MOCK_METHOD(cricket::IceRole, GetIceRole, (), (const, override));
+  MOCK_METHOD(bool,
+              GetStats,
+              (cricket::IceTransportStats * ice_transport_stats),
+              (override));
 
   IceTransportState GetState() const override {
     return IceTransportState::STATE_INIT;
diff --git a/p2p/base/p2p_transport_channel_unittest.cc b/p2p/base/p2p_transport_channel_unittest.cc
index ce78335..f0d5d66 100644
--- a/p2p/base/p2p_transport_channel_unittest.cc
+++ b/p2p/base/p2p_transport_channel_unittest.cc
@@ -177,14 +177,14 @@
 
 class MockIceControllerFactory : public cricket::IceControllerFactoryInterface {
  public:
-  ~MockIceControllerFactory() = default;
+  ~MockIceControllerFactory() override = default;
   std::unique_ptr<cricket::IceControllerInterface> Create(
-      const cricket::IceControllerFactoryArgs& args) {
+      const cricket::IceControllerFactoryArgs& args) override {
     RecordIceControllerCreated();
     return std::make_unique<cricket::BasicIceController>(args);
   }
 
-  MOCK_METHOD0(RecordIceControllerCreated, void());
+  MOCK_METHOD(void, RecordIceControllerCreated, ());
 };
 
 }  // namespace
@@ -5255,10 +5255,14 @@
 
 class MockMdnsResponder : public webrtc::MdnsResponderInterface {
  public:
-  MOCK_METHOD2(CreateNameForAddress,
-               void(const rtc::IPAddress&, NameCreatedCallback));
-  MOCK_METHOD2(RemoveNameForAddress,
-               void(const rtc::IPAddress&, NameRemovedCallback));
+  MOCK_METHOD(void,
+              CreateNameForAddress,
+              (const rtc::IPAddress&, NameCreatedCallback),
+              (override));
+  MOCK_METHOD(void,
+              RemoveNameForAddress,
+              (const rtc::IPAddress&, NameRemovedCallback),
+              (override));
 };
 
 TEST_F(P2PTransportChannelTest,
diff --git a/p2p/base/stun_port_unittest.cc b/p2p/base/stun_port_unittest.cc
index dfc7236..2804ac0 100644
--- a/p2p/base/stun_port_unittest.cc
+++ b/p2p/base/stun_port_unittest.cc
@@ -412,24 +412,29 @@
  public:
   ~MockAsyncPacketSocket() = default;
 
-  MOCK_CONST_METHOD0(GetLocalAddress, SocketAddress());
-  MOCK_CONST_METHOD0(GetRemoteAddress, SocketAddress());
-  MOCK_METHOD3(Send,
-               int(const void* pv,
-                   size_t cb,
-                   const rtc::PacketOptions& options));
+  MOCK_METHOD(SocketAddress, GetLocalAddress, (), (const, override));
+  MOCK_METHOD(SocketAddress, GetRemoteAddress, (), (const, override));
+  MOCK_METHOD(int,
+              Send,
+              (const void* pv, size_t cb, const rtc::PacketOptions& options),
+              (override));
 
-  MOCK_METHOD4(SendTo,
-               int(const void* pv,
-                   size_t cb,
-                   const SocketAddress& addr,
-                   const rtc::PacketOptions& options));
-  MOCK_METHOD0(Close, int());
-  MOCK_CONST_METHOD0(GetState, State());
-  MOCK_METHOD2(GetOption, int(rtc::Socket::Option opt, int* value));
-  MOCK_METHOD2(SetOption, int(rtc::Socket::Option opt, int value));
-  MOCK_CONST_METHOD0(GetError, int());
-  MOCK_METHOD1(SetError, void(int error));
+  MOCK_METHOD(int,
+              SendTo,
+              (const void* pv,
+               size_t cb,
+               const SocketAddress& addr,
+               const rtc::PacketOptions& options),
+              (override));
+  MOCK_METHOD(int, Close, (), (override));
+  MOCK_METHOD(State, GetState, (), (const, override));
+  MOCK_METHOD(int,
+              GetOption,
+              (rtc::Socket::Option opt, int* value),
+              (override));
+  MOCK_METHOD(int, SetOption, (rtc::Socket::Option opt, int value), (override));
+  MOCK_METHOD(int, GetError, (), (const, override));
+  MOCK_METHOD(void, SetError, (int error), (override));
 };
 
 // Test that outbound packets inherit the dscp value assigned to the socket.