diff --git a/quic/core/http/http_decoder_test.cc b/quic/core/http/http_decoder_test.cc
index 2e8885c..27f0990 100644
--- a/quic/core/http/http_decoder_test.cc
+++ b/quic/core/http/http_decoder_test.cc
@@ -39,42 +39,79 @@
   ~MockVisitor() override = default;
 
   // Called if an error is detected.
-  MOCK_METHOD1(OnError, void(HttpDecoder* decoder));
+  MOCK_METHOD(void, OnError, (HttpDecoder*), (override));
 
-  MOCK_METHOD1(OnCancelPushFrame, bool(const CancelPushFrame& frame));
-  MOCK_METHOD1(OnMaxPushIdFrame, bool(const MaxPushIdFrame& frame));
-  MOCK_METHOD1(OnGoAwayFrame, bool(const GoAwayFrame& frame));
-  MOCK_METHOD1(OnSettingsFrameStart, bool(QuicByteCount header_length));
-  MOCK_METHOD1(OnSettingsFrame, bool(const SettingsFrame& frame));
+  MOCK_METHOD(bool,
+              OnCancelPushFrame,
+              (const CancelPushFrame& frame),
+              (override));
+  MOCK_METHOD(bool,
+              OnMaxPushIdFrame,
+              (const MaxPushIdFrame& frame),
+              (override));
+  MOCK_METHOD(bool, OnGoAwayFrame, (const GoAwayFrame& frame), (override));
+  MOCK_METHOD(bool,
+              OnSettingsFrameStart,
+              (QuicByteCount header_length),
+              (override));
+  MOCK_METHOD(bool, OnSettingsFrame, (const SettingsFrame& frame), (override));
 
-  MOCK_METHOD2(OnDataFrameStart,
-               bool(QuicByteCount header_length, QuicByteCount payload_length));
-  MOCK_METHOD1(OnDataFramePayload, bool(quiche::QuicheStringPiece payload));
-  MOCK_METHOD0(OnDataFrameEnd, bool());
+  MOCK_METHOD(bool,
+              OnDataFrameStart,
+              (QuicByteCount header_length, QuicByteCount payload_length),
+              (override));
+  MOCK_METHOD(bool,
+              OnDataFramePayload,
+              (quiche::QuicheStringPiece payload),
+              (override));
+  MOCK_METHOD(bool, OnDataFrameEnd, (), (override));
 
-  MOCK_METHOD2(OnHeadersFrameStart,
-               bool(QuicByteCount header_length, QuicByteCount payload_length));
-  MOCK_METHOD1(OnHeadersFramePayload, bool(quiche::QuicheStringPiece payload));
-  MOCK_METHOD0(OnHeadersFrameEnd, bool());
+  MOCK_METHOD(bool,
+              OnHeadersFrameStart,
+              (QuicByteCount header_length, QuicByteCount payload_length),
+              (override));
+  MOCK_METHOD(bool,
+              OnHeadersFramePayload,
+              (quiche::QuicheStringPiece payload),
+              (override));
+  MOCK_METHOD(bool, OnHeadersFrameEnd, (), (override));
 
-  MOCK_METHOD1(OnPushPromiseFrameStart, bool(QuicByteCount header_length));
-  MOCK_METHOD3(OnPushPromiseFramePushId,
-               bool(PushId push_id,
-                    QuicByteCount push_id_length,
-                    QuicByteCount header_block_length));
-  MOCK_METHOD1(OnPushPromiseFramePayload,
-               bool(quiche::QuicheStringPiece payload));
-  MOCK_METHOD0(OnPushPromiseFrameEnd, bool());
+  MOCK_METHOD(bool,
+              OnPushPromiseFrameStart,
+              (QuicByteCount header_length),
+              (override));
+  MOCK_METHOD(bool,
+              OnPushPromiseFramePushId,
+              (PushId push_id,
+               QuicByteCount push_id_length,
+               QuicByteCount header_block_length),
+              (override));
+  MOCK_METHOD(bool,
+              OnPushPromiseFramePayload,
+              (quiche::QuicheStringPiece payload),
+              (override));
+  MOCK_METHOD(bool, OnPushPromiseFrameEnd, (), (override));
 
-  MOCK_METHOD1(OnPriorityUpdateFrameStart, bool(QuicByteCount header_length));
-  MOCK_METHOD1(OnPriorityUpdateFrame, bool(const PriorityUpdateFrame& frame));
+  MOCK_METHOD(bool,
+              OnPriorityUpdateFrameStart,
+              (QuicByteCount header_length),
+              (override));
+  MOCK_METHOD(bool,
+              OnPriorityUpdateFrame,
+              (const PriorityUpdateFrame& frame),
+              (override));
 
-  MOCK_METHOD3(OnUnknownFrameStart,
-               bool(uint64_t frame_type,
-                    QuicByteCount header_length,
-                    QuicByteCount payload_length));
-  MOCK_METHOD1(OnUnknownFramePayload, bool(quiche::QuicheStringPiece payload));
-  MOCK_METHOD0(OnUnknownFrameEnd, bool());
+  MOCK_METHOD(bool,
+              OnUnknownFrameStart,
+              (uint64_t frame_type,
+               QuicByteCount header_length,
+               QuicByteCount payload_length),
+              (override));
+  MOCK_METHOD(bool,
+              OnUnknownFramePayload,
+              (quiche::QuicheStringPiece payload),
+              (override));
+  MOCK_METHOD(bool, OnUnknownFrameEnd, (), (override));
 };
 
 class HttpDecoderTest : public QuicTest {
diff --git a/quic/core/http/quic_client_promised_info_test.cc b/quic/core/http/quic_client_promised_info_test.cc
index 381160b..a599626 100644
--- a/quic/core/http/quic_client_promised_info_test.cc
+++ b/quic/core/http/quic_client_promised_info_test.cc
@@ -52,7 +52,7 @@
 
   void set_authorized(bool authorized) { authorized_ = authorized; }
 
-  MOCK_METHOD1(CloseStream, void(QuicStreamId stream_id));
+  MOCK_METHOD(void, CloseStream, (QuicStreamId stream_id), (override));
 
  private:
   QuicCryptoClientConfig crypto_config_;
diff --git a/quic/core/http/quic_client_push_promise_index_test.cc b/quic/core/http/quic_client_push_promise_index_test.cc
index 3ca377e..0fc903a 100644
--- a/quic/core/http/quic_client_push_promise_index_test.cc
+++ b/quic/core/http/quic_client_push_promise_index_test.cc
@@ -40,7 +40,7 @@
       delete;
   ~MockQuicSpdyClientSession() override {}
 
-  MOCK_METHOD1(CloseStream, void(QuicStreamId stream_id));
+  MOCK_METHOD(void, CloseStream, (QuicStreamId stream_id), (override));
 
  private:
   QuicCryptoClientConfig crypto_config_;
diff --git a/quic/core/http/quic_headers_stream_test.cc b/quic/core/http/quic_headers_stream_test.cc
index 6f92345..d9e1c8e 100644
--- a/quic/core/http/quic_headers_stream_test.cc
+++ b/quic/core/http/quic_headers_stream_test.cc
@@ -78,66 +78,90 @@
   MockQuicHpackDebugVisitor& operator=(const MockQuicHpackDebugVisitor&) =
       delete;
 
-  MOCK_METHOD1(OnUseEntry, void(QuicTime::Delta elapsed));
+  MOCK_METHOD(void, OnUseEntry, (QuicTime::Delta elapsed), (override));
 };
 
 namespace {
 
 class MockVisitor : public SpdyFramerVisitorInterface {
  public:
-  MOCK_METHOD1(OnError,
-               void(http2::Http2DecoderAdapter::SpdyFramerError error));
-  MOCK_METHOD3(OnDataFrameHeader,
-               void(SpdyStreamId stream_id, size_t length, bool fin));
-  MOCK_METHOD3(OnStreamFrameData,
-               void(SpdyStreamId stream_id, const char* data, size_t len));
-  MOCK_METHOD1(OnStreamEnd, void(SpdyStreamId stream_id));
-  MOCK_METHOD2(OnStreamPadding, void(SpdyStreamId stream_id, size_t len));
-  MOCK_METHOD1(OnHeaderFrameStart,
-               SpdyHeadersHandlerInterface*(SpdyStreamId stream_id));
-  MOCK_METHOD1(OnHeaderFrameEnd, void(SpdyStreamId stream_id));
-  MOCK_METHOD3(OnControlFrameHeaderData,
-               bool(SpdyStreamId stream_id,
-                    const char* header_data,
-                    size_t len));
-  MOCK_METHOD2(OnRstStream,
-               void(SpdyStreamId stream_id, SpdyErrorCode error_code));
-  MOCK_METHOD0(OnSettings, void());
-  MOCK_METHOD2(OnSetting, void(SpdySettingsId id, uint32_t value));
-  MOCK_METHOD0(OnSettingsAck, void());
-  MOCK_METHOD0(OnSettingsEnd, void());
-  MOCK_METHOD2(OnPing, void(SpdyPingId unique_id, bool is_ack));
-  MOCK_METHOD2(OnGoAway,
-               void(SpdyStreamId last_accepted_stream_id,
-                    SpdyErrorCode error_code));
-  MOCK_METHOD7(OnHeaders,
-               void(SpdyStreamId stream_id,
-                    bool has_priority,
-                    int weight,
-                    SpdyStreamId parent_stream_id,
-                    bool exclusive,
-                    bool fin,
-                    bool end));
-  MOCK_METHOD2(OnWindowUpdate,
-               void(SpdyStreamId stream_id, int delta_window_size));
-  MOCK_METHOD1(OnBlocked, void(SpdyStreamId stream_id));
-  MOCK_METHOD3(OnPushPromise,
-               void(SpdyStreamId stream_id,
-                    SpdyStreamId promised_stream_id,
-                    bool end));
-  MOCK_METHOD2(OnContinuation, void(SpdyStreamId stream_id, bool end));
-  MOCK_METHOD3(OnAltSvc,
-               void(SpdyStreamId stream_id,
-                    quiche::QuicheStringPiece origin,
-                    const SpdyAltSvcWireFormat::AlternativeServiceVector&
-                        altsvc_vector));
-  MOCK_METHOD4(OnPriority,
-               void(SpdyStreamId stream_id,
-                    SpdyStreamId parent_stream_id,
-                    int weight,
-                    bool exclusive));
-  MOCK_METHOD2(OnUnknownFrame,
-               bool(SpdyStreamId stream_id, uint8_t frame_type));
+  MOCK_METHOD(void,
+              OnError,
+              (http2::Http2DecoderAdapter::SpdyFramerError error),
+              (override));
+  MOCK_METHOD(void,
+              OnDataFrameHeader,
+              (SpdyStreamId stream_id, size_t length, bool fin),
+              (override));
+  MOCK_METHOD(void,
+              OnStreamFrameData,
+              (SpdyStreamId stream_id, const char*, size_t len),
+              (override));
+  MOCK_METHOD(void, OnStreamEnd, (SpdyStreamId stream_id), (override));
+  MOCK_METHOD(void,
+              OnStreamPadding,
+              (SpdyStreamId stream_id, size_t len),
+              (override));
+  MOCK_METHOD(SpdyHeadersHandlerInterface*,
+              OnHeaderFrameStart,
+              (SpdyStreamId stream_id),
+              (override));
+  MOCK_METHOD(void, OnHeaderFrameEnd, (SpdyStreamId stream_id), (override));
+  MOCK_METHOD(void,
+              OnRstStream,
+              (SpdyStreamId stream_id, SpdyErrorCode error_code),
+              (override));
+  MOCK_METHOD(void, OnSettings, (), (override));
+  MOCK_METHOD(void, OnSetting, (SpdySettingsId id, uint32_t value), (override));
+  MOCK_METHOD(void, OnSettingsAck, (), (override));
+  MOCK_METHOD(void, OnSettingsEnd, (), (override));
+  MOCK_METHOD(void, OnPing, (SpdyPingId unique_id, bool is_ack), (override));
+  MOCK_METHOD(void,
+              OnGoAway,
+              (SpdyStreamId last_accepted_stream_id, SpdyErrorCode error_code),
+              (override));
+  MOCK_METHOD(void,
+              OnHeaders,
+              (SpdyStreamId stream_id,
+               bool has_priority,
+               int weight,
+               SpdyStreamId parent_stream_id,
+               bool exclusive,
+               bool fin,
+               bool end),
+              (override));
+  MOCK_METHOD(void,
+              OnWindowUpdate,
+              (SpdyStreamId stream_id, int delta_window_size),
+              (override));
+  MOCK_METHOD(void,
+              OnPushPromise,
+              (SpdyStreamId stream_id,
+               SpdyStreamId promised_stream_id,
+               bool end),
+              (override));
+  MOCK_METHOD(void,
+              OnContinuation,
+              (SpdyStreamId stream_id, bool end),
+              (override));
+  MOCK_METHOD(
+      void,
+      OnAltSvc,
+      (SpdyStreamId stream_id,
+       quiche::QuicheStringPiece origin,
+       const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector),
+      (override));
+  MOCK_METHOD(void,
+              OnPriority,
+              (SpdyStreamId stream_id,
+               SpdyStreamId parent_stream_id,
+               int weight,
+               bool exclusive),
+              (override));
+  MOCK_METHOD(bool,
+              OnUnknownFrame,
+              (SpdyStreamId stream_id, uint8_t frame_type),
+              (override));
 };
 
 struct TestParams {
diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index 51b981f..c482856 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -475,8 +475,10 @@
       delete;
   ~MockQuicCryptoServerStream() override {}
 
-  MOCK_METHOD1(SendServerConfigUpdate,
-               void(const CachedNetworkParameters* cached_network_parameters));
+  MOCK_METHOD(void,
+              SendServerConfigUpdate,
+              (const CachedNetworkParameters*),
+              (override));
 };
 
 class MockTlsServerHandshaker : public TlsServerHandshaker {
@@ -488,8 +490,10 @@
   MockTlsServerHandshaker& operator=(const MockTlsServerHandshaker&) = delete;
   ~MockTlsServerHandshaker() override {}
 
-  MOCK_METHOD1(SendServerConfigUpdate,
-               void(const CachedNetworkParameters* cached_network_parameters));
+  MOCK_METHOD(void,
+              SendServerConfigUpdate,
+              (const CachedNetworkParameters*),
+              (override));
 };
 
 TEST_P(QuicServerSessionBaseTest, BandwidthEstimates) {
diff --git a/quic/core/http/quic_spdy_client_stream_test.cc b/quic/core/http/quic_spdy_client_stream_test.cc
index 50224cb..fdc0e29 100644
--- a/quic/core/http/quic_spdy_client_stream_test.cc
+++ b/quic/core/http/quic_spdy_client_stream_test.cc
@@ -46,7 +46,7 @@
       delete;
   ~MockQuicSpdyClientSession() override = default;
 
-  MOCK_METHOD1(CloseStream, void(QuicStreamId stream_id));
+  MOCK_METHOD(void, CloseStream, (QuicStreamId stream_id), (override));
 
  private:
   QuicCryptoClientConfig crypto_config_;
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 705d45c..dceccd9 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -139,11 +139,11 @@
   void OnOneRttPacketAcknowledged() override {}
   void OnHandshakeDoneReceived() override {}
 
-  MOCK_METHOD0(OnCanWrite, void());
+  MOCK_METHOD(void, OnCanWrite, (), (override));
 
   bool HasPendingCryptoRetransmission() const override { return false; }
 
-  MOCK_CONST_METHOD0(HasPendingRetransmission, bool());
+  MOCK_METHOD(bool, HasPendingRetransmission, (), (const, override));
 
  private:
   using QuicCryptoStream::session;
@@ -158,7 +158,7 @@
   explicit TestHeadersStream(QuicSpdySession* session)
       : QuicHeadersStream(session) {}
 
-  MOCK_METHOD0(OnCanWrite, void());
+  MOCK_METHOD(void, OnCanWrite, (), (override));
 };
 
 class TestStream : public QuicSpdyStream {
@@ -173,11 +173,13 @@
 
   void OnBodyAvailable() override {}
 
-  MOCK_METHOD0(OnCanWrite, void());
-  MOCK_METHOD4(RetransmitStreamData,
-               bool(QuicStreamOffset, QuicByteCount, bool, TransmissionType));
+  MOCK_METHOD(void, OnCanWrite, (), (override));
+  MOCK_METHOD(bool,
+              RetransmitStreamData,
+              (QuicStreamOffset, QuicByteCount, bool, TransmissionType),
+              (override));
 
-  MOCK_CONST_METHOD0(HasPendingRetransmission, bool());
+  MOCK_METHOD(bool, HasPendingRetransmission, (), (const, override));
 };
 
 class TestSession : public QuicSpdySession {
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index 9db9f22..6d708d4 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -124,11 +124,11 @@
   void OnOneRttPacketAcknowledged() override {}
   void OnHandshakeDoneReceived() override {}
 
-  MOCK_METHOD0(OnCanWrite, void());
+  MOCK_METHOD(void, OnCanWrite, (), (override));
 
   bool HasPendingCryptoRetransmission() const override { return false; }
 
-  MOCK_CONST_METHOD0(HasPendingRetransmission, bool());
+  MOCK_METHOD(bool, HasPendingRetransmission, (), (const, override));
 
  private:
   using QuicCryptoStream::session;
@@ -164,7 +164,7 @@
     data_ += std::string(buffer, bytes_read);
   }
 
-  MOCK_METHOD1(WriteHeadersMock, void(bool fin));
+  MOCK_METHOD(void, WriteHeadersMock, (bool fin), ());
 
   size_t WriteHeadersImpl(spdy::SpdyHeaderBlock header_block,
                           bool fin,
@@ -899,6 +899,7 @@
   }
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
       .WillOnce(Return(QuicConsumedData(kWindow - kHeaderLength, true)));
+  EXPECT_CALL(*session_, SendBlocked(_));
   EXPECT_CALL(*connection_, SendControlFrame(_));
   stream_->WriteOrBufferBody(body, false);
 
@@ -918,7 +919,7 @@
   Initialize(!kShouldProcessData);
 
   // Expect no WINDOW_UPDATE frames to be sent.
-  EXPECT_CALL(*connection_, SendWindowUpdate(_, _)).Times(0);
+  EXPECT_CALL(*session_, SendWindowUpdate(_, _)).Times(0);
 
   // Set a small flow control receive window.
   const uint64_t kWindow = 36;
@@ -1012,6 +1013,7 @@
   QuicStreamFrame frame2(GetNthClientInitiatedBidirectionalId(0), false,
                          kWindow / 3 + header_length,
                          quiche::QuicheStringPiece(data));
+  EXPECT_CALL(*session_, SendWindowUpdate(_, _));
   EXPECT_CALL(*connection_, SendControlFrame(_));
   stream_->OnStreamFrame(frame2);
   EXPECT_EQ(kWindow, QuicFlowControllerPeer::ReceiveWindowSize(
@@ -1084,6 +1086,7 @@
   // Now receive a further single byte on one stream - again this does not
   // trigger a stream WINDOW_UPDATE, but now the connection flow control window
   // is over half full and thus a connection WINDOW_UPDATE is sent.
+  EXPECT_CALL(*session_, SendWindowUpdate(_, _));
   EXPECT_CALL(*connection_, SendControlFrame(_));
   QuicStreamFrame frame3(GetNthClientInitiatedBidirectionalId(0), false,
                          body.length() + header_length,
@@ -1170,8 +1173,7 @@
   std::string body = "";
   bool fin = true;
 
-  EXPECT_CALL(*connection_,
-              SendBlocked(GetNthClientInitiatedBidirectionalId(0)))
+  EXPECT_CALL(*session_, SendBlocked(GetNthClientInitiatedBidirectionalId(0)))
       .Times(0);
   EXPECT_CALL(*session_, WritevData(_, 0, _, FIN, _, _));
 
diff --git a/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc b/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
index c98f854..93e2561 100644
--- a/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
+++ b/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
@@ -42,11 +42,14 @@
 class MockVisitor : public QpackDecodedHeadersAccumulator::Visitor {
  public:
   ~MockVisitor() override = default;
-  MOCK_METHOD2(OnHeadersDecoded,
-               void(QuicHeaderList headers,
-                    bool header_list_size_limit_exceeded));
-  MOCK_METHOD1(OnHeaderDecodingError,
-               void(quiche::QuicheStringPiece error_message));
+  MOCK_METHOD(void,
+              OnHeadersDecoded,
+              (QuicHeaderList headers, bool header_list_size_limit_exceeded),
+              (override));
+  MOCK_METHOD(void,
+              OnHeaderDecodingError,
+              (quiche::QuicheStringPiece error_message),
+              (override));
 };
 
 }  // anonymous namespace
diff --git a/quic/core/qpack/qpack_decoder_stream_receiver_test.cc b/quic/core/qpack/qpack_decoder_stream_receiver_test.cc
index 44a2286..70d2450 100644
--- a/quic/core/qpack/qpack_decoder_stream_receiver_test.cc
+++ b/quic/core/qpack/qpack_decoder_stream_receiver_test.cc
@@ -19,10 +19,16 @@
  public:
   ~MockDelegate() override = default;
 
-  MOCK_METHOD1(OnInsertCountIncrement, void(uint64_t increment));
-  MOCK_METHOD1(OnHeaderAcknowledgement, void(QuicStreamId stream_id));
-  MOCK_METHOD1(OnStreamCancellation, void(QuicStreamId stream_id));
-  MOCK_METHOD1(OnErrorDetected, void(quiche::QuicheStringPiece error_message));
+  MOCK_METHOD(void, OnInsertCountIncrement, (uint64_t increment), (override));
+  MOCK_METHOD(void,
+              OnHeaderAcknowledgement,
+              (QuicStreamId stream_id),
+              (override));
+  MOCK_METHOD(void, OnStreamCancellation, (QuicStreamId stream_id), (override));
+  MOCK_METHOD(void,
+              OnErrorDetected,
+              (quiche::QuicheStringPiece error_message),
+              (override));
 };
 
 class QpackDecoderStreamReceiverTest : public QuicTest {
diff --git a/quic/core/qpack/qpack_encoder_stream_receiver_test.cc b/quic/core/qpack/qpack_encoder_stream_receiver_test.cc
index b5edd5f..71b6d34 100644
--- a/quic/core/qpack/qpack_encoder_stream_receiver_test.cc
+++ b/quic/core/qpack/qpack_encoder_stream_receiver_test.cc
@@ -19,16 +19,22 @@
  public:
   ~MockDelegate() override = default;
 
-  MOCK_METHOD3(OnInsertWithNameReference,
-               void(bool is_static,
-                    uint64_t name_index,
-                    quiche::QuicheStringPiece value));
-  MOCK_METHOD2(OnInsertWithoutNameReference,
-               void(quiche::QuicheStringPiece name,
-                    quiche::QuicheStringPiece value));
-  MOCK_METHOD1(OnDuplicate, void(uint64_t index));
-  MOCK_METHOD1(OnSetDynamicTableCapacity, void(uint64_t capacity));
-  MOCK_METHOD1(OnErrorDetected, void(quiche::QuicheStringPiece error_message));
+  MOCK_METHOD(void,
+              OnInsertWithNameReference,
+              (bool is_static,
+               uint64_t name_index,
+               quiche::QuicheStringPiece value),
+              (override));
+  MOCK_METHOD(void,
+              OnInsertWithoutNameReference,
+              (quiche::QuicheStringPiece name, quiche::QuicheStringPiece value),
+              (override));
+  MOCK_METHOD(void, OnDuplicate, (uint64_t index), (override));
+  MOCK_METHOD(void, OnSetDynamicTableCapacity, (uint64_t capacity), (override));
+  MOCK_METHOD(void,
+              OnErrorDetected,
+              (quiche::QuicheStringPiece error_message),
+              (override));
 };
 
 class QpackEncoderStreamReceiverTest : public QuicTest {
diff --git a/quic/core/qpack/qpack_header_table_test.cc b/quic/core/qpack/qpack_header_table_test.cc
index 5cf3920..a96159b 100644
--- a/quic/core/qpack/qpack_header_table_test.cc
+++ b/quic/core/qpack/qpack_header_table_test.cc
@@ -25,8 +25,8 @@
  public:
   ~MockObserver() override = default;
 
-  MOCK_METHOD0(OnInsertCountReachedThreshold, void());
-  MOCK_METHOD0(Cancel, void());
+  MOCK_METHOD(void, OnInsertCountReachedThreshold, (), (override));
+  MOCK_METHOD(void, Cancel, (), (override));
 };
 
 class QpackHeaderTableTest : public QuicTest {
diff --git a/quic/core/qpack/qpack_instruction_decoder_test.cc b/quic/core/qpack/qpack_instruction_decoder_test.cc
index 99cda08..a4bbc91 100644
--- a/quic/core/qpack/qpack_instruction_decoder_test.cc
+++ b/quic/core/qpack/qpack_instruction_decoder_test.cc
@@ -61,8 +61,14 @@
   MockDelegate& operator=(const MockDelegate&) = delete;
   ~MockDelegate() override = default;
 
-  MOCK_METHOD1(OnInstructionDecoded, bool(const QpackInstruction* instruction));
-  MOCK_METHOD1(OnError, void(quiche::QuicheStringPiece error_message));
+  MOCK_METHOD(bool,
+              OnInstructionDecoded,
+              (const QpackInstruction*),
+              (override));
+  MOCK_METHOD(void,
+              OnError,
+              (quiche::QuicheStringPiece error_message),
+              (override));
 };
 
 class QpackInstructionDecoderTest : public QuicTestWithParam<FragmentMode> {
diff --git a/quic/core/quic_alarm_test.cc b/quic/core/quic_alarm_test.cc
index b2f4690..87cbd69 100644
--- a/quic/core/quic_alarm_test.cc
+++ b/quic/core/quic_alarm_test.cc
@@ -14,7 +14,7 @@
 
 class MockDelegate : public QuicAlarm::Delegate {
  public:
-  MOCK_METHOD0(OnAlarm, void());
+  MOCK_METHOD(void, OnAlarm, (), (override));
 };
 
 class DestructiveDelegate : public QuicAlarm::Delegate {
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 0de52b4..4ad005d 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -1094,8 +1094,6 @@
         .WillRepeatedly(Return(kDefaultTCPMSS));
     EXPECT_CALL(*send_algorithm_, PacingRate(_))
         .WillRepeatedly(Return(QuicBandwidth::Zero()));
-    EXPECT_CALL(*send_algorithm_, HasReliableBandwidthEstimate())
-        .Times(AnyNumber());
     EXPECT_CALL(*send_algorithm_, BandwidthEstimate())
         .Times(AnyNumber())
         .WillRepeatedly(Return(QuicBandwidth::Zero()));
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index fde97c9..814462e 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -80,13 +80,27 @@
 
   ~TestQuicSpdyServerSession() override { DeleteConnection(); }
 
-  MOCK_METHOD2(OnConnectionClosed,
-               void(const QuicConnectionCloseFrame& frame,
-                    ConnectionCloseSource source));
-  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id));
-  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream* pending));
-  MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicSpdyStream*());
-  MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicSpdyStream*());
+  MOCK_METHOD(void,
+              OnConnectionClosed,
+              (const QuicConnectionCloseFrame& frame,
+               ConnectionCloseSource source),
+              (override));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateIncomingStream,
+              (QuicStreamId id),
+              (override));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateIncomingStream,
+              (PendingStream*),
+              (override));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateOutgoingBidirectionalStream,
+              (),
+              (override));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateOutgoingUnidirectionalStream,
+              (),
+              (override));
 
   std::unique_ptr<QuicCryptoServerStreamBase> CreateQuicCryptoServerStream(
       const QuicCryptoServerConfig* crypto_config,
@@ -116,15 +130,18 @@
                        kQuicDefaultConnectionIdLength),
         random_(random) {}
 
-  MOCK_METHOD4(
-      CreateQuicSession,
-      std::unique_ptr<QuicSession>(QuicConnectionId connection_id,
-                                   const QuicSocketAddress& peer_address,
-                                   quiche::QuicheStringPiece alpn,
-                                   const quic::ParsedQuicVersion& version));
+  MOCK_METHOD(std::unique_ptr<QuicSession>,
+              CreateQuicSession,
+              (QuicConnectionId connection_id,
+               const QuicSocketAddress& peer_address,
+               quiche::QuicheStringPiece alpn,
+               const quic::ParsedQuicVersion& version),
+              (override));
 
-  MOCK_METHOD1(ShouldCreateOrBufferPacketForConnection,
-               bool(const ReceivedPacketInfo& packet_info));
+  MOCK_METHOD(bool,
+              ShouldCreateOrBufferPacketForConnection,
+              (const ReceivedPacketInfo& packet_info),
+              (override));
 
   struct TestQuicPerPacketContext : public QuicPerPacketContext {
     std::string custom_packet_context;
diff --git a/quic/core/quic_flow_controller_test.cc b/quic/core/quic_flow_controller_test.cc
index 8f4cdf7..29a9ba3 100644
--- a/quic/core/quic_flow_controller_test.cc
+++ b/quic/core/quic_flow_controller_test.cc
@@ -31,7 +31,7 @@
   MockFlowController& operator=(const MockFlowController&) = delete;
   ~MockFlowController() override {}
 
-  MOCK_METHOD1(EnsureWindowAtLeast, void(QuicByteCount));
+  MOCK_METHOD(void, EnsureWindowAtLeast, (QuicByteCount), (override));
 };
 
 class QuicFlowControllerTest : public QuicTest {
diff --git a/quic/core/quic_idle_network_detector_test.cc b/quic/core/quic_idle_network_detector_test.cc
index 16941ef..0d40d64 100644
--- a/quic/core/quic_idle_network_detector_test.cc
+++ b/quic/core/quic_idle_network_detector_test.cc
@@ -22,8 +22,8 @@
 
 class MockDelegate : public QuicIdleNetworkDetector::Delegate {
  public:
-  MOCK_METHOD0(OnHandshakeTimeout, void());
-  MOCK_METHOD0(OnIdleNetworkDetected, void());
+  MOCK_METHOD(void, OnHandshakeTimeout, (), (override));
+  MOCK_METHOD(void, OnIdleNetworkDetected, (), (override));
 };
 
 class QuicIdleNetworkDetectorTest : public QuicTest {
diff --git a/quic/core/quic_network_blackhole_detector_test.cc b/quic/core/quic_network_blackhole_detector_test.cc
index eca50e3..0178887 100644
--- a/quic/core/quic_network_blackhole_detector_test.cc
+++ b/quic/core/quic_network_blackhole_detector_test.cc
@@ -21,8 +21,8 @@
 namespace {
 class MockDelegate : public QuicNetworkBlackholeDetector::Delegate {
  public:
-  MOCK_METHOD0(OnPathDegradingDetected, void());
-  MOCK_METHOD0(OnBlackholeDetected, void());
+  MOCK_METHOD(void, OnPathDegradingDetected, (), (override));
+  MOCK_METHOD(void, OnBlackholeDetected, (), (override));
 };
 
 const size_t kPathDegradingDelayInSeconds = 5;
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index 98e86c3..19fc5cb 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -86,9 +86,12 @@
  public:
   ~MockDebugDelegate() override = default;
 
-  MOCK_METHOD1(OnFrameAddedToPacket, void(const QuicFrame& frame));
+  MOCK_METHOD(void, OnFrameAddedToPacket, (const QuicFrame& frame), (override));
 
-  MOCK_METHOD1(OnStreamFrameCoalesced, void(const QuicStreamFrame& frame));
+  MOCK_METHOD(void,
+              OnStreamFrameCoalesced,
+              (const QuicStreamFrame& frame),
+              (override));
 };
 
 class TestPacketCreator : public QuicPacketCreator {
@@ -2237,13 +2240,20 @@
   MockDelegate& operator=(const MockDelegate&) = delete;
   ~MockDelegate() override {}
 
-  MOCK_METHOD2(ShouldGeneratePacket,
-               bool(HasRetransmittableData retransmittable,
-                    IsHandshake handshake));
-  MOCK_METHOD0(MaybeBundleAckOpportunistically, const QuicFrames());
-  MOCK_METHOD0(GetPacketBuffer, char*());
-  MOCK_METHOD1(OnSerializedPacket, void(SerializedPacket* packet));
-  MOCK_METHOD2(OnUnrecoverableError, void(QuicErrorCode, const std::string&));
+  MOCK_METHOD(bool,
+              ShouldGeneratePacket,
+              (HasRetransmittableData retransmittable, IsHandshake handshake),
+              (override));
+  MOCK_METHOD(const QuicFrames,
+              MaybeBundleAckOpportunistically,
+              (),
+              (override));
+  MOCK_METHOD(char*, GetPacketBuffer, (), (override));
+  MOCK_METHOD(void, OnSerializedPacket, (SerializedPacket*), (override));
+  MOCK_METHOD(void,
+              OnUnrecoverableError,
+              (QuicErrorCode, const std::string&),
+              (override));
 
   void SetCanWriteAnything() {
     EXPECT_CALL(*this, ShouldGeneratePacket(_, _)).WillRepeatedly(Return(true));
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index e63a9b8..7efa8e3 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -43,14 +43,17 @@
 
 class MockDebugDelegate : public QuicSentPacketManager::DebugDelegate {
  public:
-  MOCK_METHOD2(OnSpuriousPacketRetransmission,
-               void(TransmissionType transmission_type,
-                    QuicByteCount byte_size));
-  MOCK_METHOD4(OnPacketLoss,
-               void(QuicPacketNumber lost_packet_number,
-                    EncryptionLevel encryption_level,
-                    TransmissionType transmission_type,
-                    QuicTime detection_time));
+  MOCK_METHOD(void,
+              OnSpuriousPacketRetransmission,
+              (TransmissionType transmission_type, QuicByteCount byte_size),
+              (override));
+  MOCK_METHOD(void,
+              OnPacketLoss,
+              (QuicPacketNumber lost_packet_number,
+               EncryptionLevel encryption_level,
+               TransmissionType transmission_type,
+               QuicTime detection_time),
+              (override));
 };
 
 class QuicSentPacketManagerTest : public QuicTest {
@@ -105,8 +108,6 @@
 
     EXPECT_CALL(*send_algorithm_, GetCongestionControlType())
         .WillRepeatedly(Return(kInitialCongestionControlType));
-    EXPECT_CALL(*send_algorithm_, HasReliableBandwidthEstimate())
-        .Times(AnyNumber());
     EXPECT_CALL(*send_algorithm_, BandwidthEstimate())
         .Times(AnyNumber())
         .WillRepeatedly(Return(QuicBandwidth::Zero()));
@@ -526,7 +527,6 @@
   // Since 1 has been retransmitted, it has already been lost, and so the
   // send algorithm is not informed that it has been ACK'd.
   ExpectUpdatedRtt(1);
-  EXPECT_CALL(*send_algorithm_, RevertRetransmissionTimeout());
   manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
                            clock_.Now());
   manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2));
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 36b55a1..372fa07 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -161,7 +161,7 @@
               (QuicStreamOffset, QuicByteCount, bool, TransmissionType),
               (override));
 
-  MOCK_METHOD(bool, HasPendingRetransmission, (), (override, const));
+  MOCK_METHOD(bool, HasPendingRetransmission, (), (const, override));
 };
 
 class TestSession : public QuicSession {
diff --git a/quic/core/quic_stream_id_manager_test.cc b/quic/core/quic_stream_id_manager_test.cc
index cf7129c..2179ba2 100644
--- a/quic/core/quic_stream_id_manager_test.cc
+++ b/quic/core/quic_stream_id_manager_test.cc
@@ -24,8 +24,10 @@
 
 class MockDelegate : public QuicStreamIdManager::DelegateInterface {
  public:
-  MOCK_METHOD2(SendMaxStreams,
-               void(QuicStreamCount stream_count, bool unidirectional));
+  MOCK_METHOD(void,
+              SendMaxStreams,
+              (QuicStreamCount stream_count, bool unidirectional),
+              (override));
 };
 
 struct TestParams {
diff --git a/quic/core/quic_stream_sequencer_test.cc b/quic/core/quic_stream_sequencer_test.cc
index 188eb86..bdf1412 100644
--- a/quic/core/quic_stream_sequencer_test.cc
+++ b/quic/core/quic_stream_sequencer_test.cc
@@ -31,13 +31,14 @@
 
 class MockStream : public QuicStreamSequencer::StreamInterface {
  public:
-  MOCK_METHOD0(OnFinRead, void());
-  MOCK_METHOD0(OnDataAvailable, void());
-  MOCK_METHOD2(OnUnrecoverableError,
-               void(QuicErrorCode error, const std::string& details));
-  MOCK_METHOD1(Reset, void(QuicRstStreamErrorCode error));
-  MOCK_METHOD0(OnCanWrite, void());
-  MOCK_METHOD1(AddBytesConsumed, void(QuicByteCount bytes));
+  MOCK_METHOD(void, OnFinRead, (), (override));
+  MOCK_METHOD(void, OnDataAvailable, (), (override));
+  MOCK_METHOD(void,
+              OnUnrecoverableError,
+              (QuicErrorCode error, const std::string& details),
+              (override));
+  MOCK_METHOD(void, Reset, (QuicRstStreamErrorCode error), (override));
+  MOCK_METHOD(void, AddBytesConsumed, (QuicByteCount bytes), (override));
 
   QuicStreamId id() const override { return 1; }
 };
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index fdff93b..f2269bb 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -61,9 +61,9 @@
   TestStream(PendingStream* pending, StreamType type, bool is_static)
       : QuicStream(pending, type, is_static) {}
 
-  MOCK_METHOD0(OnDataAvailable, void());
+  MOCK_METHOD(void, OnDataAvailable, (), (override));
 
-  MOCK_METHOD0(OnCanWriteNewData, void());
+  MOCK_METHOD(void, OnCanWriteNewData, (), (override));
 
   using QuicStream::CanWriteNewData;
   using QuicStream::CanWriteNewDataAfterData;
diff --git a/quic/core/quic_time_wait_list_manager_test.cc b/quic/core/quic_time_wait_list_manager_test.cc
index 9e09a80..468b21b 100644
--- a/quic/core/quic_time_wait_list_manager_test.cc
+++ b/quic/core/quic_time_wait_list_manager_test.cc
@@ -113,8 +113,8 @@
     return QuicArenaScopedPtr<MockAlarm>(
         new MockAlarm(std::move(delegate), alarm_index_++, this));
   }
-  MOCK_METHOD2(OnAlarmSet, void(int, QuicTime));
-  MOCK_METHOD1(OnAlarmCancelled, void(int));
+  MOCK_METHOD(void, OnAlarmSet, (int, QuicTime), ());
+  MOCK_METHOD(void, OnAlarmCancelled, (int), ());
 
  private:
   int alarm_index_ = 0;
diff --git a/quic/core/tls_handshaker_test.cc b/quic/core/tls_handshaker_test.cc
index f774e28..147d62f 100644
--- a/quic/core/tls_handshaker_test.cc
+++ b/quic/core/tls_handshaker_test.cc
@@ -225,10 +225,16 @@
   MockProofHandler() = default;
   ~MockProofHandler() override {}
 
-  MOCK_METHOD1(OnProofValid,  // NOLINT(build/deprecated)
-               void(const QuicCryptoClientConfig::CachedState&));
-  MOCK_METHOD1(OnProofVerifyDetailsAvailable,  // NOLINT(build/deprecated)
-               void(const ProofVerifyDetails&));
+  MOCK_METHOD(  // NOLINT(build/deprecated)
+      void,
+      OnProofValid,
+      (const QuicCryptoClientConfig::CachedState&),
+      (override));
+  MOCK_METHOD(  // NOLINT(build/deprecated)
+      void,
+      OnProofVerifyDetailsAvailable,
+      (const ProofVerifyDetails&),
+      (override));
 };
 
 class TestQuicCryptoClientStream : public TestQuicCryptoStream {
diff --git a/quic/core/uber_quic_stream_id_manager_test.cc b/quic/core/uber_quic_stream_id_manager_test.cc
index 6fe8363..7cae0a6 100644
--- a/quic/core/uber_quic_stream_id_manager_test.cc
+++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -46,8 +46,10 @@
 
 class MockDelegate : public QuicStreamIdManager::DelegateInterface {
  public:
-  MOCK_METHOD2(SendMaxStreams,
-               void(QuicStreamCount stream_count, bool unidirectional));
+  MOCK_METHOD(void,
+              SendMaxStreams,
+              (QuicStreamCount stream_count, bool unidirectional),
+              (override));
 };
 
 class UberQuicStreamIdManagerTest : public QuicTestWithParam<TestParams> {
diff --git a/quic/qbone/bonnet/mock_icmp_reachable.h b/quic/qbone/bonnet/mock_icmp_reachable.h
index 092845e..b717a60 100644
--- a/quic/qbone/bonnet/mock_icmp_reachable.h
+++ b/quic/qbone/bonnet/mock_icmp_reachable.h
@@ -12,7 +12,7 @@
 
 class MockIcmpReachable : public IcmpReachableInterface {
  public:
-  MOCK_METHOD0(Init, bool());
+  MOCK_METHOD(bool, Init, (), (override));
 };
 
 }  // namespace quic
diff --git a/quic/qbone/bonnet/mock_packet_exchanger_stats_interface.h b/quic/qbone/bonnet/mock_packet_exchanger_stats_interface.h
index a265603..f1f8e87 100644
--- a/quic/qbone/bonnet/mock_packet_exchanger_stats_interface.h
+++ b/quic/qbone/bonnet/mock_packet_exchanger_stats_interface.h
@@ -13,13 +13,13 @@
 class MockPacketExchangerStatsInterface
     : public TunDevicePacketExchanger::StatsInterface {
  public:
-  MOCK_METHOD1(OnPacketRead, void(size_t));
-  MOCK_METHOD1(OnPacketWritten, void(size_t));
-  MOCK_METHOD1(OnReadError, void(std::string*));
-  MOCK_METHOD1(OnWriteError, void(std::string*));
+  MOCK_METHOD(void, OnPacketRead, (size_t), (override));
+  MOCK_METHOD(void, OnPacketWritten, (size_t), (override));
+  MOCK_METHOD(void, OnReadError, (std::string*), (override));
+  MOCK_METHOD(void, OnWriteError, (std::string*), (override));
 
-  MOCK_CONST_METHOD0(PacketsRead, int64_t());
-  MOCK_CONST_METHOD0(PacketsWritten, int64_t());
+  MOCK_METHOD(int64_t, PacketsRead, (), (const, override));
+  MOCK_METHOD(int64_t, PacketsWritten, (), (const, override));
 };
 
 }  // namespace quic
diff --git a/quic/qbone/bonnet/mock_tun_device.h b/quic/qbone/bonnet/mock_tun_device.h
index 37e852a..14879de 100644
--- a/quic/qbone/bonnet/mock_tun_device.h
+++ b/quic/qbone/bonnet/mock_tun_device.h
@@ -12,13 +12,13 @@
 
 class MockTunDevice : public TunDeviceInterface {
  public:
-  MOCK_METHOD0(Init, bool());
+  MOCK_METHOD(bool, Init, (), (override));
 
-  MOCK_METHOD0(Up, bool());
+  MOCK_METHOD(bool, Up, (), (override));
 
-  MOCK_METHOD0(Down, bool());
+  MOCK_METHOD(bool, Down, (), (override));
 
-  MOCK_CONST_METHOD0(GetFileDescriptor, int());
+  MOCK_METHOD(int, GetFileDescriptor, (), (const, override));
 };
 
 }  // namespace quic
diff --git a/quic/qbone/bonnet/tun_device_packet_exchanger_test.cc b/quic/qbone/bonnet/tun_device_packet_exchanger_test.cc
index 30ef5ed..f61407d 100644
--- a/quic/qbone/bonnet/tun_device_packet_exchanger_test.cc
+++ b/quic/qbone/bonnet/tun_device_packet_exchanger_test.cc
@@ -23,8 +23,8 @@
 
 class MockVisitor : public QbonePacketExchanger::Visitor {
  public:
-  MOCK_METHOD1(OnReadError, void(const std::string&));
-  MOCK_METHOD1(OnWriteError, void(const std::string&));
+  MOCK_METHOD(void, OnReadError, (const std::string&), (override));
+  MOCK_METHOD(void, OnWriteError, (const std::string&), (override));
 };
 
 class TunDevicePacketExchangerTest : public QuicTest {
diff --git a/quic/qbone/mock_qbone_client.h b/quic/qbone/mock_qbone_client.h
index 0a089ea..3170b7e 100644
--- a/quic/qbone/mock_qbone_client.h
+++ b/quic/qbone/mock_qbone_client.h
@@ -13,8 +13,10 @@
 
 class MockQboneClient : public QboneClientInterface {
  public:
-  MOCK_METHOD1(ProcessPacketFromNetwork,
-               void(quiche::QuicheStringPiece packet));
+  MOCK_METHOD(void,
+              ProcessPacketFromNetwork,
+              (quiche::QuicheStringPiece packet),
+              (override));
 };
 
 }  // namespace quic
diff --git a/quic/qbone/mock_qbone_server_session.h b/quic/qbone/mock_qbone_server_session.h
index 874ad21..0781e7f 100644
--- a/quic/qbone/mock_qbone_server_session.h
+++ b/quic/qbone/mock_qbone_server_session.h
@@ -25,10 +25,16 @@
                            /*client_ip_subnet_length=*/0,
                            /*handler=*/nullptr) {}
 
-  MOCK_METHOD1(SendClientRequest, bool(const QboneClientRequest&));
+  MOCK_METHOD(bool, SendClientRequest, (const QboneClientRequest&), (override));
 
-  MOCK_METHOD1(ProcessPacketFromNetwork, void(quiche::QuicheStringPiece));
-  MOCK_METHOD1(ProcessPacketFromPeer, void(quiche::QuicheStringPiece));
+  MOCK_METHOD(void,
+              ProcessPacketFromNetwork,
+              (quiche::QuicheStringPiece),
+              (override));
+  MOCK_METHOD(void,
+              ProcessPacketFromPeer,
+              (quiche::QuicheStringPiece),
+              (override));
 };
 
 }  // namespace quic
diff --git a/quic/qbone/platform/mock_kernel.h b/quic/qbone/platform/mock_kernel.h
index c01aad1..e30bfa1 100644
--- a/quic/qbone/platform/mock_kernel.h
+++ b/quic/qbone/platform/mock_kernel.h
@@ -14,31 +14,38 @@
  public:
   MockKernel() {}
 
-  MOCK_METHOD3(bind,
-               int(int fd, const struct sockaddr* addr, socklen_t addr_len));
-  MOCK_METHOD1(close, int(int fd));
-  MOCK_METHOD3(ioctl, int(int fd, int request, void* argp));
-  MOCK_METHOD2(open, int(const char* pathname, int flags));
-  MOCK_METHOD3(read, ssize_t(int fd, void* buf, size_t count));
-  MOCK_METHOD6(recvfrom,
-               ssize_t(int sockfd,
-                       void* buf,
-                       size_t len,
-                       int flags,
-                       struct sockaddr* src_addr,
-                       socklen_t* addrlen));
-  MOCK_METHOD3(sendmsg,
-               ssize_t(int sockfd, const struct msghdr* msg, int flags));
-  MOCK_METHOD6(sendto,
-               ssize_t(int sockfd,
-                       const void* buf,
-                       size_t len,
-                       int flags,
-                       const struct sockaddr* dest_addr,
-                       socklen_t addrlen));
-  MOCK_METHOD3(socket, int(int domain, int type, int protocol));
-  MOCK_METHOD5(setsockopt, int(int, int, int, const void*, socklen_t));
-  MOCK_METHOD3(write, ssize_t(int fd, const void* buf, size_t count));
+  MOCK_METHOD(int,
+              bind,
+              (int fd, const struct sockaddr*, socklen_t addr_len),
+              (override));
+  MOCK_METHOD(int, close, (int fd), (override));
+  MOCK_METHOD(int, ioctl, (int fd, int request, void*), (override));
+  MOCK_METHOD(int, open, (const char*, int flags), (override));
+  MOCK_METHOD(ssize_t, read, (int fd, void*, size_t count), (override));
+  MOCK_METHOD(
+      ssize_t,
+      recvfrom,
+      (int sockfd, void*, size_t len, int flags, struct sockaddr*, socklen_t*),
+      (override));
+  MOCK_METHOD(ssize_t,
+              sendmsg,
+              (int sockfd, const struct msghdr*, int flags),
+              (override));
+  MOCK_METHOD(ssize_t,
+              sendto,
+              (int sockfd,
+               const void*,
+               size_t len,
+               int flags,
+               const struct sockaddr*,
+               socklen_t addrlen),
+              (override));
+  MOCK_METHOD(int, socket, (int domain, int type, int protocol), (override));
+  MOCK_METHOD(int,
+              setsockopt,
+              (int, int, int, const void*, socklen_t),
+              (override));
+  MOCK_METHOD(ssize_t, write, (int fd, const void*, size_t count), (override));
 };
 
 }  // namespace quic
diff --git a/quic/qbone/platform/mock_netlink.h b/quic/qbone/platform/mock_netlink.h
index e9f5d68..ea5d62e 100644
--- a/quic/qbone/platform/mock_netlink.h
+++ b/quic/qbone/platform/mock_netlink.h
@@ -12,33 +12,38 @@
 
 class MockNetlink : public NetlinkInterface {
  public:
-  MOCK_METHOD2(GetLinkInfo, bool(const std::string&, LinkInfo*));
+  MOCK_METHOD(bool, GetLinkInfo, (const std::string&, LinkInfo*), (override));
 
-  MOCK_METHOD4(GetAddresses,
-               bool(int, uint8_t, std::vector<AddressInfo>*, int*));
+  MOCK_METHOD(bool,
+              GetAddresses,
+              (int, uint8_t, std::vector<AddressInfo>*, int*),
+              (override));
 
-  MOCK_METHOD7(ChangeLocalAddress,
-               bool(uint32_t,
-                    Verb,
-                    const QuicIpAddress&,
-                    uint8_t,
-                    uint8_t,
-                    uint8_t,
-                    const std::vector<struct rtattr*>&));
+  MOCK_METHOD(bool,
+              ChangeLocalAddress,
+              (uint32_t,
+               Verb,
+               const QuicIpAddress&,
+               uint8_t,
+               uint8_t,
+               uint8_t,
+               const std::vector<struct rtattr*>&),
+              (override));
 
-  MOCK_METHOD1(GetRouteInfo, bool(std::vector<RoutingRule>*));
+  MOCK_METHOD(bool, GetRouteInfo, (std::vector<RoutingRule>*), (override));
 
-  MOCK_METHOD6(
-      ChangeRoute,
-      bool(Verb, uint32_t, const IpRange&, uint8_t, QuicIpAddress, int32_t));
+  MOCK_METHOD(bool,
+              ChangeRoute,
+              (Verb, uint32_t, const IpRange&, uint8_t, QuicIpAddress, int32_t),
+              (override));
 
-  MOCK_METHOD1(GetRuleInfo, bool(std::vector<IpRule>*));
+  MOCK_METHOD(bool, GetRuleInfo, (std::vector<IpRule>*), (override));
 
-  MOCK_METHOD3(ChangeRule, bool(Verb, uint32_t, IpRange));
+  MOCK_METHOD(bool, ChangeRule, (Verb, uint32_t, IpRange), (override));
 
-  MOCK_METHOD2(Send, bool(struct iovec*, size_t));
+  MOCK_METHOD(bool, Send, (struct iovec*, size_t), (override));
 
-  MOCK_METHOD2(Recv, bool(uint32_t, NetlinkParserInterface*));
+  MOCK_METHOD(bool, Recv, (uint32_t, NetlinkParserInterface*), (override));
 };
 
 }  // namespace quic
diff --git a/quic/qbone/qbone_packet_exchanger_test.cc b/quic/qbone/qbone_packet_exchanger_test.cc
index 1f38910..9ec9e20 100644
--- a/quic/qbone/qbone_packet_exchanger_test.cc
+++ b/quic/qbone/qbone_packet_exchanger_test.cc
@@ -19,8 +19,8 @@
 
 class MockVisitor : public QbonePacketExchanger::Visitor {
  public:
-  MOCK_METHOD1(OnReadError, void(const std::string&));
-  MOCK_METHOD1(OnWriteError, void(const std::string&));
+  MOCK_METHOD(void, OnReadError, (const std::string&), (override));
+  MOCK_METHOD(void, OnWriteError, (const std::string&), (override));
 };
 
 class FakeQbonePacketExchanger : public QbonePacketExchanger {
diff --git a/quic/qbone/qbone_packet_processor_test.cc b/quic/qbone/qbone_packet_processor_test.cc
index 77fb5d5..2820a7a 100644
--- a/quic/qbone/qbone_packet_processor_test.cc
+++ b/quic/qbone/qbone_packet_processor_test.cc
@@ -125,12 +125,14 @@
 
 class MockPacketFilter : public QbonePacketProcessor::Filter {
  public:
-  MOCK_METHOD5(FilterPacket,
-               ProcessingResult(Direction,
-                                quiche::QuicheStringPiece,
-                                quiche::QuicheStringPiece,
-                                icmp6_hdr*,
-                                OutputInterface*));
+  MOCK_METHOD(ProcessingResult,
+              FilterPacket,
+              (Direction,
+               quiche::QuicheStringPiece,
+               quiche::QuicheStringPiece,
+               icmp6_hdr*,
+               OutputInterface*),
+              (override));
 };
 
 class QbonePacketProcessorTest : public QuicTest {
diff --git a/quic/qbone/qbone_packet_processor_test_tools.h b/quic/qbone/qbone_packet_processor_test_tools.h
index 809b542..7203050 100644
--- a/quic/qbone/qbone_packet_processor_test_tools.h
+++ b/quic/qbone/qbone_packet_processor_test_tools.h
@@ -15,20 +15,40 @@
  public:
   MockPacketProcessorOutput() {}
 
-  MOCK_METHOD1(SendPacketToClient, void(quiche::QuicheStringPiece));
-  MOCK_METHOD1(SendPacketToNetwork, void(quiche::QuicheStringPiece));
+  MOCK_METHOD(void,
+              SendPacketToClient,
+              (quiche::QuicheStringPiece),
+              (override));
+  MOCK_METHOD(void,
+              SendPacketToNetwork,
+              (quiche::QuicheStringPiece),
+              (override));
 };
 
 class MockPacketProcessorStats : public QbonePacketProcessor::StatsInterface {
  public:
   MockPacketProcessorStats() {}
 
-  MOCK_METHOD1(OnPacketForwarded, void(QbonePacketProcessor::Direction));
-  MOCK_METHOD1(OnPacketDroppedSilently, void(QbonePacketProcessor::Direction));
-  MOCK_METHOD1(OnPacketDroppedWithIcmp, void(QbonePacketProcessor::Direction));
-  MOCK_METHOD1(OnPacketDroppedWithTcpReset,
-               void(QbonePacketProcessor::Direction));
-  MOCK_METHOD1(OnPacketDeferred, void(QbonePacketProcessor::Direction));
+  MOCK_METHOD(void,
+              OnPacketForwarded,
+              (QbonePacketProcessor::Direction),
+              (override));
+  MOCK_METHOD(void,
+              OnPacketDroppedSilently,
+              (QbonePacketProcessor::Direction),
+              (override));
+  MOCK_METHOD(void,
+              OnPacketDroppedWithIcmp,
+              (QbonePacketProcessor::Direction),
+              (override));
+  MOCK_METHOD(void,
+              OnPacketDroppedWithTcpReset,
+              (QbonePacketProcessor::Direction),
+              (override));
+  MOCK_METHOD(void,
+              OnPacketDeferred,
+              (QbonePacketProcessor::Direction),
+              (override));
 };
 
 std::string PrependIPv6HeaderForTest(const std::string& body, int hops);
diff --git a/quic/qbone/qbone_stream_test.cc b/quic/qbone/qbone_stream_test.cc
index 42840be..10edaf6 100644
--- a/quic/qbone/qbone_stream_test.cc
+++ b/quic/qbone/qbone_stream_test.cc
@@ -62,8 +62,10 @@
   QuicCryptoStream* GetMutableCryptoStream() override { return nullptr; }
 
   // Called by QuicStream when they want to close stream.
-  MOCK_METHOD3(SendRstStream,
-               void(QuicStreamId, QuicRstStreamErrorCode, QuicStreamOffset));
+  MOCK_METHOD(void,
+              SendRstStream,
+              (QuicStreamId, QuicRstStreamErrorCode, QuicStreamOffset),
+              (override));
 
   // Sets whether data is written to buffer, or else if this is write blocked.
   void set_writable(bool writable) { writable_ = writable; }
@@ -87,8 +89,14 @@
     return nullptr;
   }
 
-  MOCK_METHOD1(ProcessPacketFromPeer, void(quiche::QuicheStringPiece));
-  MOCK_METHOD1(ProcessPacketFromNetwork, void(quiche::QuicheStringPiece));
+  MOCK_METHOD(void,
+              ProcessPacketFromPeer,
+              (quiche::QuicheStringPiece),
+              (override));
+  MOCK_METHOD(void,
+              ProcessPacketFromNetwork,
+              (quiche::QuicheStringPiece),
+              (override));
 
  private:
   // Whether data is written to write_buffer_.
diff --git a/quic/quic_transport/quic_transport_stream_test.cc b/quic/quic_transport/quic_transport_stream_test.cc
index 6a91702..0f0d770 100644
--- a/quic/quic_transport/quic_transport_stream_test.cc
+++ b/quic/quic_transport/quic_transport_stream_test.cc
@@ -29,7 +29,7 @@
 
 class MockQuicTransportSessionInterface : public QuicTransportSessionInterface {
  public:
-  MOCK_CONST_METHOD0(IsSessionReady, bool());
+  MOCK_METHOD(bool, IsSessionReady, (), (const, override));
 };
 
 class QuicTransportStreamTest : public QuicTest {
diff --git a/quic/test_tools/mock_quic_client_promised_info.h b/quic/test_tools/mock_quic_client_promised_info.h
index 1cb9019..f89d579 100644
--- a/quic/test_tools/mock_quic_client_promised_info.h
+++ b/quic/test_tools/mock_quic_client_promised_info.h
@@ -21,9 +21,11 @@
                              std::string url);
   ~MockQuicClientPromisedInfo() override;
 
-  MOCK_METHOD2(HandleClientRequest,
-               QuicAsyncStatus(const spdy::SpdyHeaderBlock& headers,
-                               QuicClientPushPromiseIndex::Delegate* delegate));
+  MOCK_METHOD(QuicAsyncStatus,
+              HandleClientRequest,
+              (const spdy::SpdyHeaderBlock& headers,
+               QuicClientPushPromiseIndex::Delegate*),
+              (override));
 };
 
 }  // namespace test
diff --git a/quic/test_tools/mock_quic_dispatcher.h b/quic/test_tools/mock_quic_dispatcher.h
index b2ab453..21c3dca 100644
--- a/quic/test_tools/mock_quic_dispatcher.h
+++ b/quic/test_tools/mock_quic_dispatcher.h
@@ -30,10 +30,12 @@
 
   ~MockQuicDispatcher() override;
 
-  MOCK_METHOD3(ProcessPacket,
-               void(const QuicSocketAddress& server_address,
-                    const QuicSocketAddress& client_address,
-                    const QuicReceivedPacket& packet));
+  MOCK_METHOD(void,
+              ProcessPacket,
+              (const QuicSocketAddress& server_address,
+               const QuicSocketAddress& client_address,
+               const QuicReceivedPacket& packet),
+              (override));
 };
 
 }  // namespace test
diff --git a/quic/test_tools/mock_quic_session_visitor.h b/quic/test_tools/mock_quic_session_visitor.h
index 0cc10d1..5cc8476 100644
--- a/quic/test_tools/mock_quic_session_visitor.h
+++ b/quic/test_tools/mock_quic_session_visitor.h
@@ -18,17 +18,26 @@
   MockQuicSessionVisitor(const MockQuicSessionVisitor&) = delete;
   MockQuicSessionVisitor& operator=(const MockQuicSessionVisitor&) = delete;
   ~MockQuicSessionVisitor() override;
-  MOCK_METHOD4(OnConnectionClosed,
-               void(QuicConnectionId connection_id,
-                    QuicErrorCode error,
-                    const std::string& error_details,
-                    ConnectionCloseSource source));
-  MOCK_METHOD1(OnWriteBlocked,
-               void(QuicBlockedWriterInterface* blocked_writer));
-  MOCK_METHOD1(OnRstStreamReceived, void(const QuicRstStreamFrame& frame));
-  MOCK_METHOD1(OnStopSendingReceived, void(const QuicStopSendingFrame& frame));
-  MOCK_METHOD1(OnConnectionAddedToTimeWaitList,
-               void(QuicConnectionId connection_id));
+  MOCK_METHOD(void,
+              OnConnectionClosed,
+              (QuicConnectionId connection_id,
+               QuicErrorCode error,
+               const std::string& error_details,
+               ConnectionCloseSource source),
+              (override));
+  MOCK_METHOD(void, OnWriteBlocked, (QuicBlockedWriterInterface*), (override));
+  MOCK_METHOD(void,
+              OnRstStreamReceived,
+              (const QuicRstStreamFrame& frame),
+              (override));
+  MOCK_METHOD(void,
+              OnStopSendingReceived,
+              (const QuicStopSendingFrame& frame),
+              (override));
+  MOCK_METHOD(void,
+              OnConnectionAddedToTimeWaitList,
+              (QuicConnectionId connection_id),
+              (override));
 };
 
 class MockQuicCryptoServerStreamHelper
@@ -40,12 +49,14 @@
   MockQuicCryptoServerStreamHelper& operator=(
       const MockQuicCryptoServerStreamHelper&) = delete;
   ~MockQuicCryptoServerStreamHelper() override;
-  MOCK_CONST_METHOD5(CanAcceptClientHello,
-                     bool(const CryptoHandshakeMessage& message,
-                          const QuicSocketAddress& client_address,
-                          const QuicSocketAddress& peer_address,
-                          const QuicSocketAddress& self_address,
-                          std::string* error_details));
+  MOCK_METHOD(bool,
+              CanAcceptClientHello,
+              (const CryptoHandshakeMessage& message,
+               const QuicSocketAddress& client_address,
+               const QuicSocketAddress& peer_address,
+               const QuicSocketAddress& self_address,
+               std::string*),
+              (const, override));
 };
 
 }  // namespace test
diff --git a/quic/test_tools/mock_quic_spdy_client_stream.h b/quic/test_tools/mock_quic_spdy_client_stream.h
index 02fe74e..f72822e 100644
--- a/quic/test_tools/mock_quic_spdy_client_stream.h
+++ b/quic/test_tools/mock_quic_spdy_client_stream.h
@@ -20,12 +20,14 @@
                            StreamType type);
   ~MockQuicSpdyClientStream() override;
 
-  MOCK_METHOD1(OnStreamFrame, void(const QuicStreamFrame& frame));
-  MOCK_METHOD3(OnPromiseHeaderList,
-               void(QuicStreamId promised_stream_id,
-                    size_t frame_len,
-                    const QuicHeaderList& list));
-  MOCK_METHOD0(OnDataAvailable, void());
+  MOCK_METHOD(void, OnStreamFrame, (const QuicStreamFrame& frame), (override));
+  MOCK_METHOD(void,
+              OnPromiseHeaderList,
+              (QuicStreamId promised_stream_id,
+               size_t frame_len,
+               const QuicHeaderList& list),
+              (override));
+  MOCK_METHOD(void, OnDataAvailable, (), (override));
 };
 
 }  // namespace test
diff --git a/quic/test_tools/mock_quic_time_wait_list_manager.h b/quic/test_tools/mock_quic_time_wait_list_manager.h
index b8a9776..54bd6d4 100644
--- a/quic/test_tools/mock_quic_time_wait_list_manager.h
+++ b/quic/test_tools/mock_quic_time_wait_list_manager.h
@@ -19,13 +19,14 @@
                           QuicAlarmFactory* alarm_factory);
   ~MockTimeWaitListManager() override;
 
-  MOCK_METHOD5(AddConnectionIdToTimeWait,
-               void(QuicConnectionId connection_id,
-                    bool ietf_quic,
-                    QuicTimeWaitListManager::TimeWaitAction action,
-                    EncryptionLevel encryption_level,
-                    std::vector<std::unique_ptr<QuicEncryptedPacket>>*
-                        termination_packets));
+  MOCK_METHOD(void,
+              AddConnectionIdToTimeWait,
+              (QuicConnectionId connection_id,
+               bool ietf_quic,
+               QuicTimeWaitListManager::TimeWaitAction action,
+               EncryptionLevel encryption_level,
+               std::vector<std::unique_ptr<QuicEncryptedPacket>>*),
+              (override));
 
   void QuicTimeWaitListManager_AddConnectionIdToTimeWait(
       QuicConnectionId connection_id,
@@ -38,34 +39,42 @@
                                                        termination_packets);
   }
 
-  MOCK_METHOD5(ProcessPacket,
-               void(const QuicSocketAddress& server_address,
-                    const QuicSocketAddress& client_address,
-                    QuicConnectionId connection_id,
-                    PacketHeaderFormat header_format,
-                    std::unique_ptr<QuicPerPacketContext> packet_context));
+  MOCK_METHOD(void,
+              ProcessPacket,
+              (const QuicSocketAddress& server_address,
+               const QuicSocketAddress& client_address,
+               QuicConnectionId connection_id,
+               PacketHeaderFormat header_format,
+               std::unique_ptr<QuicPerPacketContext> packet_context),
+              (override));
 
-  MOCK_METHOD8(SendVersionNegotiationPacket,
-               void(QuicConnectionId server_connection_id,
-                    QuicConnectionId client_connection_id,
-                    bool ietf_quic,
-                    bool has_length_prefix,
-                    const ParsedQuicVersionVector& supported_versions,
-                    const QuicSocketAddress& server_address,
-                    const QuicSocketAddress& client_address,
-                    std::unique_ptr<QuicPerPacketContext> packet_context));
+  MOCK_METHOD(void,
+              SendVersionNegotiationPacket,
+              (QuicConnectionId server_connection_id,
+               QuicConnectionId client_connection_id,
+               bool ietf_quic,
+               bool has_length_prefix,
+               const ParsedQuicVersionVector& supported_versions,
+               const QuicSocketAddress& server_address,
+               const QuicSocketAddress& client_address,
+               std::unique_ptr<QuicPerPacketContext> packet_context),
+              (override));
 
-  MOCK_METHOD5(SendPublicReset,
-               void(const QuicSocketAddress&,
-                    const QuicSocketAddress&,
-                    QuicConnectionId,
-                    bool,
-                    std::unique_ptr<QuicPerPacketContext>));
+  MOCK_METHOD(void,
+              SendPublicReset,
+              (const QuicSocketAddress&,
+               const QuicSocketAddress&,
+               QuicConnectionId,
+               bool,
+               std::unique_ptr<QuicPerPacketContext>),
+              (override));
 
-  MOCK_METHOD3(SendPacket,
-               void(const QuicSocketAddress&,
-                    const QuicSocketAddress&,
-                    const QuicEncryptedPacket&));
+  MOCK_METHOD(void,
+              SendPacket,
+              (const QuicSocketAddress&,
+               const QuicSocketAddress&,
+               const QuicEncryptedPacket&),
+              (override));
 };
 
 }  // namespace test
diff --git a/quic/test_tools/qpack/qpack_decoder_test_utils.h b/quic/test_tools/qpack/qpack_decoder_test_utils.h
index 2bd80ef..9741b05 100644
--- a/quic/test_tools/qpack/qpack_decoder_test_utils.h
+++ b/quic/test_tools/qpack/qpack_decoder_test_utils.h
@@ -32,8 +32,10 @@
  public:
   ~MockEncoderStreamErrorDelegate() override = default;
 
-  MOCK_METHOD1(OnEncoderStreamError,
-               void(quiche::QuicheStringPiece error_message));
+  MOCK_METHOD(void,
+              OnEncoderStreamError,
+              (quiche::QuicheStringPiece error_message),
+              (override));
 };
 
 // HeadersHandlerInterface implementation that collects decoded headers
@@ -74,12 +76,15 @@
   MockHeadersHandler& operator=(const MockHeadersHandler&) = delete;
   ~MockHeadersHandler() override = default;
 
-  MOCK_METHOD2(OnHeaderDecoded,
-               void(quiche::QuicheStringPiece name,
-                    quiche::QuicheStringPiece value));
-  MOCK_METHOD0(OnDecodingCompleted, void());
-  MOCK_METHOD1(OnDecodingErrorDetected,
-               void(quiche::QuicheStringPiece error_message));
+  MOCK_METHOD(void,
+              OnHeaderDecoded,
+              (quiche::QuicheStringPiece name, quiche::QuicheStringPiece value),
+              (override));
+  MOCK_METHOD(void, OnDecodingCompleted, (), (override));
+  MOCK_METHOD(void,
+              OnDecodingErrorDetected,
+              (quiche::QuicheStringPiece error_message),
+              (override));
 };
 
 class NoOpHeadersHandler
diff --git a/quic/test_tools/qpack/qpack_encoder_test_utils.h b/quic/test_tools/qpack/qpack_encoder_test_utils.h
index 0ea978f..9b18815 100644
--- a/quic/test_tools/qpack/qpack_encoder_test_utils.h
+++ b/quic/test_tools/qpack/qpack_encoder_test_utils.h
@@ -31,8 +31,10 @@
  public:
   ~MockDecoderStreamErrorDelegate() override = default;
 
-  MOCK_METHOD1(OnDecoderStreamError,
-               void(quiche::QuicheStringPiece error_message));
+  MOCK_METHOD(void,
+              OnDecoderStreamError,
+              (quiche::QuicheStringPiece error_message),
+              (override));
 };
 
 }  // namespace test
diff --git a/quic/test_tools/qpack/qpack_test_utils.h b/quic/test_tools/qpack/qpack_test_utils.h
index 0740950..b9f4adf 100644
--- a/quic/test_tools/qpack/qpack_test_utils.h
+++ b/quic/test_tools/qpack/qpack_test_utils.h
@@ -32,7 +32,10 @@
  public:
   ~MockQpackStreamSenderDelegate() override = default;
 
-  MOCK_METHOD1(WriteStreamData, void(quiche::QuicheStringPiece data));
+  MOCK_METHOD(void,
+              WriteStreamData,
+              (quiche::QuicheStringPiece data),
+              (override));
 };
 
 class NoopQpackStreamSenderDelegate : public QpackStreamSenderDelegate {
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index 93611e3..00a57e7 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -660,6 +660,15 @@
 
   ON_CALL(*this, WritevData(_, _, _, _, _, _))
       .WillByDefault(testing::Return(QuicConsumedData(0, false)));
+
+  ON_CALL(*this, SendWindowUpdate(_, _))
+      .WillByDefault([this](QuicStreamId id, QuicStreamOffset byte_offset) {
+        return QuicSpdySession::SendWindowUpdate(id, byte_offset);
+      });
+
+  ON_CALL(*this, SendBlocked(_)).WillByDefault([this](QuicStreamId id) {
+    return QuicSpdySession::SendBlocked(id);
+  });
 }
 
 MockQuicSpdySession::~MockQuicSpdySession() {
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 92c13f3..5a24909 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -269,63 +269,141 @@
   MockFramerVisitor& operator=(const MockFramerVisitor&) = delete;
   ~MockFramerVisitor() override;
 
-  MOCK_METHOD1(OnError, void(QuicFramer* framer));
+  MOCK_METHOD(void, OnError, (QuicFramer*), (override));
   // The constructor sets this up to return false by default.
-  MOCK_METHOD1(OnProtocolVersionMismatch, bool(ParsedQuicVersion version));
-  MOCK_METHOD0(OnPacket, void());
-  MOCK_METHOD1(OnPublicResetPacket, void(const QuicPublicResetPacket& header));
-  MOCK_METHOD1(OnVersionNegotiationPacket,
-               void(const QuicVersionNegotiationPacket& packet));
-  MOCK_METHOD5(OnRetryPacket,
-               void(QuicConnectionId original_connection_id,
-                    QuicConnectionId new_connection_id,
-                    quiche::QuicheStringPiece retry_token,
-                    quiche::QuicheStringPiece retry_integrity_tag,
-                    quiche::QuicheStringPiece retry_without_tag));
+  MOCK_METHOD(bool,
+              OnProtocolVersionMismatch,
+              (ParsedQuicVersion version),
+              (override));
+  MOCK_METHOD(void, OnPacket, (), (override));
+  MOCK_METHOD(void,
+              OnPublicResetPacket,
+              (const QuicPublicResetPacket& header),
+              (override));
+  MOCK_METHOD(void,
+              OnVersionNegotiationPacket,
+              (const QuicVersionNegotiationPacket& packet),
+              (override));
+  MOCK_METHOD(void,
+              OnRetryPacket,
+              (QuicConnectionId original_connection_id,
+               QuicConnectionId new_connection_id,
+               quiche::QuicheStringPiece retry_token,
+               quiche::QuicheStringPiece retry_integrity_tag,
+               quiche::QuicheStringPiece retry_without_tag),
+              (override));
   // The constructor sets this up to return true by default.
-  MOCK_METHOD1(OnUnauthenticatedHeader, bool(const QuicPacketHeader& header));
+  MOCK_METHOD(bool,
+              OnUnauthenticatedHeader,
+              (const QuicPacketHeader& header),
+              (override));
   // The constructor sets this up to return true by default.
-  MOCK_METHOD1(OnUnauthenticatedPublicHeader,
-               bool(const QuicPacketHeader& header));
-  MOCK_METHOD1(OnDecryptedPacket, void(EncryptionLevel level));
-  MOCK_METHOD1(OnPacketHeader, bool(const QuicPacketHeader& header));
-  MOCK_METHOD1(OnCoalescedPacket, void(const QuicEncryptedPacket& packet));
-  MOCK_METHOD3(OnUndecryptablePacket,
-               void(const QuicEncryptedPacket& packet,
-                    EncryptionLevel decryption_level,
-                    bool has_decryption_key));
-  MOCK_METHOD1(OnStreamFrame, bool(const QuicStreamFrame& frame));
-  MOCK_METHOD1(OnCryptoFrame, bool(const QuicCryptoFrame& frame));
-  MOCK_METHOD2(OnAckFrameStart, bool(QuicPacketNumber, QuicTime::Delta));
-  MOCK_METHOD2(OnAckRange, bool(QuicPacketNumber, QuicPacketNumber));
-  MOCK_METHOD2(OnAckTimestamp, bool(QuicPacketNumber, QuicTime));
-  MOCK_METHOD1(OnAckFrameEnd, bool(QuicPacketNumber));
-  MOCK_METHOD1(OnStopWaitingFrame, bool(const QuicStopWaitingFrame& frame));
-  MOCK_METHOD1(OnPaddingFrame, bool(const QuicPaddingFrame& frame));
-  MOCK_METHOD1(OnPingFrame, bool(const QuicPingFrame& frame));
-  MOCK_METHOD1(OnRstStreamFrame, bool(const QuicRstStreamFrame& frame));
-  MOCK_METHOD1(OnConnectionCloseFrame,
-               bool(const QuicConnectionCloseFrame& frame));
-  MOCK_METHOD1(OnNewConnectionIdFrame,
-               bool(const QuicNewConnectionIdFrame& frame));
-  MOCK_METHOD1(OnRetireConnectionIdFrame,
-               bool(const QuicRetireConnectionIdFrame& frame));
-  MOCK_METHOD1(OnNewTokenFrame, bool(const QuicNewTokenFrame& frame));
-  MOCK_METHOD1(OnStopSendingFrame, bool(const QuicStopSendingFrame& frame));
-  MOCK_METHOD1(OnPathChallengeFrame, bool(const QuicPathChallengeFrame& frame));
-  MOCK_METHOD1(OnPathResponseFrame, bool(const QuicPathResponseFrame& frame));
-  MOCK_METHOD1(OnGoAwayFrame, bool(const QuicGoAwayFrame& frame));
-  MOCK_METHOD1(OnMaxStreamsFrame, bool(const QuicMaxStreamsFrame& frame));
-  MOCK_METHOD1(OnStreamsBlockedFrame,
-               bool(const QuicStreamsBlockedFrame& frame));
-  MOCK_METHOD1(OnWindowUpdateFrame, bool(const QuicWindowUpdateFrame& frame));
-  MOCK_METHOD1(OnBlockedFrame, bool(const QuicBlockedFrame& frame));
-  MOCK_METHOD1(OnMessageFrame, bool(const QuicMessageFrame& frame));
-  MOCK_METHOD1(OnHandshakeDoneFrame, bool(const QuicHandshakeDoneFrame& frame));
-  MOCK_METHOD0(OnPacketComplete, void());
-  MOCK_CONST_METHOD1(IsValidStatelessResetToken, bool(QuicUint128));
-  MOCK_METHOD1(OnAuthenticatedIetfStatelessResetPacket,
-               void(const QuicIetfStatelessResetPacket&));
+  MOCK_METHOD(bool,
+              OnUnauthenticatedPublicHeader,
+              (const QuicPacketHeader& header),
+              (override));
+  MOCK_METHOD(void, OnDecryptedPacket, (EncryptionLevel level), (override));
+  MOCK_METHOD(bool,
+              OnPacketHeader,
+              (const QuicPacketHeader& header),
+              (override));
+  MOCK_METHOD(void,
+              OnCoalescedPacket,
+              (const QuicEncryptedPacket& packet),
+              (override));
+  MOCK_METHOD(void,
+              OnUndecryptablePacket,
+              (const QuicEncryptedPacket& packet,
+               EncryptionLevel decryption_level,
+               bool has_decryption_key),
+              (override));
+  MOCK_METHOD(bool, OnStreamFrame, (const QuicStreamFrame& frame), (override));
+  MOCK_METHOD(bool, OnCryptoFrame, (const QuicCryptoFrame& frame), (override));
+  MOCK_METHOD(bool,
+              OnAckFrameStart,
+              (QuicPacketNumber, QuicTime::Delta),
+              (override));
+  MOCK_METHOD(bool,
+              OnAckRange,
+              (QuicPacketNumber, QuicPacketNumber),
+              (override));
+  MOCK_METHOD(bool, OnAckTimestamp, (QuicPacketNumber, QuicTime), (override));
+  MOCK_METHOD(bool, OnAckFrameEnd, (QuicPacketNumber), (override));
+  MOCK_METHOD(bool,
+              OnStopWaitingFrame,
+              (const QuicStopWaitingFrame& frame),
+              (override));
+  MOCK_METHOD(bool,
+              OnPaddingFrame,
+              (const QuicPaddingFrame& frame),
+              (override));
+  MOCK_METHOD(bool, OnPingFrame, (const QuicPingFrame& frame), (override));
+  MOCK_METHOD(bool,
+              OnRstStreamFrame,
+              (const QuicRstStreamFrame& frame),
+              (override));
+  MOCK_METHOD(bool,
+              OnConnectionCloseFrame,
+              (const QuicConnectionCloseFrame& frame),
+              (override));
+  MOCK_METHOD(bool,
+              OnNewConnectionIdFrame,
+              (const QuicNewConnectionIdFrame& frame),
+              (override));
+  MOCK_METHOD(bool,
+              OnRetireConnectionIdFrame,
+              (const QuicRetireConnectionIdFrame& frame),
+              (override));
+  MOCK_METHOD(bool,
+              OnNewTokenFrame,
+              (const QuicNewTokenFrame& frame),
+              (override));
+  MOCK_METHOD(bool,
+              OnStopSendingFrame,
+              (const QuicStopSendingFrame& frame),
+              (override));
+  MOCK_METHOD(bool,
+              OnPathChallengeFrame,
+              (const QuicPathChallengeFrame& frame),
+              (override));
+  MOCK_METHOD(bool,
+              OnPathResponseFrame,
+              (const QuicPathResponseFrame& frame),
+              (override));
+  MOCK_METHOD(bool, OnGoAwayFrame, (const QuicGoAwayFrame& frame), (override));
+  MOCK_METHOD(bool,
+              OnMaxStreamsFrame,
+              (const QuicMaxStreamsFrame& frame),
+              (override));
+  MOCK_METHOD(bool,
+              OnStreamsBlockedFrame,
+              (const QuicStreamsBlockedFrame& frame),
+              (override));
+  MOCK_METHOD(bool,
+              OnWindowUpdateFrame,
+              (const QuicWindowUpdateFrame& frame),
+              (override));
+  MOCK_METHOD(bool,
+              OnBlockedFrame,
+              (const QuicBlockedFrame& frame),
+              (override));
+  MOCK_METHOD(bool,
+              OnMessageFrame,
+              (const QuicMessageFrame& frame),
+              (override));
+  MOCK_METHOD(bool,
+              OnHandshakeDoneFrame,
+              (const QuicHandshakeDoneFrame& frame),
+              (override));
+  MOCK_METHOD(void, OnPacketComplete, (), (override));
+  MOCK_METHOD(bool,
+              IsValidStatelessResetToken,
+              (QuicUint128),
+              (const, override));
+  MOCK_METHOD(void,
+              OnAuthenticatedIetfStatelessResetPacket,
+              (const QuicIetfStatelessResetPacket&),
+              (override));
 };
 
 class NoOpFramerVisitor : public QuicFramerVisitorInterface {
@@ -395,44 +473,69 @@
       delete;
   ~MockQuicConnectionVisitor() override;
 
-  MOCK_METHOD1(OnStreamFrame, void(const QuicStreamFrame& frame));
-  MOCK_METHOD1(OnCryptoFrame, void(const QuicCryptoFrame& frame));
-  MOCK_METHOD1(OnWindowUpdateFrame, void(const QuicWindowUpdateFrame& frame));
-  MOCK_METHOD1(OnBlockedFrame, void(const QuicBlockedFrame& frame));
-  MOCK_METHOD1(OnRstStream, void(const QuicRstStreamFrame& frame));
-  MOCK_METHOD1(OnGoAway, void(const QuicGoAwayFrame& frame));
-  MOCK_METHOD1(OnMessageReceived, void(quiche::QuicheStringPiece message));
-  MOCK_METHOD0(OnHandshakeDoneReceived, void());
-  MOCK_METHOD2(OnConnectionClosed,
-               void(const QuicConnectionCloseFrame& frame,
-                    ConnectionCloseSource source));
-  MOCK_METHOD0(OnWriteBlocked, void());
-  MOCK_METHOD0(OnCanWrite, void());
-  MOCK_METHOD0(SendProbingData, bool());
-  MOCK_METHOD1(OnCongestionWindowChange, void(QuicTime now));
-  MOCK_METHOD1(OnConnectionMigration, void(AddressChangeType type));
-  MOCK_METHOD0(OnPathDegrading, void());
-  MOCK_CONST_METHOD0(WillingAndAbleToWrite, bool());
-  MOCK_CONST_METHOD0(HasPendingHandshake, bool());
-  MOCK_CONST_METHOD0(ShouldKeepConnectionAlive, bool());
-  MOCK_METHOD1(OnSuccessfulVersionNegotiation,
-               void(const ParsedQuicVersion& version));
-  MOCK_METHOD3(OnPacketReceived,
-               void(const QuicSocketAddress& self_address,
-                    const QuicSocketAddress& peer_address,
-                    bool is_connectivity_probe));
-  MOCK_METHOD0(OnConfigNegotiated, void());
-  MOCK_METHOD0(OnAckNeedsRetransmittableFrame, void());
-  MOCK_METHOD0(SendPing, void());
-  MOCK_CONST_METHOD0(AllowSelfAddressChange, bool());
-  MOCK_CONST_METHOD0(GetHandshakeState, HandshakeState());
-  MOCK_METHOD0(OnForwardProgressConfirmed, void());
-  MOCK_METHOD1(OnMaxStreamsFrame, bool(const QuicMaxStreamsFrame& frame));
-  MOCK_METHOD1(OnStreamsBlockedFrame,
-               bool(const QuicStreamsBlockedFrame& frame));
-  MOCK_METHOD1(OnStopSendingFrame, void(const QuicStopSendingFrame& frame));
-  MOCK_METHOD1(OnPacketDecrypted, void(EncryptionLevel));
-  MOCK_METHOD0(OnOneRttPacketAcknowledged, void());
+  MOCK_METHOD(void, OnStreamFrame, (const QuicStreamFrame& frame), (override));
+  MOCK_METHOD(void, OnCryptoFrame, (const QuicCryptoFrame& frame), (override));
+  MOCK_METHOD(void,
+              OnWindowUpdateFrame,
+              (const QuicWindowUpdateFrame& frame),
+              (override));
+  MOCK_METHOD(void,
+              OnBlockedFrame,
+              (const QuicBlockedFrame& frame),
+              (override));
+  MOCK_METHOD(void, OnRstStream, (const QuicRstStreamFrame& frame), (override));
+  MOCK_METHOD(void, OnGoAway, (const QuicGoAwayFrame& frame), (override));
+  MOCK_METHOD(void,
+              OnMessageReceived,
+              (quiche::QuicheStringPiece message),
+              (override));
+  MOCK_METHOD(void, OnHandshakeDoneReceived, (), (override));
+  MOCK_METHOD(void,
+              OnConnectionClosed,
+              (const QuicConnectionCloseFrame& frame,
+               ConnectionCloseSource source),
+              (override));
+  MOCK_METHOD(void, OnWriteBlocked, (), (override));
+  MOCK_METHOD(void, OnCanWrite, (), (override));
+  MOCK_METHOD(bool, SendProbingData, (), (override));
+  MOCK_METHOD(void, OnCongestionWindowChange, (QuicTime now), (override));
+  MOCK_METHOD(void,
+              OnConnectionMigration,
+              (AddressChangeType type),
+              (override));
+  MOCK_METHOD(void, OnPathDegrading, (), (override));
+  MOCK_METHOD(bool, WillingAndAbleToWrite, (), (const, override));
+  MOCK_METHOD(bool, HasPendingHandshake, (), (const, override));
+  MOCK_METHOD(bool, ShouldKeepConnectionAlive, (), (const, override));
+  MOCK_METHOD(void,
+              OnSuccessfulVersionNegotiation,
+              (const ParsedQuicVersion& version),
+              (override));
+  MOCK_METHOD(void,
+              OnPacketReceived,
+              (const QuicSocketAddress& self_address,
+               const QuicSocketAddress& peer_address,
+               bool is_connectivity_probe),
+              (override));
+  MOCK_METHOD(void, OnAckNeedsRetransmittableFrame, (), (override));
+  MOCK_METHOD(void, SendPing, (), (override));
+  MOCK_METHOD(bool, AllowSelfAddressChange, (), (const, override));
+  MOCK_METHOD(HandshakeState, GetHandshakeState, (), (const, override));
+  MOCK_METHOD(void, OnForwardProgressConfirmed, (), (override));
+  MOCK_METHOD(bool,
+              OnMaxStreamsFrame,
+              (const QuicMaxStreamsFrame& frame),
+              (override));
+  MOCK_METHOD(bool,
+              OnStreamsBlockedFrame,
+              (const QuicStreamsBlockedFrame& frame),
+              (override));
+  MOCK_METHOD(void,
+              OnStopSendingFrame,
+              (const QuicStopSendingFrame& frame),
+              (override));
+  MOCK_METHOD(void, OnPacketDecrypted, (EncryptionLevel), (override));
+  MOCK_METHOD(void, OnOneRttPacketAcknowledged, (), (override));
 };
 
 class MockQuicConnectionHelper : public QuicConnectionHelperInterface {
@@ -517,50 +620,53 @@
   // will advance the time of the MockClock.
   void AdvanceTime(QuicTime::Delta delta);
 
-  MOCK_METHOD3(ProcessUdpPacket,
-               void(const QuicSocketAddress& self_address,
-                    const QuicSocketAddress& peer_address,
-                    const QuicReceivedPacket& packet));
-  MOCK_METHOD1(SendConnectionClose, void(QuicErrorCode error));
-  MOCK_METHOD3(CloseConnection,
-               void(QuicErrorCode error,
-                    const std::string& details,
-                    ConnectionCloseBehavior connection_close_behavior));
-  MOCK_METHOD2(SendConnectionClosePacket,
-               void(QuicErrorCode error, const std::string& details));
-  MOCK_METHOD3(SendRstStream,
-               void(QuicStreamId id,
-                    QuicRstStreamErrorCode error,
-                    QuicStreamOffset bytes_written));
-  MOCK_METHOD3(SendGoAway,
-               void(QuicErrorCode error,
-                    QuicStreamId last_good_stream_id,
-                    const std::string& reason));
-  MOCK_METHOD1(SendBlocked, void(QuicStreamId id));
-  MOCK_METHOD2(SendWindowUpdate,
-               void(QuicStreamId id, QuicStreamOffset byte_offset));
-  MOCK_METHOD0(OnCanWrite, void());
-  MOCK_METHOD1(SendConnectivityProbingResponsePacket,
-               void(const QuicSocketAddress& peer_address));
-  MOCK_METHOD2(SendConnectivityProbingPacket,
-               bool(QuicPacketWriter* probing_writer,
-                    const QuicSocketAddress& peer_address));
+  MOCK_METHOD(void,
+              ProcessUdpPacket,
+              (const QuicSocketAddress& self_address,
+               const QuicSocketAddress& peer_address,
+               const QuicReceivedPacket& packet),
+              (override));
+  MOCK_METHOD(void,
+              CloseConnection,
+              (QuicErrorCode error,
+               const std::string& details,
+               ConnectionCloseBehavior connection_close_behavior),
+              (override));
+  MOCK_METHOD(void,
+              SendConnectionClosePacket,
+              (QuicErrorCode error, const std::string& details),
+              (override));
+  MOCK_METHOD(void, OnCanWrite, (), (override));
+  MOCK_METHOD(void,
+              SendConnectivityProbingResponsePacket,
+              (const QuicSocketAddress& peer_address),
+              (override));
+  MOCK_METHOD(bool,
+              SendConnectivityProbingPacket,
+              (QuicPacketWriter*, const QuicSocketAddress& peer_address),
+              (override));
 
-  MOCK_METHOD1(OnSendConnectionState, void(const CachedNetworkParameters&));
-  MOCK_METHOD2(ResumeConnectionState,
-               void(const CachedNetworkParameters&, bool));
-  MOCK_METHOD1(SetMaxPacingRate, void(QuicBandwidth));
+  MOCK_METHOD(void,
+              OnSendConnectionState,
+              (const CachedNetworkParameters&),
+              (override));
+  MOCK_METHOD(void,
+              ResumeConnectionState,
+              (const CachedNetworkParameters&, bool),
+              (override));
+  MOCK_METHOD(void, SetMaxPacingRate, (QuicBandwidth), (override));
 
-  MOCK_METHOD2(OnStreamReset, void(QuicStreamId, QuicRstStreamErrorCode));
-  MOCK_METHOD1(SendControlFrame, bool(const QuicFrame& frame));
-  MOCK_METHOD3(SendMessage,
-               MessageStatus(QuicMessageId, QuicMemSliceSpan, bool));
-  MOCK_METHOD3(OnConnectionClosed,
-               void(QuicErrorCode error,
-                    const std::string& error_details,
-                    ConnectionCloseSource source));
+  MOCK_METHOD(void,
+              OnStreamReset,
+              (QuicStreamId, QuicRstStreamErrorCode),
+              (override));
+  MOCK_METHOD(bool, SendControlFrame, (const QuicFrame& frame), (override));
+  MOCK_METHOD(MessageStatus,
+              SendMessage,
+              (QuicMessageId, QuicMemSliceSpan, bool),
+              (override));
 
-  MOCK_METHOD1(OnError, void(QuicFramer* framer));
+  MOCK_METHOD(void, OnError, (QuicFramer*), (override));
   void QuicConnection_OnError(QuicFramer* framer) {
     QuicConnection::OnError(framer);
   }
@@ -595,10 +701,18 @@
       const QuicSocketAddress& peer_address) {
     QuicConnection::SendConnectivityProbingResponsePacket(peer_address);
   }
-  MOCK_METHOD1(OnPathResponseFrame, bool(const QuicPathResponseFrame&));
-  MOCK_METHOD1(OnStopSendingFrame, bool(const QuicStopSendingFrame& frame));
-  MOCK_METHOD3(SendCryptoData,
-               size_t(EncryptionLevel, size_t, QuicStreamOffset));
+  MOCK_METHOD(bool,
+              OnPathResponseFrame,
+              (const QuicPathResponseFrame&),
+              (override));
+  MOCK_METHOD(bool,
+              OnStopSendingFrame,
+              (const QuicStopSendingFrame& frame),
+              (override));
+  MOCK_METHOD(size_t,
+              SendCryptoData,
+              (EncryptionLevel, size_t, QuicStreamOffset),
+              (override));
   size_t QuicConnection_SendCryptoData(EncryptionLevel level,
                                        size_t write_length,
                                        QuicStreamOffset offset) {
@@ -642,41 +756,44 @@
   const QuicCryptoStream* GetCryptoStream() const override;
   void SetCryptoStream(QuicCryptoStream* crypto_stream);
 
-  MOCK_METHOD2(OnConnectionClosed,
-               void(const QuicConnectionCloseFrame& frame,
-                    ConnectionCloseSource source));
-  MOCK_METHOD1(CreateIncomingStream, QuicStream*(QuicStreamId id));
-  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream* stream));
-  MOCK_METHOD1(ShouldCreateIncomingStream2, bool(QuicStreamId id));
-  MOCK_METHOD0(ShouldCreateOutgoingBidirectionalStream, bool());
-  MOCK_METHOD0(ShouldCreateOutgoingUnidirectionalStream, bool());
-  MOCK_METHOD6(WritevData,
-               QuicConsumedData(QuicStreamId id,
-                                size_t write_length,
-                                QuicStreamOffset offset,
-                                StreamSendingState state,
-                                TransmissionType type,
-                                quiche::QuicheOptional<EncryptionLevel> level));
+  MOCK_METHOD(void,
+              OnConnectionClosed,
+              (const QuicConnectionCloseFrame& frame,
+               ConnectionCloseSource source),
+              (override));
+  MOCK_METHOD(QuicStream*, CreateIncomingStream, (QuicStreamId id), (override));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateIncomingStream,
+              (PendingStream*),
+              (override));
+  MOCK_METHOD(QuicConsumedData,
+              WritevData,
+              (QuicStreamId id,
+               size_t write_length,
+               QuicStreamOffset offset,
+               StreamSendingState state,
+               TransmissionType type,
+               quiche::QuicheOptional<EncryptionLevel> level),
+              (override));
 
-  MOCK_METHOD3(SendRstStream,
-               void(QuicStreamId stream_id,
-                    QuicRstStreamErrorCode error,
-                    QuicStreamOffset bytes_written));
+  MOCK_METHOD(void,
+              SendRstStream,
+              (QuicStreamId stream_id,
+               QuicRstStreamErrorCode error,
+               QuicStreamOffset bytes_written),
+              (override));
 
-  MOCK_METHOD2(OnStreamHeaders,
-               void(QuicStreamId stream_id,
-                    quiche::QuicheStringPiece headers_data));
-  MOCK_METHOD2(OnStreamHeadersPriority,
-               void(QuicStreamId stream_id, spdy::SpdyPriority priority));
-  MOCK_METHOD3(OnStreamHeadersComplete,
-               void(QuicStreamId stream_id, bool fin, size_t frame_len));
-  MOCK_CONST_METHOD0(ShouldKeepConnectionAlive, bool());
-  MOCK_METHOD2(SendStopSending, void(uint16_t code, QuicStreamId stream_id));
-  MOCK_CONST_METHOD0(GetAlpnsToOffer, std::vector<std::string>());
-  MOCK_CONST_METHOD1(SelectAlpn,
-                     std::vector<quiche::QuicheStringPiece>::const_iterator(
-                         const std::vector<quiche::QuicheStringPiece>&));
-  MOCK_METHOD1(OnAlpnSelected, void(quiche::QuicheStringPiece));
+  MOCK_METHOD(bool, ShouldKeepConnectionAlive, (), (const, override));
+  MOCK_METHOD(void,
+              SendStopSending,
+              (uint16_t code, QuicStreamId stream_id),
+              (override));
+  MOCK_METHOD(std::vector<std::string>, GetAlpnsToOffer, (), (const, override));
+  MOCK_METHOD(std::vector<quiche::QuicheStringPiece>::const_iterator,
+              SelectAlpn,
+              (const std::vector<quiche::QuicheStringPiece>&),
+              (const, override));
+  MOCK_METHOD(void, OnAlpnSelected, (quiche::QuicheStringPiece), (override));
 
   using QuicSession::ActivateStream;
   using QuicSession::GetNumDrainingStreams;
@@ -742,62 +859,73 @@
   }
 
   // From QuicSession.
-  MOCK_METHOD2(OnConnectionClosed,
-               void(const QuicConnectionCloseFrame& frame,
-                    ConnectionCloseSource source));
-  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id));
-  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream* stream));
-  MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicSpdyStream*());
-  MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicSpdyStream*());
-  MOCK_METHOD1(ShouldCreateIncomingStream, bool(QuicStreamId id));
-  MOCK_METHOD0(ShouldCreateOutgoingBidirectionalStream, bool());
-  MOCK_METHOD0(ShouldCreateOutgoingUnidirectionalStream, bool());
-  MOCK_METHOD6(WritevData,
-               QuicConsumedData(QuicStreamId id,
-                                size_t write_length,
-                                QuicStreamOffset offset,
-                                StreamSendingState state,
-                                TransmissionType type,
-                                quiche::QuicheOptional<EncryptionLevel> level));
-
-  MOCK_METHOD3(SendRstStream,
-               void(QuicStreamId stream_id,
-                    QuicRstStreamErrorCode error,
-                    QuicStreamOffset bytes_written));
-
-  MOCK_METHOD2(OnStreamHeaders,
-               void(QuicStreamId stream_id,
-                    quiche::QuicheStringPiece headers_data));
-  MOCK_METHOD2(OnStreamHeadersPriority,
-               void(QuicStreamId stream_id,
-                    const spdy::SpdyStreamPrecedence& precedence));
-  MOCK_METHOD3(OnStreamHeadersComplete,
-               void(QuicStreamId stream_id, bool fin, size_t frame_len));
-  MOCK_METHOD4(OnStreamHeaderList,
-               void(QuicStreamId stream_id,
-                    bool fin,
-                    size_t frame_len,
-                    const QuicHeaderList& header_list));
-  MOCK_METHOD2(OnPromiseHeaders,
-               void(QuicStreamId stream_id,
-                    quiche::QuicheStringPiece headers_data));
-  MOCK_METHOD3(OnPromiseHeadersComplete,
-               void(QuicStreamId stream_id,
-                    QuicStreamId promised_stream_id,
-                    size_t frame_len));
-  MOCK_METHOD4(OnPromiseHeaderList,
-               void(QuicStreamId stream_id,
-                    QuicStreamId promised_stream_id,
-                    size_t frame_len,
-                    const QuicHeaderList& header_list));
-  MOCK_METHOD2(OnPriorityFrame,
-               void(QuicStreamId id,
-                    const spdy::SpdyStreamPrecedence& precedence));
-
-  MOCK_METHOD1(OnHeadersHeadOfLineBlocking, void(QuicTime::Delta delta));
-  MOCK_METHOD4(
-      OnStreamFrameData,
-      void(QuicStreamId stream_id, const char* data, size_t len, bool fin));
+  MOCK_METHOD(void,
+              OnConnectionClosed,
+              (const QuicConnectionCloseFrame& frame,
+               ConnectionCloseSource source),
+              (override));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateIncomingStream,
+              (QuicStreamId id),
+              (override));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateIncomingStream,
+              (PendingStream*),
+              (override));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateOutgoingBidirectionalStream,
+              (),
+              (override));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateOutgoingUnidirectionalStream,
+              (),
+              (override));
+  MOCK_METHOD(bool, ShouldCreateIncomingStream, (QuicStreamId id), (override));
+  MOCK_METHOD(bool, ShouldCreateOutgoingBidirectionalStream, (), (override));
+  MOCK_METHOD(bool, ShouldCreateOutgoingUnidirectionalStream, (), (override));
+  MOCK_METHOD(QuicConsumedData,
+              WritevData,
+              (QuicStreamId id,
+               size_t write_length,
+               QuicStreamOffset offset,
+               StreamSendingState state,
+               TransmissionType type,
+               quiche::QuicheOptional<EncryptionLevel> level),
+              (override));
+  MOCK_METHOD(void,
+              SendRstStream,
+              (QuicStreamId stream_id,
+               QuicRstStreamErrorCode error,
+               QuicStreamOffset bytes_written),
+              (override));
+  MOCK_METHOD(void,
+              SendWindowUpdate,
+              (QuicStreamId id, QuicStreamOffset byte_offset),
+              (override));
+  MOCK_METHOD(void, SendBlocked, (QuicStreamId id), (override));
+  MOCK_METHOD(void,
+              OnStreamHeadersPriority,
+              (QuicStreamId stream_id,
+               const spdy::SpdyStreamPrecedence& precedence),
+              (override));
+  MOCK_METHOD(void,
+              OnStreamHeaderList,
+              (QuicStreamId stream_id,
+               bool fin,
+               size_t frame_len,
+               const QuicHeaderList& header_list),
+              (override));
+  MOCK_METHOD(void,
+              OnPromiseHeaderList,
+              (QuicStreamId stream_id,
+               QuicStreamId promised_stream_id,
+               size_t frame_len,
+               const QuicHeaderList& header_list),
+              (override));
+  MOCK_METHOD(void,
+              OnPriorityFrame,
+              (QuicStreamId id, const spdy::SpdyStreamPrecedence& precedence),
+              (override));
 
   // Returns a QuicConsumedData that indicates all of |write_length| (and |fin|
   // if set) has been consumed.
@@ -816,39 +944,79 @@
 
 class MockHttp3DebugVisitor : public Http3DebugVisitor {
  public:
-  MOCK_METHOD1(OnControlStreamCreated, void(QuicStreamId));
-  MOCK_METHOD1(OnQpackEncoderStreamCreated, void(QuicStreamId));
-  MOCK_METHOD1(OnQpackDecoderStreamCreated, void(QuicStreamId));
-  MOCK_METHOD1(OnPeerControlStreamCreated, void(QuicStreamId));
-  MOCK_METHOD1(OnPeerQpackEncoderStreamCreated, void(QuicStreamId));
-  MOCK_METHOD1(OnPeerQpackDecoderStreamCreated, void(QuicStreamId));
+  MOCK_METHOD(void, OnControlStreamCreated, (QuicStreamId), (override));
+  MOCK_METHOD(void, OnQpackEncoderStreamCreated, (QuicStreamId), (override));
+  MOCK_METHOD(void, OnQpackDecoderStreamCreated, (QuicStreamId), (override));
+  MOCK_METHOD(void, OnPeerControlStreamCreated, (QuicStreamId), (override));
+  MOCK_METHOD(void,
+              OnPeerQpackEncoderStreamCreated,
+              (QuicStreamId),
+              (override));
+  MOCK_METHOD(void,
+              OnPeerQpackDecoderStreamCreated,
+              (QuicStreamId),
+              (override));
 
-  MOCK_METHOD1(OnCancelPushFrameReceived, void(const CancelPushFrame&));
-  MOCK_METHOD1(OnSettingsFrameReceived, void(const SettingsFrame&));
-  MOCK_METHOD1(OnGoAwayFrameReceived, void(const GoAwayFrame&));
-  MOCK_METHOD1(OnMaxPushIdFrameReceived, void(const MaxPushIdFrame&));
-  MOCK_METHOD1(OnPriorityUpdateFrameReceived, void(const PriorityUpdateFrame&));
+  MOCK_METHOD(void,
+              OnCancelPushFrameReceived,
+              (const CancelPushFrame&),
+              (override));
+  MOCK_METHOD(void,
+              OnSettingsFrameReceived,
+              (const SettingsFrame&),
+              (override));
+  MOCK_METHOD(void, OnGoAwayFrameReceived, (const GoAwayFrame&), (override));
+  MOCK_METHOD(void,
+              OnMaxPushIdFrameReceived,
+              (const MaxPushIdFrame&),
+              (override));
+  MOCK_METHOD(void,
+              OnPriorityUpdateFrameReceived,
+              (const PriorityUpdateFrame&),
+              (override));
 
-  MOCK_METHOD2(OnDataFrameReceived, void(QuicStreamId, QuicByteCount));
-  MOCK_METHOD2(OnHeadersFrameReceived, void(QuicStreamId, QuicByteCount));
-  MOCK_METHOD2(OnHeadersDecoded, void(QuicStreamId, QuicHeaderList));
-  MOCK_METHOD3(OnPushPromiseFrameReceived,
-               void(QuicStreamId, QuicStreamId, QuicByteCount));
-  MOCK_METHOD3(OnPushPromiseDecoded,
-               void(QuicStreamId, QuicStreamId, QuicHeaderList));
-  MOCK_METHOD3(OnUnknownFrameReceived,
-               void(QuicStreamId, uint64_t, QuicByteCount));
+  MOCK_METHOD(void,
+              OnDataFrameReceived,
+              (QuicStreamId, QuicByteCount),
+              (override));
+  MOCK_METHOD(void,
+              OnHeadersFrameReceived,
+              (QuicStreamId, QuicByteCount),
+              (override));
+  MOCK_METHOD(void,
+              OnHeadersDecoded,
+              (QuicStreamId, QuicHeaderList),
+              (override));
+  MOCK_METHOD(void,
+              OnPushPromiseFrameReceived,
+              (QuicStreamId, QuicStreamId, QuicByteCount),
+              (override));
+  MOCK_METHOD(void,
+              OnPushPromiseDecoded,
+              (QuicStreamId, QuicStreamId, QuicHeaderList),
+              (override));
+  MOCK_METHOD(void,
+              OnUnknownFrameReceived,
+              (QuicStreamId, uint64_t, QuicByteCount),
+              (override));
 
-  MOCK_METHOD1(OnSettingsFrameSent, void(const SettingsFrame&));
-  MOCK_METHOD1(OnGoAwayFrameSent, void(QuicStreamId));
-  MOCK_METHOD1(OnMaxPushIdFrameSent, void(const MaxPushIdFrame&));
-  MOCK_METHOD1(OnPriorityUpdateFrameSent, void(const PriorityUpdateFrame&));
+  MOCK_METHOD(void, OnSettingsFrameSent, (const SettingsFrame&), (override));
+  MOCK_METHOD(void, OnGoAwayFrameSent, (QuicStreamId), (override));
+  MOCK_METHOD(void, OnMaxPushIdFrameSent, (const MaxPushIdFrame&), (override));
+  MOCK_METHOD(void,
+              OnPriorityUpdateFrameSent,
+              (const PriorityUpdateFrame&),
+              (override));
 
-  MOCK_METHOD2(OnDataFrameSent, void(QuicStreamId, QuicByteCount));
-  MOCK_METHOD2(OnHeadersFrameSent,
-               void(QuicStreamId, const spdy::SpdyHeaderBlock&));
-  MOCK_METHOD3(OnPushPromiseFrameSent,
-               void(QuicStreamId, QuicStreamId, const spdy::SpdyHeaderBlock&));
+  MOCK_METHOD(void, OnDataFrameSent, (QuicStreamId, QuicByteCount), (override));
+  MOCK_METHOD(void,
+              OnHeadersFrameSent,
+              (QuicStreamId, const spdy::SpdyHeaderBlock&),
+              (override));
+  MOCK_METHOD(void,
+              OnPushPromiseFrameSent,
+              (QuicStreamId, QuicStreamId, const spdy::SpdyHeaderBlock&),
+              (override));
 };
 
 class TestQuicSpdyServerSession : public QuicServerSessionBase {
@@ -864,14 +1032,27 @@
       delete;
   ~TestQuicSpdyServerSession() override;
 
-  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id));
-  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream* stream));
-  MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicSpdyStream*());
-  MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicSpdyStream*());
-  MOCK_CONST_METHOD1(SelectAlpn,
-                     std::vector<quiche::QuicheStringPiece>::const_iterator(
-                         const std::vector<quiche::QuicheStringPiece>&));
-  MOCK_METHOD(void, OnAlpnSelected, (quiche::QuicheStringPiece));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateIncomingStream,
+              (QuicStreamId id),
+              (override));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateIncomingStream,
+              (PendingStream*),
+              (override));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateOutgoingBidirectionalStream,
+              (),
+              (override));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateOutgoingUnidirectionalStream,
+              (),
+              (override));
+  MOCK_METHOD(std::vector<quiche::QuicheStringPiece>::const_iterator,
+              SelectAlpn,
+              (const std::vector<quiche::QuicheStringPiece>&),
+              (const, override));
+  MOCK_METHOD(void, OnAlpnSelected, (quiche::QuicheStringPiece), (override));
   std::unique_ptr<QuicCryptoServerStreamBase> CreateQuicCryptoServerStream(
       const QuicCryptoServerConfig* crypto_config,
       QuicCompressedCertsCache* compressed_certs_cache) override;
@@ -924,21 +1105,37 @@
   bool IsAuthorized(const std::string& authority) override;
 
   // QuicSpdyClientSessionBase
-  MOCK_METHOD1(OnProofValid,
-               void(const QuicCryptoClientConfig::CachedState& cached));
-  MOCK_METHOD1(OnProofVerifyDetailsAvailable,
-               void(const ProofVerifyDetails& verify_details));
+  MOCK_METHOD(void,
+              OnProofValid,
+              (const QuicCryptoClientConfig::CachedState& cached),
+              (override));
+  MOCK_METHOD(void,
+              OnProofVerifyDetailsAvailable,
+              (const ProofVerifyDetails& verify_details),
+              (override));
 
   // TestQuicSpdyClientSession
-  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id));
-  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream* stream));
-  MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicSpdyStream*());
-  MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicSpdyStream*());
-  MOCK_METHOD1(ShouldCreateIncomingStream, bool(QuicStreamId id));
-  MOCK_METHOD0(ShouldCreateOutgoingBidirectionalStream, bool());
-  MOCK_METHOD0(ShouldCreateOutgoingUnidirectionalStream, bool());
-  MOCK_CONST_METHOD0(GetAlpnsToOffer, std::vector<std::string>());
-  MOCK_METHOD(void, OnAlpnSelected, (quiche::QuicheStringPiece));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateIncomingStream,
+              (QuicStreamId id),
+              (override));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateIncomingStream,
+              (PendingStream*),
+              (override));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateOutgoingBidirectionalStream,
+              (),
+              (override));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateOutgoingUnidirectionalStream,
+              (),
+              (override));
+  MOCK_METHOD(bool, ShouldCreateIncomingStream, (QuicStreamId id), (override));
+  MOCK_METHOD(bool, ShouldCreateOutgoingBidirectionalStream, (), (override));
+  MOCK_METHOD(bool, ShouldCreateOutgoingUnidirectionalStream, (), (override));
+  MOCK_METHOD(std::vector<std::string>, GetAlpnsToOffer, (), (const, override));
+  MOCK_METHOD(void, OnAlpnSelected, (quiche::QuicheStringPiece), (override));
 
   QuicCryptoClientStream* GetMutableCryptoStream() override;
   const QuicCryptoClientStream* GetCryptoStream() const override;
@@ -967,22 +1164,28 @@
   MockPacketWriter& operator=(const MockPacketWriter&) = delete;
   ~MockPacketWriter() override;
 
-  MOCK_METHOD5(WritePacket,
-               WriteResult(const char* buffer,
-                           size_t buf_len,
-                           const QuicIpAddress& self_address,
-                           const QuicSocketAddress& peer_address,
-                           PerPacketOptions* options));
-  MOCK_CONST_METHOD0(IsWriteBlocked, bool());
-  MOCK_METHOD0(SetWritable, void());
-  MOCK_CONST_METHOD1(GetMaxPacketSize,
-                     QuicByteCount(const QuicSocketAddress& peer_address));
-  MOCK_CONST_METHOD0(SupportsReleaseTime, bool());
-  MOCK_CONST_METHOD0(IsBatchMode, bool());
-  MOCK_METHOD2(GetNextWriteLocation,
-               char*(const QuicIpAddress& self_address,
-                     const QuicSocketAddress& peer_address));
-  MOCK_METHOD0(Flush, WriteResult());
+  MOCK_METHOD(WriteResult,
+              WritePacket,
+              (const char*,
+               size_t buf_len,
+               const QuicIpAddress& self_address,
+               const QuicSocketAddress& peer_address,
+               PerPacketOptions*),
+              (override));
+  MOCK_METHOD(bool, IsWriteBlocked, (), (const, override));
+  MOCK_METHOD(void, SetWritable, (), (override));
+  MOCK_METHOD(QuicByteCount,
+              GetMaxPacketSize,
+              (const QuicSocketAddress& peer_address),
+              (const, override));
+  MOCK_METHOD(bool, SupportsReleaseTime, (), (const, override));
+  MOCK_METHOD(bool, IsBatchMode, (), (const, override));
+  MOCK_METHOD(char*,
+              GetNextWriteLocation,
+              (const QuicIpAddress& self_address,
+               const QuicSocketAddress& peer_address),
+              (override));
+  MOCK_METHOD(WriteResult, Flush, (), (override));
 };
 
 class MockSendAlgorithm : public SendAlgorithmInterface {
@@ -992,45 +1195,55 @@
   MockSendAlgorithm& operator=(const MockSendAlgorithm&) = delete;
   ~MockSendAlgorithm() override;
 
-  MOCK_METHOD2(SetFromConfig,
-               void(const QuicConfig& config, Perspective perspective));
-  MOCK_METHOD1(SetInitialCongestionWindowInPackets,
-               void(QuicPacketCount packets));
-  MOCK_METHOD1(SetMaxCongestionWindow,
-               void(QuicByteCount max_congestion_window));
-  MOCK_METHOD5(OnCongestionEvent,
-               void(bool rtt_updated,
-                    QuicByteCount bytes_in_flight,
-                    QuicTime event_time,
-                    const AckedPacketVector& acked_packets,
-                    const LostPacketVector& lost_packets));
-  MOCK_METHOD5(OnPacketSent,
-               void(QuicTime,
-                    QuicByteCount,
-                    QuicPacketNumber,
-                    QuicByteCount,
-                    HasRetransmittableData));
-  MOCK_METHOD1(OnPacketNeutered, void(QuicPacketNumber));
-  MOCK_METHOD1(OnRetransmissionTimeout, void(bool));
-  MOCK_METHOD0(OnConnectionMigration, void());
-  MOCK_METHOD0(RevertRetransmissionTimeout, void());
-  MOCK_METHOD1(CanSend, bool(QuicByteCount));
-  MOCK_CONST_METHOD1(PacingRate, QuicBandwidth(QuicByteCount));
-  MOCK_CONST_METHOD0(BandwidthEstimate, QuicBandwidth(void));
-  MOCK_CONST_METHOD0(HasReliableBandwidthEstimate, bool());
-  MOCK_METHOD1(OnRttUpdated, void(QuicPacketNumber));
-  MOCK_CONST_METHOD0(GetCongestionWindow, QuicByteCount());
-  MOCK_CONST_METHOD0(GetDebugState, std::string());
-  MOCK_CONST_METHOD0(InSlowStart, bool());
-  MOCK_CONST_METHOD0(InRecovery, bool());
-  MOCK_CONST_METHOD0(ShouldSendProbingPacket, bool());
-  MOCK_CONST_METHOD0(GetSlowStartThreshold, QuicByteCount());
-  MOCK_CONST_METHOD0(GetCongestionControlType, CongestionControlType());
-  MOCK_METHOD3(AdjustNetworkParameters,
-               void(QuicBandwidth, QuicTime::Delta, bool));
-  MOCK_METHOD1(AdjustNetworkParameters, void(const NetworkParams&));
-  MOCK_METHOD1(OnApplicationLimited, void(QuicByteCount));
-  MOCK_CONST_METHOD1(PopulateConnectionStats, void(QuicConnectionStats*));
+  MOCK_METHOD(void,
+              SetFromConfig,
+              (const QuicConfig& config, Perspective perspective),
+              (override));
+  MOCK_METHOD(void,
+              SetInitialCongestionWindowInPackets,
+              (QuicPacketCount packets),
+              (override));
+  MOCK_METHOD(void,
+              OnCongestionEvent,
+              (bool rtt_updated,
+               QuicByteCount bytes_in_flight,
+               QuicTime event_time,
+               const AckedPacketVector& acked_packets,
+               const LostPacketVector& lost_packets),
+              (override));
+  MOCK_METHOD(void,
+              OnPacketSent,
+              (QuicTime,
+               QuicByteCount,
+               QuicPacketNumber,
+               QuicByteCount,
+               HasRetransmittableData),
+              (override));
+  MOCK_METHOD(void, OnPacketNeutered, (QuicPacketNumber), (override));
+  MOCK_METHOD(void, OnRetransmissionTimeout, (bool), (override));
+  MOCK_METHOD(void, OnConnectionMigration, (), (override));
+  MOCK_METHOD(bool, CanSend, (QuicByteCount), (override));
+  MOCK_METHOD(QuicBandwidth, PacingRate, (QuicByteCount), (const, override));
+  MOCK_METHOD(QuicBandwidth, BandwidthEstimate, (), (const, override));
+  MOCK_METHOD(QuicByteCount, GetCongestionWindow, (), (const, override));
+  MOCK_METHOD(std::string, GetDebugState, (), (const, override));
+  MOCK_METHOD(bool, InSlowStart, (), (const, override));
+  MOCK_METHOD(bool, InRecovery, (), (const, override));
+  MOCK_METHOD(bool, ShouldSendProbingPacket, (), (const, override));
+  MOCK_METHOD(QuicByteCount, GetSlowStartThreshold, (), (const, override));
+  MOCK_METHOD(CongestionControlType,
+              GetCongestionControlType,
+              (),
+              (const, override));
+  MOCK_METHOD(void,
+              AdjustNetworkParameters,
+              (const NetworkParams&),
+              (override));
+  MOCK_METHOD(void, OnApplicationLimited, (QuicByteCount), (override));
+  MOCK_METHOD(void,
+              PopulateConnectionStats,
+              (QuicConnectionStats*),
+              (const, override));
 };
 
 class MockLossAlgorithm : public LossDetectionInterface {
@@ -1040,27 +1253,33 @@
   MockLossAlgorithm& operator=(const MockLossAlgorithm&) = delete;
   ~MockLossAlgorithm() override;
 
-  MOCK_METHOD2(SetFromConfig,
-               void(const QuicConfig& config, Perspective perspective));
+  MOCK_METHOD(void,
+              SetFromConfig,
+              (const QuicConfig& config, Perspective perspective),
+              (override));
 
-  MOCK_METHOD6(DetectLosses,
-               void(const QuicUnackedPacketMap& unacked_packets,
-                    QuicTime time,
-                    const RttStats& rtt_stats,
-                    QuicPacketNumber largest_recently_acked,
-                    const AckedPacketVector& packets_acked,
-                    LostPacketVector* packets_lost));
-  MOCK_CONST_METHOD0(GetLossTimeout, QuicTime());
-  MOCK_METHOD5(SpuriousLossDetected,
-               void(const QuicUnackedPacketMap&,
-                    const RttStats&,
-                    QuicTime,
-                    QuicPacketNumber,
-                    QuicPacketNumber));
+  MOCK_METHOD(void,
+              DetectLosses,
+              (const QuicUnackedPacketMap& unacked_packets,
+               QuicTime time,
+               const RttStats& rtt_stats,
+               QuicPacketNumber largest_recently_acked,
+               const AckedPacketVector& packets_acked,
+               LostPacketVector*),
+              (override));
+  MOCK_METHOD(QuicTime, GetLossTimeout, (), (const, override));
+  MOCK_METHOD(void,
+              SpuriousLossDetected,
+              (const QuicUnackedPacketMap&,
+               const RttStats&,
+               QuicTime,
+               QuicPacketNumber,
+               QuicPacketNumber),
+              (override));
 
-  MOCK_METHOD0(OnConfigNegotiated, void());
-  MOCK_METHOD0(OnMinRttAvailable, void());
-  MOCK_METHOD0(OnConnectionClosed, void());
+  MOCK_METHOD(void, OnConfigNegotiated, (), (override));
+  MOCK_METHOD(void, OnMinRttAvailable, (), (override));
+  MOCK_METHOD(void, OnConnectionClosed, (), (override));
 };
 
 class MockAckListener : public QuicAckListenerInterface {
@@ -1069,10 +1288,15 @@
   MockAckListener(const MockAckListener&) = delete;
   MockAckListener& operator=(const MockAckListener&) = delete;
 
-  MOCK_METHOD2(OnPacketAcked,
-               void(int acked_bytes, QuicTime::Delta ack_delay_time));
+  MOCK_METHOD(void,
+              OnPacketAcked,
+              (int acked_bytes, QuicTime::Delta ack_delay_time),
+              (override));
 
-  MOCK_METHOD1(OnPacketRetransmitted, void(int retransmitted_bytes));
+  MOCK_METHOD(void,
+              OnPacketRetransmitted,
+              (int retransmitted_bytes),
+              (override));
 
  protected:
   // Object is ref counted.
@@ -1087,8 +1311,8 @@
   MockNetworkChangeVisitor& operator=(const MockNetworkChangeVisitor&) = delete;
   ~MockNetworkChangeVisitor() override;
 
-  MOCK_METHOD0(OnCongestionChange, void());
-  MOCK_METHOD1(OnPathMtuIncreased, void(QuicPacketLength));
+  MOCK_METHOD(void, OnCongestionChange, (), (override));
+  MOCK_METHOD(void, OnPathMtuIncreased, (QuicPacketLength), (override));
 };
 
 class MockQuicConnectionDebugVisitor : public QuicConnectionDebugVisitor {
@@ -1096,66 +1320,95 @@
   MockQuicConnectionDebugVisitor();
   ~MockQuicConnectionDebugVisitor() override;
 
-  MOCK_METHOD1(OnFrameAddedToPacket, void(const QuicFrame&));
+  MOCK_METHOD(void,
+              OnPacketSent,
+              (const SerializedPacket&, TransmissionType, QuicTime),
+              (override));
 
-  MOCK_METHOD3(OnPacketSent,
-               void(const SerializedPacket&, TransmissionType, QuicTime));
+  MOCK_METHOD(void,
+              OnCoalescedPacketSent,
+              (const QuicCoalescedPacket&, size_t),
+              (override));
 
-  MOCK_METHOD2(OnCoalescedPacketSent, void(const QuicCoalescedPacket&, size_t));
+  MOCK_METHOD(void, OnPingSent, (), (override));
 
-  MOCK_METHOD0(OnPingSent, void());
+  MOCK_METHOD(void,
+              OnPacketReceived,
+              (const QuicSocketAddress&,
+               const QuicSocketAddress&,
+               const QuicEncryptedPacket&),
+              (override));
 
-  MOCK_METHOD3(OnPacketReceived,
-               void(const QuicSocketAddress&,
-                    const QuicSocketAddress&,
-                    const QuicEncryptedPacket&));
+  MOCK_METHOD(void, OnIncorrectConnectionId, (QuicConnectionId), (override));
 
-  MOCK_METHOD1(OnIncorrectConnectionId, void(QuicConnectionId));
+  MOCK_METHOD(void, OnProtocolVersionMismatch, (ParsedQuicVersion), (override));
 
-  MOCK_METHOD1(OnProtocolVersionMismatch, void(ParsedQuicVersion));
+  MOCK_METHOD(void,
+              OnPacketHeader,
+              (const QuicPacketHeader& header),
+              (override));
 
-  MOCK_METHOD1(OnPacketHeader, void(const QuicPacketHeader& header));
+  MOCK_METHOD(void,
+              OnSuccessfulVersionNegotiation,
+              (const ParsedQuicVersion&),
+              (override));
 
-  MOCK_METHOD1(OnSuccessfulVersionNegotiation, void(const ParsedQuicVersion&));
+  MOCK_METHOD(void, OnStreamFrame, (const QuicStreamFrame&), (override));
 
-  MOCK_METHOD1(OnStreamFrame, void(const QuicStreamFrame&));
+  MOCK_METHOD(void, OnCryptoFrame, (const QuicCryptoFrame&), (override));
 
-  MOCK_METHOD1(OnCryptoFrame, void(const QuicCryptoFrame&));
+  MOCK_METHOD(void,
+              OnStopWaitingFrame,
+              (const QuicStopWaitingFrame&),
+              (override));
 
-  MOCK_METHOD1(OnStopWaitingFrame, void(const QuicStopWaitingFrame&));
+  MOCK_METHOD(void, OnRstStreamFrame, (const QuicRstStreamFrame&), (override));
 
-  MOCK_METHOD1(OnRstStreamFrame, void(const QuicRstStreamFrame&));
+  MOCK_METHOD(void,
+              OnConnectionCloseFrame,
+              (const QuicConnectionCloseFrame&),
+              (override));
 
-  MOCK_METHOD1(OnConnectionCloseFrame, void(const QuicConnectionCloseFrame&));
+  MOCK_METHOD(void, OnBlockedFrame, (const QuicBlockedFrame&), (override));
 
-  MOCK_METHOD1(OnBlockedFrame, void(const QuicBlockedFrame&));
+  MOCK_METHOD(void,
+              OnNewConnectionIdFrame,
+              (const QuicNewConnectionIdFrame&),
+              (override));
 
-  MOCK_METHOD1(OnNewConnectionIdFrame, void(const QuicNewConnectionIdFrame&));
+  MOCK_METHOD(void,
+              OnRetireConnectionIdFrame,
+              (const QuicRetireConnectionIdFrame&),
+              (override));
 
-  MOCK_METHOD1(OnRetireConnectionIdFrame,
-               void(const QuicRetireConnectionIdFrame&));
+  MOCK_METHOD(void, OnNewTokenFrame, (const QuicNewTokenFrame&), (override));
 
-  MOCK_METHOD1(OnNewTokenFrame, void(const QuicNewTokenFrame&));
+  MOCK_METHOD(void, OnMessageFrame, (const QuicMessageFrame&), (override));
 
-  MOCK_METHOD1(OnMessageFrame, void(const QuicMessageFrame&));
+  MOCK_METHOD(void,
+              OnStopSendingFrame,
+              (const QuicStopSendingFrame&),
+              (override));
 
-  MOCK_METHOD1(OnStopSendingFrame, void(const QuicStopSendingFrame&));
+  MOCK_METHOD(void,
+              OnPathChallengeFrame,
+              (const QuicPathChallengeFrame&),
+              (override));
 
-  MOCK_METHOD1(OnPathChallengeFrame, void(const QuicPathChallengeFrame&));
+  MOCK_METHOD(void,
+              OnPathResponseFrame,
+              (const QuicPathResponseFrame&),
+              (override));
 
-  MOCK_METHOD1(OnPathResponseFrame, void(const QuicPathResponseFrame&));
+  MOCK_METHOD(void,
+              OnPublicResetPacket,
+              (const QuicPublicResetPacket&),
+              (override));
 
-  MOCK_METHOD1(OnPublicResetPacket, void(const QuicPublicResetPacket&));
-
-  MOCK_METHOD1(OnVersionNegotiationPacket,
-               void(const QuicVersionNegotiationPacket&));
-
-  MOCK_METHOD5(OnRetryPacket,
-               void(QuicConnectionId,
-                    QuicConnectionId,
-                    quiche::QuicheStringPiece,
-                    quiche::QuicheStringPiece,
-                    quiche::QuicheStringPiece));
+  MOCK_METHOD(void,
+              OnVersionNegotiationPacket,
+              (const QuicVersionNegotiationPacket&),
+              (override));
 };
 
 class MockReceivedPacketManager : public QuicReceivedPacketManager {
@@ -1163,14 +1416,17 @@
   explicit MockReceivedPacketManager(QuicConnectionStats* stats);
   ~MockReceivedPacketManager() override;
 
-  MOCK_METHOD2(RecordPacketReceived,
-               void(const QuicPacketHeader& header, QuicTime receipt_time));
-  MOCK_METHOD1(IsMissing, bool(QuicPacketNumber packet_number));
-  MOCK_CONST_METHOD1(IsAwaitingPacket, bool(QuicPacketNumber packet_number));
-  MOCK_METHOD1(UpdatePacketInformationSentByPeer,
-               void(const QuicStopWaitingFrame& stop_waiting));
-  MOCK_CONST_METHOD0(HasNewMissingPackets, bool(void));
-  MOCK_CONST_METHOD0(ack_frame_updated, bool(void));
+  MOCK_METHOD(void,
+              RecordPacketReceived,
+              (const QuicPacketHeader& header, QuicTime receipt_time),
+              (override));
+  MOCK_METHOD(bool, IsMissing, (QuicPacketNumber packet_number), (override));
+  MOCK_METHOD(bool,
+              IsAwaitingPacket,
+              (QuicPacketNumber packet_number),
+              (const, override));
+  MOCK_METHOD(bool, HasNewMissingPackets, (), (const, override));
+  MOCK_METHOD(bool, ack_frame_updated, (), (const, override));
 };
 
 class MockPacketCreatorDelegate : public QuicPacketCreator::DelegateInterface {
@@ -1181,13 +1437,20 @@
       delete;
   ~MockPacketCreatorDelegate() override;
 
-  MOCK_METHOD0(GetPacketBuffer, char*());
-  MOCK_METHOD1(OnSerializedPacket, void(SerializedPacket* packet));
-  MOCK_METHOD2(OnUnrecoverableError, void(QuicErrorCode, const std::string&));
-  MOCK_METHOD2(ShouldGeneratePacket,
-               bool(HasRetransmittableData retransmittable,
-                    IsHandshake handshake));
-  MOCK_METHOD0(MaybeBundleAckOpportunistically, const QuicFrames());
+  MOCK_METHOD(char*, GetPacketBuffer, (), (override));
+  MOCK_METHOD(void, OnSerializedPacket, (SerializedPacket*), (override));
+  MOCK_METHOD(void,
+              OnUnrecoverableError,
+              (QuicErrorCode, const std::string&),
+              (override));
+  MOCK_METHOD(bool,
+              ShouldGeneratePacket,
+              (HasRetransmittableData retransmittable, IsHandshake handshake),
+              (override));
+  MOCK_METHOD(const QuicFrames,
+              MaybeBundleAckOpportunistically,
+              (),
+              (override));
 };
 
 class MockSessionNotifier : public SessionNotifierInterface {
@@ -1195,14 +1458,22 @@
   MockSessionNotifier();
   ~MockSessionNotifier() override;
 
-  MOCK_METHOD3(OnFrameAcked, bool(const QuicFrame&, QuicTime::Delta, QuicTime));
-  MOCK_METHOD1(OnStreamFrameRetransmitted, void(const QuicStreamFrame&));
-  MOCK_METHOD1(OnFrameLost, void(const QuicFrame&));
-  MOCK_METHOD2(RetransmitFrames,
-               void(const QuicFrames&, TransmissionType type));
-  MOCK_CONST_METHOD1(IsFrameOutstanding, bool(const QuicFrame&));
-  MOCK_CONST_METHOD0(HasUnackedCryptoData, bool());
-  MOCK_CONST_METHOD0(HasUnackedStreamData, bool());
+  MOCK_METHOD(bool,
+              OnFrameAcked,
+              (const QuicFrame&, QuicTime::Delta, QuicTime),
+              (override));
+  MOCK_METHOD(void,
+              OnStreamFrameRetransmitted,
+              (const QuicStreamFrame&),
+              (override));
+  MOCK_METHOD(void, OnFrameLost, (const QuicFrame&), (override));
+  MOCK_METHOD(void,
+              RetransmitFrames,
+              (const QuicFrames&, TransmissionType type),
+              (override));
+  MOCK_METHOD(bool, IsFrameOutstanding, (const QuicFrame&), (const, override));
+  MOCK_METHOD(bool, HasUnackedCryptoData, (), (const, override));
+  MOCK_METHOD(bool, HasUnackedStreamData, (), (const, override));
 };
 
 class QuicCryptoClientStreamPeer {
diff --git a/quic/test_tools/quic_transport_test_tools.h b/quic/test_tools/quic_transport_test_tools.h
index e7e01f7..50db80a 100644
--- a/quic/test_tools/quic_transport_test_tools.h
+++ b/quic/test_tools/quic_transport_test_tools.h
@@ -14,25 +14,28 @@
 
 class MockClientVisitor : public QuicTransportClientSession::ClientVisitor {
  public:
-  MOCK_METHOD0(OnSessionReady, void());
-  MOCK_METHOD0(OnIncomingBidirectionalStreamAvailable, void());
-  MOCK_METHOD0(OnIncomingUnidirectionalStreamAvailable, void());
-  MOCK_METHOD1(OnDatagramReceived, void(quiche::QuicheStringPiece));
-  MOCK_METHOD0(OnCanCreateNewOutgoingBidirectionalStream, void());
-  MOCK_METHOD0(OnCanCreateNewOutgoingUnidirectionalStream, void());
+  MOCK_METHOD(void, OnSessionReady, (), (override));
+  MOCK_METHOD(void, OnIncomingBidirectionalStreamAvailable, (), (override));
+  MOCK_METHOD(void, OnIncomingUnidirectionalStreamAvailable, (), (override));
+  MOCK_METHOD(void,
+              OnDatagramReceived,
+              (quiche::QuicheStringPiece),
+              (override));
+  MOCK_METHOD(void, OnCanCreateNewOutgoingBidirectionalStream, (), (override));
+  MOCK_METHOD(void, OnCanCreateNewOutgoingUnidirectionalStream, (), (override));
 };
 
 class MockServerVisitor : public QuicTransportServerSession::ServerVisitor {
  public:
-  MOCK_METHOD1(CheckOrigin, bool(url::Origin));
-  MOCK_METHOD1(ProcessPath, bool(const GURL&));
+  MOCK_METHOD(bool, CheckOrigin, (url::Origin), (override));
+  MOCK_METHOD(bool, ProcessPath, (const GURL&), (override));
 };
 
 class MockStreamVisitor : public QuicTransportStream::Visitor {
  public:
-  MOCK_METHOD0(OnCanRead, void());
-  MOCK_METHOD0(OnFinRead, void());
-  MOCK_METHOD0(OnCanWrite, void());
+  MOCK_METHOD(void, OnCanRead, (), (override));
+  MOCK_METHOD(void, OnFinRead, (), (override));
+  MOCK_METHOD(void, OnCanWrite, (), (override));
 };
 
 }  // namespace test
diff --git a/quic/test_tools/simple_session_notifier_test.cc b/quic/test_tools/simple_session_notifier_test.cc
index 4dc48a7..b72a952 100644
--- a/quic/test_tools/simple_session_notifier_test.cc
+++ b/quic/test_tools/simple_session_notifier_test.cc
@@ -29,11 +29,13 @@
                                        Perspective perspective)
       : MockQuicConnection(helper, alarm_factory, perspective) {}
 
-  MOCK_METHOD4(SendStreamData,
-               QuicConsumedData(QuicStreamId id,
-                                size_t write_length,
-                                QuicStreamOffset offset,
-                                StreamSendingState state));
+  MOCK_METHOD(QuicConsumedData,
+              SendStreamData,
+              (QuicStreamId id,
+               size_t write_length,
+               QuicStreamOffset offset,
+               StreamSendingState state),
+              (override));
 };
 
 class SimpleSessionNotifierTest : public QuicTest {
diff --git a/quic/test_tools/simulator/simulator_test.cc b/quic/test_tools/simulator/simulator_test.cc
index 06ef4b2..0bfce16 100644
--- a/quic/test_tools/simulator/simulator_test.cc
+++ b/quic/test_tools/simulator/simulator_test.cc
@@ -595,7 +595,7 @@
  public:
   MockPacketFilter(Simulator* simulator, std::string name, Endpoint* endpoint)
       : PacketFilter(simulator, name, endpoint) {}
-  MOCK_METHOD1(FilterPacket, bool(const Packet&));
+  MOCK_METHOD(bool, FilterPacket, (const Packet&), (override));
 };
 
 // Set up two trivial packet filters, one allowing any packets, and one dropping
diff --git a/quic/tools/quic_server_test.cc b/quic/tools/quic_server_test.cc
index fb7955f..3c43720 100644
--- a/quic/tools/quic_server_test.cc
+++ b/quic/tools/quic_server_test.cc
@@ -48,10 +48,10 @@
                              kQuicDefaultConnectionIdLength) {}
   ~MockQuicSimpleDispatcher() override = default;
 
-  MOCK_METHOD0(OnCanWrite, void());
-  MOCK_CONST_METHOD0(HasPendingWrites, bool());
-  MOCK_CONST_METHOD0(HasChlosBuffered, bool());
-  MOCK_METHOD1(ProcessBufferedChlos, void(size_t));
+  MOCK_METHOD(void, OnCanWrite, (), (override));
+  MOCK_METHOD(bool, HasPendingWrites, (), (const, override));
+  MOCK_METHOD(bool, HasChlosBuffered, (), (const, override));
+  MOCK_METHOD(void, ProcessBufferedChlos, (size_t), (override));
 };
 
 class TestQuicServer : public QuicServer {
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index 966128b..f5dad7d 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -95,8 +95,10 @@
       delete;
   ~MockQuicCryptoServerStream() override {}
 
-  MOCK_METHOD1(SendServerConfigUpdate,
-               void(const CachedNetworkParameters* cached_network_parameters));
+  MOCK_METHOD(void,
+              SendServerConfigUpdate,
+              (const CachedNetworkParameters*),
+              (override));
 
   bool encryption_established() const override { return true; }
 };
@@ -110,8 +112,10 @@
   MockTlsServerHandshaker& operator=(const MockTlsServerHandshaker&) = delete;
   ~MockTlsServerHandshaker() override {}
 
-  MOCK_METHOD1(SendServerConfigUpdate,
-               void(const CachedNetworkParameters* cached_network_parameters));
+  MOCK_METHOD(void,
+              SendServerConfigUpdate,
+              (const CachedNetworkParameters*),
+              (override));
 
   bool encryption_established() const override { return true; }
 };
@@ -156,11 +160,13 @@
         .WillByDefault(Invoke(consume_all_data));
   }
 
-  MOCK_METHOD4(SendStreamData,
-               QuicConsumedData(QuicStreamId id,
-                                size_t write_length,
-                                QuicStreamOffset offset,
-                                StreamSendingState state));
+  MOCK_METHOD(QuicConsumedData,
+              SendStreamData,
+              (QuicStreamId id,
+               size_t write_length,
+               QuicStreamOffset offset,
+               StreamSendingState state),
+              (override));
 };
 
 class MockQuicSimpleServerSession : public QuicSimpleServerSession {
@@ -189,12 +195,14 @@
     return WritePushPromiseMock(original_stream_id, promised_stream_id,
                                 headers);
   }
-  MOCK_METHOD3(WritePushPromiseMock,
-               void(QuicStreamId original_stream_id,
-                    QuicStreamId promised_stream_id,
-                    const spdy::SpdyHeaderBlock& headers));
+  MOCK_METHOD(void,
+              WritePushPromiseMock,
+              (QuicStreamId original_stream_id,
+               QuicStreamId promised_stream_id,
+               const spdy::SpdyHeaderBlock& headers),
+              ());
 
-  MOCK_METHOD1(SendBlocked, void(QuicStreamId));
+  MOCK_METHOD(void, SendBlocked, (QuicStreamId), (override));
 };
 
 class QuicSimpleServerSessionTest
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index 8c45942..3dfaa1e 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -55,7 +55,7 @@
 
   ~TestStream() override = default;
 
-  MOCK_METHOD1(WriteHeadersMock, void(bool fin));
+  MOCK_METHOD(void, WriteHeadersMock, (bool fin), ());
 
   size_t WriteHeaders(spdy::SpdyHeaderBlock /*header_block*/,
                       bool fin,
@@ -120,30 +120,42 @@
       delete;
   ~MockQuicSimpleServerSession() override = default;
 
-  MOCK_METHOD2(OnConnectionClosed,
-               void(const QuicConnectionCloseFrame& frame,
-                    ConnectionCloseSource source));
-  MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id));
-  MOCK_METHOD6(WritevData,
-               QuicConsumedData(QuicStreamId id,
-                                size_t write_length,
-                                QuicStreamOffset offset,
-                                StreamSendingState state,
-                                TransmissionType type,
-                                quiche::QuicheOptional<EncryptionLevel> level));
-  MOCK_METHOD4(OnStreamHeaderList,
-               void(QuicStreamId stream_id,
-                    bool fin,
-                    size_t frame_len,
-                    const QuicHeaderList& header_list));
-  MOCK_METHOD2(OnStreamHeadersPriority,
-               void(QuicStreamId stream_id,
-                    const spdy::SpdyStreamPrecedence& precedence));
-  MOCK_METHOD3(SendRstStream,
-               void(QuicStreamId stream_id,
-                    QuicRstStreamErrorCode error,
-                    QuicStreamOffset bytes_written));
-  MOCK_METHOD1(OnHeadersHeadOfLineBlocking, void(QuicTime::Delta delta));
+  MOCK_METHOD(void,
+              OnConnectionClosed,
+              (const QuicConnectionCloseFrame& frame,
+               ConnectionCloseSource source),
+              (override));
+  MOCK_METHOD(QuicSpdyStream*,
+              CreateIncomingStream,
+              (QuicStreamId id),
+              (override));
+  MOCK_METHOD(QuicConsumedData,
+              WritevData,
+              (QuicStreamId id,
+               size_t write_length,
+               QuicStreamOffset offset,
+               StreamSendingState state,
+               TransmissionType type,
+               quiche::QuicheOptional<EncryptionLevel> level),
+              (override));
+  MOCK_METHOD(void,
+              OnStreamHeaderList,
+              (QuicStreamId stream_id,
+               bool fin,
+               size_t frame_len,
+               const QuicHeaderList& header_list),
+              (override));
+  MOCK_METHOD(void,
+              OnStreamHeadersPriority,
+              (QuicStreamId stream_id,
+               const spdy::SpdyStreamPrecedence& precedence),
+              (override));
+  MOCK_METHOD(void,
+              SendRstStream,
+              (QuicStreamId stream_id,
+               QuicRstStreamErrorCode error,
+               QuicStreamOffset bytes_written),
+              (override));
   // Matchers cannot be used on non-copyable types like SpdyHeaderBlock.
   void PromisePushResources(
       const std::string& request_url,
@@ -155,17 +167,17 @@
     PromisePushResourcesMock(request_url, resources, original_stream_id,
                              original_precedence, original_request_headers);
   }
-  MOCK_METHOD5(PromisePushResourcesMock,
-               void(const std::string&,
-                    const std::list<QuicBackendResponse::ServerPushInfo>&,
-                    QuicStreamId,
-                    const spdy::SpdyStreamPrecedence&,
-                    const spdy::SpdyHeaderBlock&));
+  MOCK_METHOD(void,
+              PromisePushResourcesMock,
+              (const std::string&,
+               const std::list<QuicBackendResponse::ServerPushInfo>&,
+               QuicStreamId,
+               const spdy::SpdyStreamPrecedence&,
+               const spdy::SpdyHeaderBlock&),
+              ());
 
   using QuicSession::ActivateStream;
 
-  MOCK_METHOD1(OnStopSendingReceived, void(const QuicStopSendingFrame& frame));
-
   QuicConsumedData ConsumeData(
       QuicStreamId id,
       size_t write_length,