diff --git a/quiche/quic/core/quic_dispatcher_test.cc b/quiche/quic/core/quic_dispatcher_test.cc
index 3260f9c..f20c4c8 100644
--- a/quiche/quic/core/quic_dispatcher_test.cc
+++ b/quiche/quic/core/quic_dispatcher_test.cc
@@ -561,9 +561,9 @@
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
                 ProcessUdpPacket(_, _, _))
         .WillOnce(WithArg<2>(
-            Invoke([this, connection_id](const QuicEncryptedPacket& packet) {
+            [this, connection_id](const QuicEncryptedPacket& packet) {
               ValidatePacket(connection_id, packet);
-            })));
+            }));
     ProcessFirstFlight(version, client_address, connection_id);
   }
 
@@ -654,9 +654,9 @@
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_))));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
-      .WillOnce(WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
+      .WillOnce(WithArg<2>([this](const QuicEncryptedPacket& packet) {
         ValidatePacket(TestConnectionId(1), packet);
-      })));
+      }));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               OnParsedClientHelloInfo(MatchParsedClientHello()))
       .Times(1);
@@ -713,9 +713,9 @@
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_))));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
-      .WillOnce(WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
+      .WillOnce(WithArg<2>([this](const QuicEncryptedPacket& packet) {
         ValidatePacket(TestConnectionId(1), packet);
-      })));
+      }));
   ProcessFirstFlight(client_address, old_id);
 
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
@@ -822,9 +822,9 @@
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_))));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
-      .WillOnce(WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
+      .WillOnce(WithArg<2>([this](const QuicEncryptedPacket& packet) {
         ValidatePacket(TestConnectionId(1), packet);
-      })));
+      }));
   ProcessFirstFlight(client_address, TestConnectionId(1));
 
   EXPECT_CALL(
@@ -837,17 +837,17 @@
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session2_))));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session2_->connection()),
               ProcessUdpPacket(_, _, _))
-      .WillOnce(WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
+      .WillOnce(WithArg<2>([this](const QuicEncryptedPacket& packet) {
         ValidatePacket(TestConnectionId(2), packet);
-      })));
+      }));
   ProcessFirstFlight(client_address, TestConnectionId(2));
 
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .Times(1)
-      .WillOnce(WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
+      .WillOnce(WithArg<2>([this](const QuicEncryptedPacket& packet) {
         ValidatePacket(TestConnectionId(1), packet);
-      })));
+      }));
   ProcessPacket(client_address, TestConnectionId(1), false, "data");
 }
 
@@ -866,10 +866,9 @@
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .Times(2)
-      .WillRepeatedly(
-          WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
-            ValidatePacket(TestConnectionId(1), packet);
-          })));
+      .WillRepeatedly(WithArg<2>([this](const QuicEncryptedPacket& packet) {
+        ValidatePacket(TestConnectionId(1), packet);
+      }));
   ProcessFirstFlight(client_address, TestConnectionId(1));
   // Packet number 256 with packet number length 1 would be considered as 0 in
   // dispatcher.
@@ -1005,9 +1004,9 @@
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_))));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
-      .WillOnce(WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
+      .WillOnce(WithArg<2>([this](const QuicEncryptedPacket& packet) {
         ValidatePacket(TestConnectionId(1), packet);
-      })));
+      }));
 
   ProcessFirstFlight(client_address, TestConnectionId(1));
 
@@ -1031,9 +1030,9 @@
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_))));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
-      .WillOnce(WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
+      .WillOnce(WithArg<2>([this](const QuicEncryptedPacket& packet) {
         ValidatePacket(TestConnectionId(1), packet);
-      })));
+      }));
 
   ProcessFirstFlight(client_address, connection_id);
 
@@ -1218,9 +1217,9 @@
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .WillOnce(WithArg<2>(
-          Invoke([this, bad_connection_id](const QuicEncryptedPacket& packet) {
+          [this, bad_connection_id](const QuicEncryptedPacket& packet) {
             ValidatePacket(bad_connection_id, packet);
-          })));
+          }));
   ProcessFirstFlight(client_address, bad_connection_id);
 }
 
@@ -1243,9 +1242,9 @@
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_))));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
-      .WillOnce(WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
+      .WillOnce(WithArg<2>([this](const QuicEncryptedPacket& packet) {
         ValidatePacket(TestConnectionId(1), packet);
-      })));
+      }));
   ProcessFirstFlight(client_address, TestConnectionId(1));
 
   generated_connection_id_ = kReturnConnectionId;
@@ -1259,17 +1258,17 @@
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session2_->connection()),
               ProcessUdpPacket(_, _, _))
       .WillOnce(WithArg<2>(
-          Invoke([this, bad_connection_id](const QuicEncryptedPacket& packet) {
+          [this, bad_connection_id](const QuicEncryptedPacket& packet) {
             ValidatePacket(bad_connection_id, packet);
-          })));
+          }));
   ProcessFirstFlight(client_address, bad_connection_id);
 
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .Times(1)
-      .WillOnce(WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
+      .WillOnce(WithArg<2>([this](const QuicEncryptedPacket& packet) {
         ValidatePacket(TestConnectionId(1), packet);
-      })));
+      }));
   ProcessPacket(client_address, TestConnectionId(1), false, "data");
 }
 
@@ -1831,9 +1830,9 @@
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_))));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
-      .WillOnce(WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
+      .WillOnce(WithArg<2>([this](const QuicEncryptedPacket& packet) {
         ValidatePacket(TestConnectionId(1), packet);
-      })));
+      }));
   ProcessFirstFlight(client_address, TestConnectionId(1));
 
   dispatcher_->StopAcceptingNewConnections();
@@ -1851,9 +1850,9 @@
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .Times(1u)
-      .WillOnce(WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
+      .WillOnce(WithArg<2>([this](const QuicEncryptedPacket& packet) {
         ValidatePacket(TestConnectionId(1), packet);
-      })));
+      }));
   ProcessPacket(client_address, TestConnectionId(1), false, "data");
 }
 
@@ -1882,9 +1881,9 @@
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_))));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
-      .WillOnce(WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
+      .WillOnce(WithArg<2>([this](const QuicEncryptedPacket& packet) {
         ValidatePacket(TestConnectionId(1), packet);
-      })));
+      }));
   ProcessFirstFlight(client_address, TestConnectionId(1));
 }
 
@@ -1992,9 +1991,9 @@
             QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_))));
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
                 ProcessUdpPacket(_, _, _))
-        .WillOnce(WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
+        .WillOnce(WithArg<2>([this](const QuicEncryptedPacket& packet) {
           ValidatePacket(TestConnectionId(1), packet);
-        })));
+        }));
     ProcessFirstFlight(client_address, TestConnectionId(1));
 
     EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, client_address,
@@ -2005,9 +2004,9 @@
             QuicDispatcherPeer::GetCache(dispatcher_.get()), &session2_))));
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session2_->connection()),
                 ProcessUdpPacket(_, _, _))
-        .WillOnce(WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
+        .WillOnce(WithArg<2>([this](const QuicEncryptedPacket& packet) {
           ValidatePacket(TestConnectionId(2), packet);
-        })));
+        }));
     ProcessFirstFlight(client_address, TestConnectionId(2));
 
     blocked_list_ = QuicDispatcherPeer::GetWriteBlockedList(dispatcher_.get());
@@ -2272,9 +2271,9 @@
             QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_))));
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
                 ProcessUdpPacket(_, _, _))
-        .WillOnce(WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
+        .WillOnce(WithArg<2>([this](const QuicEncryptedPacket& packet) {
           ValidatePacket(TestConnectionId(1), packet);
-        })));
+        }));
     ProcessFirstFlight(client_address, TestConnectionId(1));
   }
 
@@ -2288,9 +2287,9 @@
             QuicDispatcherPeer::GetCache(dispatcher_.get()), &session2_))));
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session2_->connection()),
                 ProcessUdpPacket(_, _, _))
-        .WillOnce(WithArg<2>(Invoke([this](const QuicEncryptedPacket& packet) {
+        .WillOnce(WithArg<2>([this](const QuicEncryptedPacket& packet) {
           ValidatePacket(TestConnectionId(2), packet);
-        })));
+        }));
     ProcessFirstFlight(client_address, TestConnectionId(2));
   }
 
@@ -2589,11 +2588,11 @@
               ProcessUdpPacket(_, _, _))
       .Times(2)  // non-CHLO + CHLO.
       .WillRepeatedly(
-          WithArg<2>(Invoke([this, conn_id](const QuicEncryptedPacket& packet) {
+          WithArg<2>([this, conn_id](const QuicEncryptedPacket& packet) {
             if (version_.UsesQuicCrypto()) {
               ValidatePacket(conn_id, packet);
             }
-          })));
+          }));
   expect_generator_is_called_ = false;
   ProcessFirstFlight(conn_id);
 }
@@ -2627,11 +2626,11 @@
               ProcessUdpPacket(_, _, _))
       .Times(kDefaultMaxUndecryptablePackets + 1)  // + 1 for CHLO.
       .WillRepeatedly(
-          WithArg<2>(Invoke([this, conn_id](const QuicEncryptedPacket& packet) {
+          WithArg<2>([this, conn_id](const QuicEncryptedPacket& packet) {
             if (version_.UsesQuicCrypto()) {
               ValidatePacket(conn_id, packet);
             }
-          })));
+          }));
   expect_generator_is_called_ = false;
   ProcessFirstFlight(conn_id);
 }
@@ -2677,12 +2676,12 @@
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
                 ProcessUdpPacket(_, client_address, _))
         .Times(num_packet_to_process)
-        .WillRepeatedly(WithArg<2>(
-            Invoke([this, conn_id](const QuicEncryptedPacket& packet) {
+        .WillRepeatedly(
+            WithArg<2>([this, conn_id](const QuicEncryptedPacket& packet) {
               if (version_.UsesQuicCrypto()) {
                 ValidatePacket(conn_id, packet);
               }
-            })));
+            }));
     ProcessFirstFlight(client_address, conn_id);
   }
 }
@@ -2724,11 +2723,11 @@
               ProcessUdpPacket(_, _, _))
       .Times(3)  // Triggered by 1 data packet and 2 CHLOs.
       .WillRepeatedly(
-          WithArg<2>(Invoke([this, conn_id](const QuicEncryptedPacket& packet) {
+          WithArg<2>([this, conn_id](const QuicEncryptedPacket& packet) {
             if (version_.UsesQuicCrypto()) {
               ValidatePacket(conn_id, packet);
             }
-          })));
+          }));
 
   std::vector<std::unique_ptr<QuicReceivedPacket>> packets =
       GetFirstFlightOfPackets(version_, conn_id);
@@ -2800,12 +2799,12 @@
       EXPECT_CALL(
           *reinterpret_cast<MockQuicConnection*>(session1_->connection()),
           ProcessUdpPacket(_, _, _))
-          .WillOnce(WithArg<2>(
-              Invoke([this, conn_id](const QuicEncryptedPacket& packet) {
+          .WillOnce(
+              WithArg<2>([this, conn_id](const QuicEncryptedPacket& packet) {
                 if (version_.UsesQuicCrypto()) {
                   ValidatePacket(TestConnectionId(conn_id), packet);
                 }
-              })));
+              }));
     }
     expect_generator_is_called_ = false;
     ProcessFirstFlight(TestConnectionId(conn_id));
@@ -2837,12 +2836,12 @@
             QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_))));
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
                 ProcessUdpPacket(_, _, _))
-        .WillOnce(WithArg<2>(
-            Invoke([this, conn_id](const QuicEncryptedPacket& packet) {
+        .WillOnce(
+            WithArg<2>([this, conn_id](const QuicEncryptedPacket& packet) {
               if (version_.UsesQuicCrypto()) {
                 ValidatePacket(TestConnectionId(conn_id), packet);
               }
-            })));
+            }));
   }
   EXPECT_CALL(connection_id_generator_,
               MaybeReplaceConnectionId(TestConnectionId(kNumCHLOs), version_))
@@ -2880,12 +2879,12 @@
             QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_))));
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
                 ProcessUdpPacket(_, _, _))
-        .WillOnce(WithArg<2>(
-            Invoke([this, conn_id](const QuicEncryptedPacket& packet) {
+        .WillOnce(
+            WithArg<2>([this, conn_id](const QuicEncryptedPacket& packet) {
               if (version_.UsesQuicCrypto()) {
                 ValidatePacket(TestConnectionId(conn_id), packet);
               }
-            })));
+            }));
     ProcessFirstFlight(TestConnectionId(conn_id));
   }
   uint64_t conn_id = kNumCHLOs;
@@ -2924,12 +2923,11 @@
           QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_))));
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
-      .WillOnce(
-          WithArg<2>(Invoke([this, conn_id](const QuicEncryptedPacket& packet) {
-            if (version_.UsesQuicCrypto()) {
-              ValidatePacket(TestConnectionId(conn_id), packet);
-            }
-          })));
+      .WillOnce(WithArg<2>([this, conn_id](const QuicEncryptedPacket& packet) {
+        if (version_.UsesQuicCrypto()) {
+          ValidatePacket(TestConnectionId(conn_id), packet);
+        }
+      }));
   while (store->HasChlosBuffered()) {
     dispatcher_->ProcessBufferedChlos(kMaxNumSessionsToCreate);
   }
@@ -2952,12 +2950,12 @@
       EXPECT_CALL(
           *reinterpret_cast<MockQuicConnection*>(session1_->connection()),
           ProcessUdpPacket(_, _, _))
-          .WillOnce(WithArg<2>(
-              Invoke([this, conn_id](const QuicEncryptedPacket& packet) {
+          .WillOnce(
+              WithArg<2>([this, conn_id](const QuicEncryptedPacket& packet) {
                 if (version_.UsesQuicCrypto()) {
                   ValidatePacket(TestConnectionId(conn_id), packet);
                 }
-              })));
+              }));
     }
     ProcessFirstFlight(TestConnectionId(conn_id));
   }
@@ -2981,11 +2979,11 @@
               ProcessUdpPacket(_, _, _))
       .Times(packets_buffered)
       .WillRepeatedly(WithArg<2>(
-          Invoke([this, last_connection](const QuicEncryptedPacket& packet) {
+          [this, last_connection](const QuicEncryptedPacket& packet) {
             if (version_.UsesQuicCrypto()) {
               ValidatePacket(last_connection, packet);
             }
-          })));
+          }));
   dispatcher_->ProcessBufferedChlos(kMaxNumSessionsToCreate);
 }
 
@@ -3006,12 +3004,12 @@
       EXPECT_CALL(
           *reinterpret_cast<MockQuicConnection*>(session1_->connection()),
           ProcessUdpPacket(_, _, _))
-          .WillRepeatedly(WithArg<2>(
-              Invoke([this, conn_id](const QuicEncryptedPacket& packet) {
+          .WillRepeatedly(
+              WithArg<2>([this, conn_id](const QuicEncryptedPacket& packet) {
                 if (version_.UsesQuicCrypto()) {
                   ValidatePacket(TestConnectionId(conn_id), packet);
                 }
-              })));
+              }));
     }
     ProcessFirstFlight(TestConnectionId(conn_id));
   }
@@ -3046,11 +3044,11 @@
               ProcessUdpPacket(_, _, _))
       .Times(last_connection_buffered_packets->buffered_packets.size())
       .WillRepeatedly(WithArg<2>(
-          Invoke([this, last_connection_id](const QuicEncryptedPacket& packet) {
+          [this, last_connection_id](const QuicEncryptedPacket& packet) {
             if (version_.UsesQuicCrypto()) {
               ValidatePacket(last_connection_id, packet);
             }
-          })));
+          }));
   dispatcher_->ProcessBufferedChlos(kMaxNumSessionsToCreate);
 }
 
@@ -3080,12 +3078,12 @@
       EXPECT_CALL(
           *reinterpret_cast<MockQuicConnection*>(session1_->connection()),
           ProcessUdpPacket(_, _, _))
-          .WillOnce(WithArg<2>(
-              Invoke([this, conn_id](const QuicEncryptedPacket& packet) {
+          .WillOnce(
+              WithArg<2>([this, conn_id](const QuicEncryptedPacket& packet) {
                 if (version_.UsesQuicCrypto()) {
                   ValidatePacket(TestConnectionId(conn_id), packet);
                 }
-              })));
+              }));
     } else if (!version_.UsesTls()) {
       expect_generator_is_called_ = false;
     }
@@ -3124,12 +3122,12 @@
       EXPECT_CALL(
           *reinterpret_cast<MockQuicConnection*>(session1_->connection()),
           ProcessUdpPacket(_, _, _))
-          .WillRepeatedly(WithArg<2>(
-              Invoke([this, conn_id](const QuicEncryptedPacket& packet) {
+          .WillRepeatedly(
+              WithArg<2>([this, conn_id](const QuicEncryptedPacket& packet) {
                 if (version_.UsesQuicCrypto()) {
                   ValidatePacket(TestConnectionId(conn_id), packet);
                 }
-              })));
+              }));
     }
     ProcessFirstFlight(version, TestConnectionId(conn_id));
   }
@@ -3149,12 +3147,12 @@
             QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_))));
     EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
                 ProcessUdpPacket(_, _, _))
-        .WillRepeatedly(WithArg<2>(
-            Invoke([this, conn_id](const QuicEncryptedPacket& packet) {
+        .WillRepeatedly(
+            WithArg<2>([this, conn_id](const QuicEncryptedPacket& packet) {
               if (version_.UsesQuicCrypto()) {
                 ValidatePacket(TestConnectionId(conn_id), packet);
               }
-            })));
+            }));
   }
   dispatcher_->ProcessBufferedChlos(kMaxNumSessionsToCreate);
 }
@@ -3193,7 +3191,7 @@
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .Times(2)  // non-CHLO + CHLO.
-      .WillRepeatedly(WithArg<2>(Invoke([&](const QuicReceivedPacket& packet) {
+      .WillRepeatedly(WithArg<2>([&](const QuicReceivedPacket& packet) {
         switch (packet.ecn_codepoint()) {
           case ECN_ECT1:
             got_ect1 = true;
@@ -3204,7 +3202,7 @@
           default:
             break;
         }
-      })));
+      }));
   QuicConnectionId client_connection_id = TestConnectionId(2);
   std::vector<std::unique_ptr<QuicReceivedPacket>> packets =
       GetFirstFlightOfPackets(version_, DefaultQuicConfig(), conn_id,
diff --git a/quiche/quic/core/quic_flow_controller_test.cc b/quiche/quic/core/quic_flow_controller_test.cc
index 567b120..87207d6 100644
--- a/quiche/quic/core/quic_flow_controller_test.cc
+++ b/quiche/quic/core/quic_flow_controller_test.cc
@@ -17,7 +17,6 @@
 #include "quiche/quic/test_tools/quic_test_utils.h"
 
 using testing::_;
-using testing::Invoke;
 using testing::StrictMock;
 
 namespace quic {
@@ -251,7 +250,7 @@
   // This test will generate two WINDOW_UPDATE frames.
   EXPECT_CALL(*session_, WriteControlFrame(_, _))
       .Times(2)
-      .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
+      .WillRepeatedly(&ClearControlFrameWithTransmissionType);
   EXPECT_FALSE(flow_controller_->auto_tune_receive_window());
 
   // Make sure clock is inititialized.
@@ -361,7 +360,7 @@
   // This test will generate two WINDOW_UPDATE frames.
   EXPECT_CALL(*session_, WriteControlFrame(_, _))
       .Times(2)
-      .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
+      .WillRepeatedly(&ClearControlFrameWithTransmissionType);
   EXPECT_FALSE(flow_controller_->auto_tune_receive_window());
 
   // Make sure clock is inititialized.
diff --git a/quiche/quic/core/quic_framer_test.cc b/quiche/quic/core/quic_framer_test.cc
index e43c385..e368fe3 100644
--- a/quiche/quic/core/quic_framer_test.cc
+++ b/quiche/quic/core/quic_framer_test.cc
@@ -8709,8 +8709,7 @@
     std::string bytes(len, 0x7c);
     memcpy(data, bytes.data(), bytes.size());
   };
-  EXPECT_CALL(random, InsecureRandBytes(_, _))
-      .WillOnce(testing::Invoke(generate_random_bytes));
+  EXPECT_CALL(random, InsecureRandBytes(_, _)).WillOnce(generate_random_bytes);
   std::unique_ptr<QuicEncryptedPacket> data(
       framer_.BuildIetfStatelessResetPacket(
           FramerTestConnectionId(),
diff --git a/quiche/quic/core/quic_linux_socket_utils_test.cc b/quiche/quic/core/quic_linux_socket_utils_test.cc
index 1a910fe..cb37fb1 100644
--- a/quiche/quic/core/quic_linux_socket_utils_test.cc
+++ b/quiche/quic/core/quic_linux_socket_utils_test.cc
@@ -20,7 +20,6 @@
 
 using testing::_;
 using testing::InSequence;
-using testing::Invoke;
 using testing::SetErrnoAndReturn;
 
 namespace quic {
@@ -224,11 +223,11 @@
                                QuicSocketAddress(QuicIpAddress::Any4(), 0));
 
   EXPECT_CALL(mock_syscalls_, Sendmmsg(_, _, _, _))
-      .WillOnce(Invoke([](int /*fd*/, mmsghdr* /*msgvec*/,
-                          unsigned int /*vlen*/, int /*flags*/) {
+      .WillOnce([](int /*fd*/, mmsghdr* /*msgvec*/, unsigned int /*vlen*/,
+                   int /*flags*/) {
         errno = EWOULDBLOCK;
         return -1;
-      }));
+      });
 
   EXPECT_EQ(WriteResult(WRITE_STATUS_BLOCKED, EWOULDBLOCK),
             TestWriteMultiplePackets(1, buffered_writes.begin(),
@@ -243,11 +242,11 @@
                                QuicSocketAddress(QuicIpAddress::Any4(), 0));
 
   EXPECT_CALL(mock_syscalls_, Sendmmsg(_, _, _, _))
-      .WillOnce(Invoke([](int /*fd*/, mmsghdr* /*msgvec*/,
-                          unsigned int /*vlen*/, int /*flags*/) {
+      .WillOnce([](int /*fd*/, mmsghdr* /*msgvec*/, unsigned int /*vlen*/,
+                   int /*flags*/) {
         errno = EPERM;
         return -1;
-      }));
+      });
 
   EXPECT_EQ(WriteResult(WRITE_STATUS_ERROR, EPERM),
             TestWriteMultiplePackets(1, buffered_writes.begin(),
@@ -292,8 +291,8 @@
     SCOPED_TRACE(testing::Message()
                  << "expected_num_packets_sent=" << expected_num_packets_sent);
     EXPECT_CALL(mock_syscalls_, Sendmmsg(_, _, _, _))
-        .WillOnce(Invoke([&](int /*fd*/, mmsghdr* msgvec, unsigned int vlen,
-                             int /*flags*/) {
+        .WillOnce([&](int /*fd*/, mmsghdr* msgvec, unsigned int vlen,
+                      int /*flags*/) {
           EXPECT_LE(static_cast<unsigned int>(expected_num_packets_sent), vlen);
           for (unsigned int i = 0; i < vlen; ++i) {
             const BufferedWrite& buffered_write = buffered_writes[i];
@@ -309,7 +308,7 @@
                       hdr.msg_control != nullptr);
           }
           return expected_num_packets_sent;
-        }))
+        })
         .RetiresOnSaturation();
 
     int expected_bytes_written = 0;
diff --git a/quiche/quic/core/quic_packet_creator_test.cc b/quiche/quic/core/quic_packet_creator_test.cc
index 176e731..380b3d5 100644
--- a/quiche/quic/core/quic_packet_creator_test.cc
+++ b/quiche/quic/core/quic_packet_creator_test.cc
@@ -1779,9 +1779,9 @@
       /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
 
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke([&external_buffer](SerializedPacket serialized_packet) {
+      .WillOnce([&external_buffer](SerializedPacket serialized_packet) {
         EXPECT_EQ(external_buffer.buffer, serialized_packet.encrypted_buffer);
-      }));
+      });
   creator_.FlushCurrentPacket();
 }
 
@@ -2345,9 +2345,9 @@
     if (i < ENCRYPTION_FORWARD_SECURE) {
       // Save coalesced packet.
       EXPECT_CALL(framer_visitor_, OnCoalescedPacket(_))
-          .WillOnce(Invoke([i, &packets](const QuicEncryptedPacket& packet) {
+          .WillOnce([i, &packets](const QuicEncryptedPacket& packet) {
             packets[i + 1] = packet.Clone();
-          }));
+          });
     }
     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
@@ -2641,10 +2641,10 @@
       frames.push_back(QuicFrame(&ack_frame_));
     }
     EXPECT_CALL(*delegate_, MaybeBundleOpportunistically(_))
-        .WillOnce(Invoke([this, frames = std::move(frames)] {
+        .WillOnce([this, frames = std::move(frames)] {
           FlushAckFrame(frames);
           return QuicFrames();
-        }));
+        });
     return QuicPacketCreator::ConsumeRetransmittableControlFrame(frame);
   }
 
@@ -4344,12 +4344,12 @@
   // After exiting the scope, the last queued frame should be flushed.
   EXPECT_TRUE(creator_.HasPendingFrames());
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke([=](SerializedPacket packet) {
+      .WillOnce([=](SerializedPacket packet) {
         EXPECT_EQ(peer_addr, packet.peer_address);
         ASSERT_EQ(2u, packet.retransmittable_frames.size());
         EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
         EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.back().type);
-      }));
+      });
   creator_.FlushCurrentPacket();
 }
 
@@ -4369,16 +4369,16 @@
 
   QuicSocketAddress peer_addr1(QuicIpAddress::Any4(), 12346);
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke([=](SerializedPacket packet) {
+      .WillOnce([=](SerializedPacket packet) {
         EXPECT_EQ(peer_addr, packet.peer_address);
         ASSERT_EQ(1u, packet.retransmittable_frames.size());
         EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
-      }))
-      .WillOnce(Invoke([=](SerializedPacket packet) {
+      })
+      .WillOnce([=](SerializedPacket packet) {
         EXPECT_EQ(peer_addr1, packet.peer_address);
         ASSERT_EQ(1u, packet.retransmittable_frames.size());
         EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
-      }));
+      });
   EXPECT_TRUE(creator_.HasPendingFrames());
   {
     QuicConnectionId client_connection_id = TestConnectionId(1);
@@ -4426,7 +4426,7 @@
 
   QuicSocketAddress peer_addr1(QuicIpAddress::Any4(), 12346);
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke([=, this](SerializedPacket packet) {
+      .WillOnce([=, this](SerializedPacket packet) {
         EXPECT_EQ(peer_addr, packet.peer_address);
         ASSERT_EQ(1u, packet.retransmittable_frames.size());
         EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
@@ -4451,12 +4451,12 @@
         // This should trigger another OnSerializedPacket() with the 2nd
         // address.
         creator_.FlushCurrentPacket();
-      }))
-      .WillOnce(Invoke([=](SerializedPacket packet) {
+      })
+      .WillOnce([=](SerializedPacket packet) {
         EXPECT_EQ(peer_addr1, packet.peer_address);
         ASSERT_EQ(1u, packet.retransmittable_frames.size());
         EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
-      }));
+      });
   creator_.FlushCurrentPacket();
 }
 
diff --git a/quiche/quic/core/quic_path_validator_test.cc b/quiche/quic/core/quic_path_validator_test.cc
index 62044b1..faca361 100644
--- a/quiche/quic/core/quic_path_validator_test.cc
+++ b/quiche/quic/core/quic_path_validator_test.cc
@@ -18,7 +18,6 @@
 #include "quiche/quic/test_tools/quic_test_utils.h"
 
 using testing::_;
-using testing::Invoke;
 using testing::Return;
 
 namespace quic {
@@ -76,12 +75,12 @@
   EXPECT_CALL(send_delegate_,
               SendPathChallenge(_, self_address_, peer_address_,
                                 effective_peer_address_, &writer_))
-      .WillOnce(Invoke([&](const QuicPathFrameBuffer& payload,
-                           const QuicSocketAddress&, const QuicSocketAddress&,
-                           const QuicSocketAddress&, QuicPacketWriter*) {
+      .WillOnce([&](const QuicPathFrameBuffer& payload,
+                    const QuicSocketAddress&, const QuicSocketAddress&,
+                    const QuicSocketAddress&, QuicPacketWriter*) {
         memcpy(challenge_data.data(), payload.data(), payload.size());
         return true;
-      }));
+      });
   EXPECT_CALL(send_delegate_, GetRetryTimeout(peer_address_, &writer_));
   const QuicTime expected_start_time = clock_.Now();
   path_validator_.StartPathValidation(
@@ -93,12 +92,11 @@
             path_validator_.GetPathValidationReason());
   EXPECT_TRUE(path_validator_.IsValidatingPeerAddress(effective_peer_address_));
   EXPECT_CALL(*result_delegate_, OnPathValidationSuccess(_, _))
-      .WillOnce(
-          Invoke([=, this](std::unique_ptr<QuicPathValidationContext> context,
-                           QuicTime start_time) {
-            EXPECT_EQ(context.get(), context_);
-            EXPECT_EQ(start_time, expected_start_time);
-          }));
+      .WillOnce([=, this](std::unique_ptr<QuicPathValidationContext> context,
+                          QuicTime start_time) {
+        EXPECT_EQ(context.get(), context_);
+        EXPECT_EQ(start_time, expected_start_time);
+      });
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(kInitialRttMs));
   path_validator_.OnPathResponse(challenge_data, self_address_);
   EXPECT_FALSE(path_validator_.HasPendingPathValidation());
@@ -111,12 +109,12 @@
   EXPECT_CALL(send_delegate_,
               SendPathChallenge(_, self_address_, peer_address_,
                                 effective_peer_address_, &writer_))
-      .WillOnce(Invoke([&](const QuicPathFrameBuffer payload,
-                           const QuicSocketAddress&, const QuicSocketAddress&,
-                           const QuicSocketAddress&, QuicPacketWriter*) {
+      .WillOnce([&](const QuicPathFrameBuffer payload, const QuicSocketAddress&,
+                    const QuicSocketAddress&, const QuicSocketAddress&,
+                    QuicPacketWriter*) {
         memcpy(challenge_data.data(), payload.data(), payload.size());
         return true;
-      }));
+      });
   EXPECT_CALL(send_delegate_, GetRetryTimeout(peer_address_, &writer_));
   const QuicTime expected_start_time = clock_.Now();
   path_validator_.StartPathValidation(
@@ -131,12 +129,11 @@
   path_validator_.OnPathResponse(challenge_data, kAlternativeSelfAddress);
 
   EXPECT_CALL(*result_delegate_, OnPathValidationSuccess(_, _))
-      .WillOnce(
-          Invoke([=, this](std::unique_ptr<QuicPathValidationContext> context,
-                           QuicTime start_time) {
-            EXPECT_EQ(context->self_address(), self_address_);
-            EXPECT_EQ(start_time, expected_start_time);
-          }));
+      .WillOnce([=, this](std::unique_ptr<QuicPathValidationContext> context,
+                          QuicTime start_time) {
+        EXPECT_EQ(context->self_address(), self_address_);
+        EXPECT_EQ(start_time, expected_start_time);
+      });
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(kInitialRttMs));
   path_validator_.OnPathResponse(challenge_data, self_address_);
   EXPECT_EQ(PathValidationReason::kReasonUnknown,
@@ -148,19 +145,19 @@
   EXPECT_CALL(send_delegate_,
               SendPathChallenge(_, self_address_, peer_address_,
                                 effective_peer_address_, &writer_))
-      .WillOnce(Invoke([&](const QuicPathFrameBuffer& payload,
-                           const QuicSocketAddress&, const QuicSocketAddress&,
-                           const QuicSocketAddress&, QuicPacketWriter*) {
+      .WillOnce([&](const QuicPathFrameBuffer& payload,
+                    const QuicSocketAddress&, const QuicSocketAddress&,
+                    const QuicSocketAddress&, QuicPacketWriter*) {
         // Store up the 1st PATH_CHALLANGE payload.
         memcpy(challenge_data.data(), payload.data(), payload.size());
         return true;
-      }))
-      .WillOnce(Invoke([&](const QuicPathFrameBuffer& payload,
-                           const QuicSocketAddress&, const QuicSocketAddress&,
-                           const QuicSocketAddress&, QuicPacketWriter*) {
+      })
+      .WillOnce([&](const QuicPathFrameBuffer& payload,
+                    const QuicSocketAddress&, const QuicSocketAddress&,
+                    const QuicSocketAddress&, QuicPacketWriter*) {
         EXPECT_NE(payload, challenge_data);
         return true;
-      }));
+      });
   EXPECT_CALL(send_delegate_, GetRetryTimeout(peer_address_, &writer_))
       .Times(2u);
   const QuicTime start_time = clock_.Now();
@@ -185,19 +182,19 @@
   EXPECT_CALL(send_delegate_,
               SendPathChallenge(_, self_address_, peer_address_,
                                 effective_peer_address_, &writer_))
-      .WillOnce(Invoke([&](const QuicPathFrameBuffer& payload,
-                           const QuicSocketAddress&, const QuicSocketAddress&,
-                           const QuicSocketAddress&, QuicPacketWriter*) {
+      .WillOnce([&](const QuicPathFrameBuffer& payload,
+                    const QuicSocketAddress&, const QuicSocketAddress&,
+                    const QuicSocketAddress&, QuicPacketWriter*) {
         memcpy(challenge_data.data(), payload.data(), payload.size());
         return true;
-      }))
-      .WillOnce(Invoke([&](const QuicPathFrameBuffer& payload,
-                           const QuicSocketAddress&, const QuicSocketAddress&,
-                           const QuicSocketAddress&, QuicPacketWriter*) {
+      })
+      .WillOnce([&](const QuicPathFrameBuffer& payload,
+                    const QuicSocketAddress&, const QuicSocketAddress&,
+                    const QuicSocketAddress&, QuicPacketWriter*) {
         EXPECT_NE(challenge_data, payload);
         memcpy(challenge_data.data(), payload.data(), payload.size());
         return true;
-      }));
+      });
   EXPECT_CALL(send_delegate_, GetRetryTimeout(peer_address_, &writer_))
       .Times(2u);
   path_validator_.StartPathValidation(
@@ -237,10 +234,9 @@
 
   // Retry 3 times. The 3rd time should fail the validation.
   EXPECT_CALL(*result_delegate_, OnPathValidationFailure(_))
-      .WillOnce(
-          Invoke([=, this](std::unique_ptr<QuicPathValidationContext> context) {
-            EXPECT_EQ(context_, context.get());
-          }));
+      .WillOnce([=, this](std::unique_ptr<QuicPathValidationContext> context) {
+        EXPECT_EQ(context_, context.get());
+      });
   for (size_t i = 0; i <= QuicPathValidator::kMaxRetryTimes; ++i) {
     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(3 * kInitialRttMs));
     alarm_factory_.FireAlarm(
@@ -254,14 +250,14 @@
   EXPECT_CALL(send_delegate_,
               SendPathChallenge(_, self_address_, peer_address_,
                                 effective_peer_address_, &writer_))
-      .WillOnce(Invoke([&](const QuicPathFrameBuffer&, const QuicSocketAddress&,
-                           const QuicSocketAddress&, const QuicSocketAddress&,
-                           QuicPacketWriter*) {
+      .WillOnce([&](const QuicPathFrameBuffer&, const QuicSocketAddress&,
+                    const QuicSocketAddress&, const QuicSocketAddress&,
+                    QuicPacketWriter*) {
         // Abandon this validation in the call stack shouldn't cause crash and
         // should cancel the alarm.
         path_validator_.CancelPathValidation();
         return false;
-      }));
+      });
   EXPECT_CALL(send_delegate_, GetRetryTimeout(peer_address_, &writer_))
       .Times(0u);
   EXPECT_CALL(*result_delegate_, OnPathValidationFailure(_));
diff --git a/quiche/quic/core/quic_sent_packet_manager_test.cc b/quiche/quic/core/quic_sent_packet_manager_test.cc
index 529d7bd..aa38362 100644
--- a/quiche/quic/core/quic_sent_packet_manager_test.cc
+++ b/quiche/quic/core/quic_sent_packet_manager_test.cc
@@ -47,7 +47,6 @@
 
 using testing::_;
 using testing::AnyNumber;
-using testing::Invoke;
 using testing::InvokeWithoutArgs;
 using testing::IsEmpty;
 using testing::Pointwise;
@@ -245,10 +244,10 @@
     if (transmission_type == HANDSHAKE_RETRANSMISSION ||
         transmission_type == PTO_RETRANSMISSION) {
       EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-          .WillOnce(WithArgs<1>(
-              Invoke([this, new_packet_number](TransmissionType type) {
+          .WillOnce(
+              WithArgs<1>([this, new_packet_number](TransmissionType type) {
                 return RetransmitDataPacket(new_packet_number, type);
-              })));
+              }));
     } else {
       EXPECT_CALL(notifier_, OnFrameLost(_)).Times(1);
       is_lost = true;
@@ -406,9 +405,9 @@
 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckBeforeSend) {
   SendDataPacket(1);
   EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
+      .WillOnce(WithArgs<1>([this](TransmissionType type) {
         return RetransmitDataPacket(2, type);
-      })));
+      }));
   QuicSentPacketManagerPeer::MarkForRetransmission(&manager_, 1,
                                                    PTO_RETRANSMISSION);
   // Ack 1.
@@ -1550,13 +1549,12 @@
   EXPECT_CALL(
       *send_algorithm_,
       OnCongestionEvent(/*rtt_updated=*/false, kDefaultLength, _, _, _, _, _))
-      .WillOnce(testing::WithArg<3>(
-          Invoke([](const AckedPacketVector& acked_packets) {
-            EXPECT_EQ(1u, acked_packets.size());
-            EXPECT_EQ(QuicPacketNumber(1), acked_packets[0].packet_number);
-            // The bytes in packet1 shouldn't contribute to congestion control.
-            EXPECT_EQ(0u, acked_packets[0].bytes_acked);
-          })));
+      .WillOnce(testing::WithArg<3>([](const AckedPacketVector& acked_packets) {
+        EXPECT_EQ(1u, acked_packets.size());
+        EXPECT_EQ(QuicPacketNumber(1), acked_packets[0].packet_number);
+        // The bytes in packet1 shouldn't contribute to congestion control.
+        EXPECT_EQ(0u, acked_packets[0].bytes_acked);
+      }));
   EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
   manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
                            clock_.Now());
@@ -1576,13 +1574,12 @@
   EXPECT_CALL(
       *send_algorithm_,
       OnCongestionEvent(/*rtt_updated=*/true, kDefaultLength, _, _, _, _, _))
-      .WillOnce(testing::WithArg<3>(
-          Invoke([](const AckedPacketVector& acked_packets) {
-            EXPECT_EQ(1u, acked_packets.size());
-            EXPECT_EQ(QuicPacketNumber(2), acked_packets[0].packet_number);
-            // The bytes in packet2 should contribute to congestion control.
-            EXPECT_EQ(kDefaultLength, acked_packets[0].bytes_acked);
-          })));
+      .WillOnce(testing::WithArg<3>([](const AckedPacketVector& acked_packets) {
+        EXPECT_EQ(1u, acked_packets.size());
+        EXPECT_EQ(QuicPacketNumber(2), acked_packets[0].packet_number);
+        // The bytes in packet2 should contribute to congestion control.
+        EXPECT_EQ(kDefaultLength, acked_packets[0].bytes_acked);
+      }));
   EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
   EXPECT_EQ(PACKETS_NEWLY_ACKED,
             manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
@@ -1596,10 +1593,10 @@
   EXPECT_CALL(*loss_algorithm, GetLossTimeout())
       .WillOnce(Return(clock_.Now() + QuicTime::Delta::FromMilliseconds(10)));
   EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _))
-      .WillOnce(WithArgs<5>(Invoke([](LostPacketVector* packet_lost) {
+      .WillOnce(WithArgs<5>([](LostPacketVector* packet_lost) {
         packet_lost->emplace_back(QuicPacketNumber(3u), kDefaultLength);
         return LossDetectionInterface::DetectionStats();
-      })));
+      }));
   EXPECT_CALL(notifier_, OnFrameLost(_));
   EXPECT_CALL(*send_algorithm_,
               OnCongestionEvent(false, kDefaultLength, _, _, _, _, _));
@@ -1646,10 +1643,10 @@
   EXPECT_CALL(*loss_algorithm, GetLossTimeout())
       .WillOnce(Return(clock_.Now() + QuicTime::Delta::FromMilliseconds(10)));
   EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _))
-      .WillOnce(WithArgs<5>(Invoke([](LostPacketVector* packet_lost) {
+      .WillOnce(WithArgs<5>([](LostPacketVector* packet_lost) {
         packet_lost->emplace_back(QuicPacketNumber(4u), kDefaultLength);
         return LossDetectionInterface::DetectionStats();
-      })));
+      }));
   EXPECT_CALL(notifier_, OnFrameLost(_));
   EXPECT_CALL(*send_algorithm_,
               OnCongestionEvent(false, kDefaultLength, _, _, _, _, _));
@@ -2027,9 +2024,9 @@
   EXPECT_EQ(0u, stats_.max_consecutive_rto_with_forward_progress);
 
   EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
+      .WillOnce(WithArgs<1>([this](TransmissionType type) {
         return RetransmitDataPacket(3, type, ENCRYPTION_FORWARD_SECURE);
-      })));
+      }));
   manager_.MaybeSendProbePacket();
   // Verify PTO period gets set to twice the current value.
   QuicTime sent_time = clock_.Now();
@@ -2086,9 +2083,9 @@
 
   // Verify one probe packet gets sent.
   EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
+      .WillOnce(WithArgs<1>([this](TransmissionType type) {
         return RetransmitDataPacket(3, type, ENCRYPTION_FORWARD_SECURE);
-      })));
+      }));
   manager_.MaybeSendProbePacket();
 }
 
@@ -2264,9 +2261,9 @@
 
   // Verify probe packet gets sent.
   EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
+      .WillOnce(WithArgs<1>([this](TransmissionType type) {
         return RetransmitDataPacket(3, type, ENCRYPTION_HANDSHAKE);
-      })));
+      }));
   manager_.MaybeSendProbePacket();
   // Verify PTO period gets set to twice the current value.
   const QuicTime packet3_sent_time = clock_.Now();
@@ -2412,9 +2409,9 @@
   EXPECT_EQ(1u, stats_.pto_count);
 
   EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
+      .WillOnce(WithArgs<1>([this](TransmissionType type) {
         return RetransmitDataPacket(3, type, ENCRYPTION_FORWARD_SECURE);
-      })));
+      }));
   manager_.MaybeSendProbePacket();
   // Verify PTO period gets set to twice the current value and based on packet3.
   QuicTime packet3_sent_time = clock_.Now();
@@ -2478,9 +2475,9 @@
   EXPECT_EQ(1u, stats_.pto_count);
 
   EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
+      .WillOnce(WithArgs<1>([this](TransmissionType type) {
         return RetransmitDataPacket(3, type, ENCRYPTION_FORWARD_SECURE);
-      })));
+      }));
   manager_.MaybeSendProbePacket();
   // Verify PTO period gets set to twice the expected value and based on
   // packet3 (right edge).
@@ -2657,13 +2654,12 @@
   SendDataPacket(2, ENCRYPTION_HANDSHAKE);
 
   EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _))
-      .WillOnce(
-          Invoke([](const QuicFrame& /*frame*/, QuicTime::Delta ack_delay_time,
-                    QuicTime receive_timestamp, bool) {
-            EXPECT_TRUE(ack_delay_time.IsZero());
-            EXPECT_EQ(receive_timestamp, QuicTime::Zero());
-            return true;
-          }));
+      .WillOnce([](const QuicFrame& /*frame*/, QuicTime::Delta ack_delay_time,
+                   QuicTime receive_timestamp, bool) {
+        EXPECT_TRUE(ack_delay_time.IsZero());
+        EXPECT_EQ(receive_timestamp, QuicTime::Zero());
+        return true;
+      });
 
   EXPECT_CALL(*send_algorithm_, OnPacketNeutered(QuicPacketNumber(2))).Times(1);
   manager_.SetHandshakeConfirmed();
@@ -2782,9 +2778,9 @@
   clock_.AdvanceTime(expected_pto_delay);
   manager_.OnRetransmissionTimeout();
 
-  EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(
-          WithArgs<1>(Invoke([this]() { return RetransmitCryptoPacket(3); })));
+  EXPECT_CALL(notifier_, RetransmitFrames(_, _)).WillOnce(WithArgs<1>([this]() {
+    return RetransmitCryptoPacket(3);
+  }));
   manager_.MaybeSendProbePacket();
   // Verify exponential backoff of the PTO timeout.
   EXPECT_EQ(clock_.Now() + 2 * expected_pto_delay,
@@ -2809,9 +2805,9 @@
   clock_.AdvanceTime(expected_pto_delay);
   manager_.OnRetransmissionTimeout();
 
-  EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(
-          WithArgs<1>(Invoke([this]() { return RetransmitCryptoPacket(3); })));
+  EXPECT_CALL(notifier_, RetransmitFrames(_, _)).WillOnce(WithArgs<1>([this]() {
+    return RetransmitCryptoPacket(3);
+  }));
   manager_.MaybeSendProbePacket();
   // Verify exponential backoff of the PTO timeout.
   EXPECT_EQ(clock_.Now() + 2 * expected_pto_delay,
@@ -2918,9 +2914,9 @@
   // Assume connection is going to send INITIAL ACK.
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
   EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
+      .WillOnce(WithArgs<1>([this](TransmissionType type) {
         return RetransmitDataPacket(4, type, ENCRYPTION_INITIAL);
-      })));
+      }));
   manager_.RetransmitDataOfSpaceIfAny(INITIAL_DATA);
   // Verify PTO is re-armed based on packet 2.
   EXPECT_EQ(packet2_sent_time + expected_pto_delay,
@@ -2929,9 +2925,9 @@
   // Connection is going to send another INITIAL ACK.
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
   EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(WithArgs<1>(Invoke([this](TransmissionType type) {
+      .WillOnce(WithArgs<1>([this](TransmissionType type) {
         return RetransmitDataPacket(5, type, ENCRYPTION_INITIAL);
-      })));
+      }));
   manager_.RetransmitDataOfSpaceIfAny(INITIAL_DATA);
   // Verify PTO does not change.
   EXPECT_EQ(packet2_sent_time + expected_pto_delay,
@@ -3428,40 +3424,40 @@
   manager_.SetDebugDelegate(&debug_delegate);
   bool correct_report = false;
   EXPECT_CALL(debug_delegate, OnIncomingAck(_, _, _, _, _, _, _))
-      .WillOnce(Invoke(
-          [&](QuicPacketNumber /*ack_packet_number*/,
-              EncryptionLevel /*ack_decrypted_level*/,
-              const QuicAckFrame& ack_frame, QuicTime /*ack_receive_time*/,
-              QuicPacketNumber /*largest_observed*/, bool /*rtt_updated*/,
-              QuicPacketNumber /*least_unacked_sent_packet*/) {
-            correct_report = (ack_frame.ecn_counters == ecn_counts1);
-          }));
+      .WillOnce([&](QuicPacketNumber /*ack_packet_number*/,
+                    EncryptionLevel /*ack_decrypted_level*/,
+                    const QuicAckFrame& ack_frame,
+                    QuicTime /*ack_receive_time*/,
+                    QuicPacketNumber /*largest_observed*/, bool /*rtt_updated*/,
+                    QuicPacketNumber /*least_unacked_sent_packet*/) {
+        correct_report = (ack_frame.ecn_counters == ecn_counts1);
+      });
   manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1), ENCRYPTION_INITIAL,
                          ecn_counts1);
   EXPECT_TRUE(correct_report);
   correct_report = false;
   EXPECT_CALL(debug_delegate, OnIncomingAck(_, _, _, _, _, _, _))
-      .WillOnce(Invoke(
-          [&](QuicPacketNumber /*ack_packet_number*/,
-              EncryptionLevel /*ack_decrypted_level*/,
-              const QuicAckFrame& ack_frame, QuicTime /*ack_receive_time*/,
-              QuicPacketNumber /*largest_observed*/, bool /*rtt_updated*/,
-              QuicPacketNumber /*least_unacked_sent_packet*/) {
-            correct_report = (ack_frame.ecn_counters == ecn_counts2);
-          }));
+      .WillOnce([&](QuicPacketNumber /*ack_packet_number*/,
+                    EncryptionLevel /*ack_decrypted_level*/,
+                    const QuicAckFrame& ack_frame,
+                    QuicTime /*ack_receive_time*/,
+                    QuicPacketNumber /*largest_observed*/, bool /*rtt_updated*/,
+                    QuicPacketNumber /*least_unacked_sent_packet*/) {
+        correct_report = (ack_frame.ecn_counters == ecn_counts2);
+      });
   manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(2),
                          ENCRYPTION_HANDSHAKE, ecn_counts2);
   EXPECT_TRUE(correct_report);
   correct_report = false;
   EXPECT_CALL(debug_delegate, OnIncomingAck(_, _, _, _, _, _, _))
-      .WillOnce(Invoke(
-          [&](QuicPacketNumber /*ack_packet_number*/,
-              EncryptionLevel /*ack_decrypted_level*/,
-              const QuicAckFrame& ack_frame, QuicTime /*ack_receive_time*/,
-              QuicPacketNumber /*largest_observed*/, bool /*rtt_updated*/,
-              QuicPacketNumber /*least_unacked_sent_packet*/) {
-            correct_report = (ack_frame.ecn_counters == ecn_counts3);
-          }));
+      .WillOnce([&](QuicPacketNumber /*ack_packet_number*/,
+                    EncryptionLevel /*ack_decrypted_level*/,
+                    const QuicAckFrame& ack_frame,
+                    QuicTime /*ack_receive_time*/,
+                    QuicPacketNumber /*largest_observed*/, bool /*rtt_updated*/,
+                    QuicPacketNumber /*least_unacked_sent_packet*/) {
+        correct_report = (ack_frame.ecn_counters == ecn_counts3);
+      });
   manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(3),
                          ENCRYPTION_FORWARD_SECURE, ecn_counts3);
   EXPECT_TRUE(correct_report);
diff --git a/quiche/quic/core/quic_session_test.cc b/quiche/quic/core/quic_session_test.cc
index e5d2ae4..ed37f26 100644
--- a/quiche/quic/core/quic_session_test.cc
+++ b/quiche/quic/core/quic_session_test.cc
@@ -522,7 +522,7 @@
         // READ_UNIDIRECTIONAL streams.
         EXPECT_CALL(*connection_, SendControlFrame(IsFrame(STOP_SENDING_FRAME)))
             .Times(1)
-            .WillOnce(Invoke(&ClearControlFrame));
+            .WillOnce(&ClearControlFrame);
         EXPECT_CALL(*connection_, OnStreamReset(id, _)).Times(1);
       } else if (QuicUtils::GetStreamType(
                      id, session_.perspective(), session_.IsIncomingStream(id),
@@ -531,20 +531,20 @@
         // stream.
         EXPECT_CALL(*connection_, SendControlFrame(IsFrame(RST_STREAM_FRAME)))
             .Times(1)
-            .WillOnce(Invoke(&ClearControlFrame));
+            .WillOnce(&ClearControlFrame);
         EXPECT_CALL(*connection_, OnStreamReset(id, _));
       } else {
         // Verify RST_STREAM and STOP_SENDING are sent for BIDIRECTIONAL
         // streams.
         EXPECT_CALL(*connection_, SendControlFrame(IsFrame(RST_STREAM_FRAME)))
-            .WillRepeatedly(Invoke(&ClearControlFrame));
+            .WillRepeatedly(&ClearControlFrame);
         EXPECT_CALL(*connection_, SendControlFrame(IsFrame(STOP_SENDING_FRAME)))
-            .WillRepeatedly(Invoke(&ClearControlFrame));
+            .WillRepeatedly(&ClearControlFrame);
         EXPECT_CALL(*connection_, OnStreamReset(id, _));
       }
     } else {
       EXPECT_CALL(*connection_, SendControlFrame(_))
-          .WillOnce(Invoke(&ClearControlFrame));
+          .WillOnce(&ClearControlFrame);
       EXPECT_CALL(*connection_, OnStreamReset(id, _));
     }
     session_.ResetStream(id, QUIC_STREAM_CANCELLED);
@@ -557,7 +557,7 @@
         connection_->perspective() == Perspective::IS_SERVER) {
       // HANDSHAKE_DONE frame.
       EXPECT_CALL(*connection_, SendControlFrame(_))
-          .WillOnce(Invoke(&ClearControlFrame));
+          .WillOnce(&ClearControlFrame);
     }
     session_.GetMutableCryptoStream()->OnHandshakeMessage(msg);
   }
@@ -633,17 +633,15 @@
       EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
       EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
       EXPECT_CALL(framer_visitor_, OnPathResponseFrame(_))
-          .WillOnce(
-              WithArg<0>(Invoke([this](const QuicPathResponseFrame& frame) {
-                EXPECT_EQ(path_frame_buffer1_, frame.data_buffer);
-                return true;
-              })));
+          .WillOnce(WithArg<0>([this](const QuicPathResponseFrame& frame) {
+            EXPECT_EQ(path_frame_buffer1_, frame.data_buffer);
+            return true;
+          }));
       EXPECT_CALL(framer_visitor_, OnPathResponseFrame(_))
-          .WillOnce(
-              WithArg<0>(Invoke([this](const QuicPathResponseFrame& frame) {
-                EXPECT_EQ(path_frame_buffer2_, frame.data_buffer);
-                return true;
-              })));
+          .WillOnce(WithArg<0>([this](const QuicPathResponseFrame& frame) {
+            EXPECT_EQ(path_frame_buffer2_, frame.data_buffer);
+            return true;
+          }));
       EXPECT_CALL(framer_visitor_, OnPacketComplete());
     }
     client_framer_.ProcessPacket(packet);
@@ -1002,10 +1000,10 @@
   InSequence s;
 
   // Reregister, to test the loop limit.
-  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(Invoke([this, stream2]() {
+  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce([this, stream2]() {
     session_.SendStreamData(stream2);
     session_.MarkConnectionLevelWriteBlocked(stream2->id());
-  }));
+  });
 
   if (!GetQuicReloadableFlag(quic_disable_batch_write) ||
       GetQuicReloadableFlag(quic_priority_respect_incremental)) {
@@ -1013,19 +1011,19 @@
     // are non-incremental by default, so if the incremental flag is respected,
     // then stream 2 will write again. (If it is not respected, then every
     // stream is treated as incremental.)
-    EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(Invoke([this, stream2]() {
+    EXPECT_CALL(*stream2, OnCanWrite()).WillOnce([this, stream2]() {
       session_.SendStreamData(stream2);
-    }));
-    EXPECT_CALL(*stream6, OnCanWrite()).WillOnce(Invoke([this, stream6]() {
+    });
+    EXPECT_CALL(*stream6, OnCanWrite()).WillOnce([this, stream6]() {
       session_.SendStreamData(stream6);
-    }));
+    });
   } else {
-    EXPECT_CALL(*stream6, OnCanWrite()).WillOnce(Invoke([this, stream6]() {
+    EXPECT_CALL(*stream6, OnCanWrite()).WillOnce([this, stream6]() {
       session_.SendStreamData(stream6);
-    }));
-    EXPECT_CALL(*stream4, OnCanWrite()).WillOnce(Invoke([this, stream4]() {
+    });
+    EXPECT_CALL(*stream4, OnCanWrite()).WillOnce([this, stream4]() {
       session_.SendStreamData(stream4);
-    }));
+    });
   }
 
   // Stream 4 will not get called, as we exceeded the loop limit.
@@ -1053,75 +1051,72 @@
 
   // With two sessions blocked, we should get two write calls.
   InSequence s;
-  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(Invoke([this, stream2]() {
+  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce([this, stream2]() {
     session_.SendLargeFakeData(stream2, 6000);
     session_.MarkConnectionLevelWriteBlocked(stream2->id());
-  }));
+  });
   if (GetQuicReloadableFlag(quic_disable_batch_write)) {
-    EXPECT_CALL(*stream4, OnCanWrite()).WillOnce(Invoke([this, stream4]() {
+    EXPECT_CALL(*stream4, OnCanWrite()).WillOnce([this, stream4]() {
       session_.SendLargeFakeData(stream4, 6000);
       session_.MarkConnectionLevelWriteBlocked(stream4->id());
-    }));
+    });
   } else {
     // Since stream2 only wrote 6 kB and marked itself blocked again,
     // the second write happens on the same stream.
-    EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(Invoke([this, stream2]() {
+    EXPECT_CALL(*stream2, OnCanWrite()).WillOnce([this, stream2]() {
       session_.SendLargeFakeData(stream2, 6000);
       session_.MarkConnectionLevelWriteBlocked(stream2->id());
-    }));
+    });
   }
   session_.OnCanWrite();
 
   // If batched write is enabled, stream2 can write a third time in a row.
   // If batched write is disabled, stream2 has a turn again after stream4.
-  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(Invoke([this, stream2]() {
+  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce([this, stream2]() {
     session_.SendLargeFakeData(stream2, 6000);
     session_.MarkConnectionLevelWriteBlocked(stream2->id());
-  }));
-  EXPECT_CALL(*stream4, OnCanWrite()).WillOnce(Invoke([this, stream4]() {
+  });
+  EXPECT_CALL(*stream4, OnCanWrite()).WillOnce([this, stream4]() {
     session_.SendLargeFakeData(stream4, 6000);
     session_.MarkConnectionLevelWriteBlocked(stream4->id());
-  }));
+  });
   session_.OnCanWrite();
 
   // The next write adds a block for stream 6.
   stream6->SetPriority(QuicStreamPriority(HttpStreamPriority{
       kV3HighestPriority, HttpStreamPriority::kDefaultIncremental}));
   if (GetQuicReloadableFlag(quic_disable_batch_write)) {
-    EXPECT_CALL(*stream2, OnCanWrite())
-        .WillOnce(Invoke([this, stream2, stream6]() {
-          session_.SendLargeFakeData(stream2, 6000);
-          session_.MarkConnectionLevelWriteBlocked(stream2->id());
-          session_.MarkConnectionLevelWriteBlocked(stream6->id());
-        }));
+    EXPECT_CALL(*stream2, OnCanWrite()).WillOnce([this, stream2, stream6]() {
+      session_.SendLargeFakeData(stream2, 6000);
+      session_.MarkConnectionLevelWriteBlocked(stream2->id());
+      session_.MarkConnectionLevelWriteBlocked(stream6->id());
+    });
   } else {
-    EXPECT_CALL(*stream4, OnCanWrite())
-        .WillOnce(Invoke([this, stream4, stream6]() {
-          session_.SendLargeFakeData(stream4, 6000);
-          session_.MarkConnectionLevelWriteBlocked(stream4->id());
-          session_.MarkConnectionLevelWriteBlocked(stream6->id());
-        }));
+    EXPECT_CALL(*stream4, OnCanWrite()).WillOnce([this, stream4, stream6]() {
+      session_.SendLargeFakeData(stream4, 6000);
+      session_.MarkConnectionLevelWriteBlocked(stream4->id());
+      session_.MarkConnectionLevelWriteBlocked(stream6->id());
+    });
   }
   // Stream 6 will write next, because it has higher priority.
   // It does not mark itself as blocked.
-  EXPECT_CALL(*stream6, OnCanWrite())
-      .WillOnce(Invoke([this, stream4, stream6]() {
-        session_.SendStreamData(stream6);
-        session_.SendLargeFakeData(stream4, 6000);
-      }));
+  EXPECT_CALL(*stream6, OnCanWrite()).WillOnce([this, stream4, stream6]() {
+    session_.SendStreamData(stream6);
+    session_.SendLargeFakeData(stream4, 6000);
+  });
   session_.OnCanWrite();
 
   // If batched write is enabled, stream4 can continue to write, but will
   // exhaust its write limit, so the last write is on stream2.
   // If batched write is disabled, stream4 has a turn again, then stream2.
-  EXPECT_CALL(*stream4, OnCanWrite()).WillOnce(Invoke([this, stream4]() {
+  EXPECT_CALL(*stream4, OnCanWrite()).WillOnce([this, stream4]() {
     session_.SendLargeFakeData(stream4, 12000);
     session_.MarkConnectionLevelWriteBlocked(stream4->id());
-  }));
-  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(Invoke([this, stream2]() {
+  });
+  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce([this, stream2]() {
     session_.SendLargeFakeData(stream2, 6000);
     session_.MarkConnectionLevelWriteBlocked(stream2->id());
-  }));
+  });
   session_.OnCanWrite();
 }
 
@@ -1147,15 +1142,15 @@
   EXPECT_CALL(*send_algorithm, GetCongestionWindow())
       .WillRepeatedly(Return(kMaxOutgoingPacketSize * 10));
   EXPECT_CALL(*send_algorithm, InRecovery()).WillRepeatedly(Return(false));
-  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(Invoke([this, stream2]() {
+  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce([this, stream2]() {
     session_.SendStreamData(stream2);
-  }));
-  EXPECT_CALL(*stream4, OnCanWrite()).WillOnce(Invoke([this, stream4]() {
+  });
+  EXPECT_CALL(*stream4, OnCanWrite()).WillOnce([this, stream4]() {
     session_.SendStreamData(stream4);
-  }));
-  EXPECT_CALL(*stream6, OnCanWrite()).WillOnce(Invoke([this, stream6]() {
+  });
+  EXPECT_CALL(*stream6, OnCanWrite()).WillOnce([this, stream6]() {
     session_.SendStreamData(stream6);
-  }));
+  });
 
   // Expect that we only send one packet, the writes from different streams
   // should be bundled together.
@@ -1185,14 +1180,14 @@
   session_.MarkConnectionLevelWriteBlocked(stream4->id());
 
   EXPECT_CALL(*send_algorithm, CanSend(_)).WillOnce(Return(true));
-  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(Invoke([this, stream2]() {
+  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce([this, stream2]() {
     session_.SendStreamData(stream2);
-  }));
+  });
   EXPECT_CALL(*send_algorithm, GetCongestionWindow()).Times(AnyNumber());
   EXPECT_CALL(*send_algorithm, CanSend(_)).WillOnce(Return(true));
-  EXPECT_CALL(*stream6, OnCanWrite()).WillOnce(Invoke([this, stream6]() {
+  EXPECT_CALL(*stream6, OnCanWrite()).WillOnce([this, stream6]() {
     session_.SendStreamData(stream6);
-  }));
+  });
   EXPECT_CALL(*send_algorithm, CanSend(_)).WillOnce(Return(false));
   // stream4->OnCanWrite is not called.
 
@@ -1207,9 +1202,9 @@
   // stream4->OnCanWrite is called once the connection stops being
   // congestion-control blocked.
   EXPECT_CALL(*send_algorithm, CanSend(_)).WillOnce(Return(true));
-  EXPECT_CALL(*stream4, OnCanWrite()).WillOnce(Invoke([this, stream4]() {
+  EXPECT_CALL(*stream4, OnCanWrite()).WillOnce([this, stream4]() {
     session_.SendStreamData(stream4);
-  }));
+  });
   EXPECT_CALL(*send_algorithm, OnApplicationLimited(_));
   session_.OnCanWrite();
   EXPECT_FALSE(session_.WillingAndAbleToWrite());
@@ -1251,13 +1246,13 @@
   }
   // Next checking causes STREAMS_BLOCKED to be sent.
   EXPECT_CALL(*connection_, SendControlFrame(_))
-      .WillOnce(Invoke([](const QuicFrame& frame) {
+      .WillOnce([](const QuicFrame& frame) {
         EXPECT_FALSE(frame.streams_blocked_frame.unidirectional);
         EXPECT_EQ(kDefaultMaxStreamsPerConnection,
                   frame.streams_blocked_frame.stream_count);
         ClearControlFrame(frame);
         return true;
-      }));
+      });
   EXPECT_FALSE(session_.CanOpenNextOutgoingBidirectionalStream());
 
   for (size_t i = 0; i < kDefaultMaxStreamsPerConnection; ++i) {
@@ -1266,13 +1261,13 @@
   }
   // Next checking causes STREAM_BLOCKED to be sent.
   EXPECT_CALL(*connection_, SendControlFrame(_))
-      .WillOnce(Invoke([](const QuicFrame& frame) {
+      .WillOnce([](const QuicFrame& frame) {
         EXPECT_TRUE(frame.streams_blocked_frame.unidirectional);
         EXPECT_EQ(kDefaultMaxStreamsPerConnection,
                   frame.streams_blocked_frame.stream_count);
         ClearControlFrame(frame);
         return true;
-      }));
+      });
   EXPECT_FALSE(session_.CanOpenNextOutgoingUnidirectionalStream());
 }
 
@@ -1293,11 +1288,11 @@
   std::vector<QuicMaxStreamsFrame> max_stream_frames;
   EXPECT_CALL(*connection_, SendControlFrame(IsFrame(MAX_STREAMS_FRAME)))
       .Times(2)
-      .WillRepeatedly(Invoke([&max_stream_frames](const QuicFrame& frame) {
+      .WillRepeatedly([&max_stream_frames](const QuicFrame& frame) {
         max_stream_frames.push_back(frame.max_streams_frame);
         ClearControlFrame(frame);
         return true;
-      }));
+      });
   for (size_t i = 0; i < kMaxStreams; ++i) {
     QuicStreamId stream_id = GetNthClientInitiatedBidirectionalId(i);
     QuicStreamFrame data1(stream_id, true, 0, absl::string_view("HT"));
@@ -1326,7 +1321,7 @@
 
   // Now when the outstanding MAX_STREAMS frame is ACK'd a new one will be sent.
   EXPECT_CALL(*connection_, SendControlFrame(IsFrame(MAX_STREAMS_FRAME)))
-      .WillOnce(Invoke(&ClearControlFrame));
+      .WillOnce(&ClearControlFrame);
   session_.OnFrameAcked(QuicFrame(max_stream_frames[0]),
                         QuicTime::Delta::Zero(), QuicTime::Zero(),
                         /*is_retransmission=*/false);
@@ -1389,16 +1384,16 @@
   TestCryptoStream* crypto_stream = session_.GetMutableCryptoStream();
   EXPECT_CALL(*crypto_stream, OnCanWrite());
 
-  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(Invoke([this, stream2]() {
+  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce([this, stream2]() {
     session_.SendStreamData(stream2);
-  }));
-  EXPECT_CALL(*stream3, OnCanWrite()).WillOnce(Invoke([this, stream3]() {
+  });
+  EXPECT_CALL(*stream3, OnCanWrite()).WillOnce([this, stream3]() {
     session_.SendStreamData(stream3);
-  }));
-  EXPECT_CALL(*stream4, OnCanWrite()).WillOnce(Invoke([this, stream4]() {
+  });
+  EXPECT_CALL(*stream4, OnCanWrite()).WillOnce([this, stream4]() {
     session_.SendStreamData(stream4);
     session_.MarkConnectionLevelWriteBlocked(stream4->id());
-  }));
+  });
 
   session_.OnCanWrite();
   EXPECT_TRUE(session_.WillingAndAbleToWrite());
@@ -1419,13 +1414,13 @@
 
   InSequence s;
   EXPECT_CALL(*connection_, SendControlFrame(_))
-      .WillRepeatedly(Invoke(&ClearControlFrame));
-  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(Invoke([this, stream2]() {
+      .WillRepeatedly(&ClearControlFrame);
+  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce([this, stream2]() {
     session_.SendStreamData(stream2);
-  }));
-  EXPECT_CALL(*stream4, OnCanWrite()).WillOnce(Invoke([this, stream4]() {
+  });
+  EXPECT_CALL(*stream4, OnCanWrite()).WillOnce([this, stream4]() {
     session_.SendStreamData(stream4);
-  }));
+  });
   session_.OnCanWrite();
   EXPECT_FALSE(session_.WillingAndAbleToWrite());
 }
@@ -1503,8 +1498,7 @@
     // In IETF QUIC, GOAWAY lives up in the HTTP layer.
     return;
   }
-  EXPECT_CALL(*connection_, SendControlFrame(_))
-      .WillOnce(Invoke(&ClearControlFrame));
+  EXPECT_CALL(*connection_, SendControlFrame(_)).WillOnce(&ClearControlFrame);
   session_.SendGoAway(QUIC_PEER_GOING_AWAY, "Going Away.");
   EXPECT_TRUE(session_.transport_goaway_sent());
   session_.SendGoAway(QUIC_PEER_GOING_AWAY, "Going Away.");
@@ -1668,7 +1662,7 @@
 
   EXPECT_CALL(*connection_, SendControlFrame(_))
       .Times(2)
-      .WillRepeatedly(Invoke(&ClearControlFrame));
+      .WillRepeatedly(&ClearControlFrame);
   EXPECT_CALL(*connection_, OnStreamReset(stream->id(), _));
 
   QuicRstStreamFrame rst_frame(kInvalidControlFrameId, stream->id(),
@@ -2490,8 +2484,7 @@
   QuicRstStreamFrame rst_frame(kInvalidControlFrameId, stream2->id(),
                                QUIC_STREAM_CANCELLED, 1234);
   // Just for the RST_STREAM
-  EXPECT_CALL(*connection_, SendControlFrame(_))
-      .WillOnce(Invoke(&ClearControlFrame));
+  EXPECT_CALL(*connection_, SendControlFrame(_)).WillOnce(&ClearControlFrame);
   if (VersionHasIetfQuicFrames(transport_version())) {
     EXPECT_CALL(*connection_,
                 OnStreamReset(stream2->id(), QUIC_STREAM_CANCELLED));
@@ -2517,7 +2510,7 @@
     // Once for the RST_STREAM, once for the STOP_SENDING
     EXPECT_CALL(*connection_, SendControlFrame(_))
         .Times(2)
-        .WillRepeatedly(Invoke(&ClearControlFrame));
+        .WillRepeatedly(&ClearControlFrame);
   } else {
     // Just for the RST_STREAM
     EXPECT_CALL(*connection_, SendControlFrame(_)).Times(1);
@@ -2644,7 +2637,7 @@
   EXPECT_CALL(*stream2, OnCanWrite());
   EXPECT_CALL(*stream2, HasPendingRetransmission()).WillOnce(Return(false));
   EXPECT_CALL(*connection_, SendControlFrame(_))
-      .WillRepeatedly(Invoke(&ClearControlFrame));
+      .WillRepeatedly(&ClearControlFrame);
   EXPECT_CALL(*stream2, OnCanWrite());
   EXPECT_CALL(*stream6, OnCanWrite());
   session_.OnCanWrite();
@@ -2659,8 +2652,7 @@
   TestStream* stream2 = session_.CreateOutgoingBidirectionalStream();
   TestStream* stream4 = session_.CreateOutgoingBidirectionalStream();
   TestStream* stream6 = session_.CreateOutgoingBidirectionalStream();
-  EXPECT_CALL(*connection_, SendControlFrame(_))
-      .WillOnce(Invoke(&ClearControlFrame));
+  EXPECT_CALL(*connection_, SendControlFrame(_)).WillOnce(&ClearControlFrame);
   session_.SendWindowUpdate(stream2->id(), 9);
 
   QuicStreamFrame frame1(stream2->id(), false, 0, 9);
@@ -2676,8 +2668,7 @@
 
   EXPECT_CALL(*stream2, RetransmitStreamData(_, _, _, _))
       .WillOnce(Return(true));
-  EXPECT_CALL(*connection_, SendControlFrame(_))
-      .WillOnce(Invoke(&ClearControlFrame));
+  EXPECT_CALL(*connection_, SendControlFrame(_)).WillOnce(&ClearControlFrame);
   EXPECT_CALL(*stream4, RetransmitStreamData(_, _, _, _))
       .WillOnce(Return(true));
   EXPECT_CALL(*stream6, RetransmitStreamData(_, _, _, _))
@@ -2701,9 +2692,9 @@
   session_.OnFrameLost(QuicFrame(frame));
   // Retransmit stream data causes connection close. Stream has not sent fin
   // yet, so an RST is sent.
-  EXPECT_CALL(*stream, OnCanWrite()).WillOnce(Invoke([this, stream]() {
+  EXPECT_CALL(*stream, OnCanWrite()).WillOnce([this, stream]() {
     session_.ResetStream(stream->id(), QUIC_STREAM_CANCELLED);
-  }));
+  });
   if (VersionHasIetfQuicFrames(transport_version())) {
     // Once for the RST_STREAM, once for the STOP_SENDING
     EXPECT_CALL(*connection_, SendControlFrame(_))
@@ -2778,7 +2769,7 @@
 
   // Reset stream2 locally.
   EXPECT_CALL(*connection_, SendControlFrame(_))
-      .WillRepeatedly(Invoke(&ClearControlFrame));
+      .WillRepeatedly(&ClearControlFrame);
   EXPECT_CALL(*connection_, OnStreamReset(stream2->id(), _));
   stream2->Reset(QUIC_STREAM_CANCELLED);
 
@@ -3252,21 +3243,21 @@
 
   EXPECT_CALL(*connection_, SendControlFrame(_))
       .Times(1)
-      .WillOnce(Invoke(&ClearControlFrame));
+      .WillOnce(&ClearControlFrame);
   EXPECT_CALL(*connection_, OnStreamReset(read_only, _));
   session_.ResetStream(read_only, QUIC_STREAM_CANCELLED);
 
   QuicStreamId write_only = GetNthServerInitiatedUnidirectionalId(0);
   EXPECT_CALL(*connection_, SendControlFrame(_))
       .Times(1)
-      .WillOnce(Invoke(&ClearControlFrame));
+      .WillOnce(&ClearControlFrame);
   EXPECT_CALL(*connection_, OnStreamReset(write_only, _));
   session_.ResetStream(write_only, QUIC_STREAM_CANCELLED);
 
   QuicStreamId bidirectional = GetNthClientInitiatedBidirectionalId(0);
   EXPECT_CALL(*connection_, SendControlFrame(_))
       .Times(2)
-      .WillRepeatedly(Invoke(&ClearControlFrame));
+      .WillRepeatedly(&ClearControlFrame);
   EXPECT_CALL(*connection_, OnStreamReset(bidirectional, _));
   session_.ResetStream(bidirectional, QUIC_STREAM_CANCELLED);
 }
diff --git a/quiche/quic/core/quic_stream_sequencer_test.cc b/quiche/quic/core/quic_stream_sequencer_test.cc
index 3ac6d88..abd8346 100644
--- a/quiche/quic/core/quic_stream_sequencer_test.cc
+++ b/quiche/quic/core/quic_stream_sequencer_test.cc
@@ -165,9 +165,9 @@
 
 TEST_F(QuicStreamSequencerTest, RejectOldFrame) {
   EXPECT_CALL(stream_, AddBytesConsumed(3));
-  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce(testing::Invoke([this]() {
+  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce([this]() {
     ConsumeData(3);
-  }));
+  });
 
   OnFrame(0, "abc");
 
@@ -194,9 +194,9 @@
 
 TEST_F(QuicStreamSequencerTest, FullFrameConsumed) {
   EXPECT_CALL(stream_, AddBytesConsumed(3));
-  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce(testing::Invoke([this]() {
+  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce([this]() {
     ConsumeData(3);
-  }));
+  });
 
   OnFrame(0, "abc");
   EXPECT_EQ(0u, NumBufferedBytes());
@@ -211,17 +211,17 @@
   EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
 
   EXPECT_CALL(stream_, AddBytesConsumed(3));
-  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce(testing::Invoke([this]() {
+  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce([this]() {
     ConsumeData(3);
-  }));
+  });
   sequencer_->SetUnblocked();
   EXPECT_EQ(0u, NumBufferedBytes());
   EXPECT_EQ(3u, sequencer_->NumBytesConsumed());
 
   EXPECT_CALL(stream_, AddBytesConsumed(3));
-  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce(testing::Invoke([this]() {
+  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce([this]() {
     ConsumeData(3);
-  }));
+  });
   EXPECT_FALSE(sequencer_->IsClosed());
   EXPECT_FALSE(sequencer_->IsAllDataAvailable());
   OnFinFrame(3, "def");
@@ -237,9 +237,9 @@
   EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
 
   EXPECT_CALL(stream_, AddBytesConsumed(3));
-  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce(testing::Invoke([this]() {
+  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce([this]() {
     ConsumeData(3);
-  }));
+  });
   EXPECT_FALSE(sequencer_->IsClosed());
   EXPECT_TRUE(sequencer_->IsAllDataAvailable());
   sequencer_->SetUnblocked();
@@ -268,9 +268,9 @@
 
 TEST_F(QuicStreamSequencerTest, PartialFrameConsumed) {
   EXPECT_CALL(stream_, AddBytesConsumed(2));
-  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce(testing::Invoke([this]() {
+  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce([this]() {
     ConsumeData(2);
-  }));
+  });
 
   OnFrame(0, "abc");
   EXPECT_EQ(1u, NumBufferedBytes());
@@ -304,9 +304,9 @@
   EXPECT_EQ(6u, sequencer_->NumBytesBuffered());
 
   EXPECT_CALL(stream_, AddBytesConsumed(9));
-  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce(testing::Invoke([this]() {
+  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce([this]() {
     ConsumeData(9);
-  }));
+  });
 
   // Now process all of them at once.
   OnFrame(0, "abc");
@@ -319,9 +319,9 @@
 TEST_F(QuicStreamSequencerTest, BasicHalfCloseOrdered) {
   InSequence s;
 
-  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce(testing::Invoke([this]() {
+  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce([this]() {
     ConsumeData(3);
-  }));
+  });
   EXPECT_CALL(stream_, AddBytesConsumed(3));
   OnFinFrame(0, "abc");
 
@@ -334,9 +334,9 @@
 
   OnFrame(3, "def");
   EXPECT_CALL(stream_, AddBytesConsumed(6));
-  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce(testing::Invoke([this]() {
+  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce([this]() {
     ConsumeData(6);
-  }));
+  });
   EXPECT_FALSE(sequencer_->IsClosed());
   OnFrame(0, "abc");
   EXPECT_TRUE(sequencer_->IsClosed());
@@ -347,9 +347,9 @@
   EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
 
   EXPECT_CALL(stream_, AddBytesConsumed(3));
-  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce(testing::Invoke([this]() {
+  EXPECT_CALL(stream_, OnDataAvailable()).WillOnce([this]() {
     ConsumeData(3);
-  }));
+  });
   EXPECT_FALSE(sequencer_->IsClosed());
   OnFrame(0, "abc");
   EXPECT_TRUE(sequencer_->IsClosed());
@@ -439,10 +439,9 @@
   QuicByteCount total_bytes_consumed = 0;
   EXPECT_CALL(stream_, AddBytesConsumed(_))
       .Times(AnyNumber())
-      .WillRepeatedly(
-          testing::Invoke([&total_bytes_consumed](QuicByteCount bytes) {
-            total_bytes_consumed += bytes;
-          }));
+      .WillRepeatedly([&total_bytes_consumed](QuicByteCount bytes) {
+        total_bytes_consumed += bytes;
+      });
 
   while (!list_.empty()) {
     int index = OneToN(list_.size()) - 1;
@@ -469,10 +468,9 @@
   QuicByteCount total_bytes_consumed = 0;
   EXPECT_CALL(stream_, AddBytesConsumed(_))
       .Times(AnyNumber())
-      .WillRepeatedly(
-          testing::Invoke([&total_bytes_consumed](QuicByteCount bytes) {
-            total_bytes_consumed += bytes;
-          }));
+      .WillRepeatedly([&total_bytes_consumed](QuicByteCount bytes) {
+        total_bytes_consumed += bytes;
+      });
 
   while (output_.size() != ABSL_ARRAYSIZE(kPayload) - 1) {
     if (!list_.empty() && OneToN(2) == 1) {  // Send data
diff --git a/quiche/quic/core/quic_stream_test.cc b/quiche/quic/core/quic_stream_test.cc
index 5f0f7fe..548737e 100644
--- a/quiche/quic/core/quic_stream_test.cc
+++ b/quiche/quic/core/quic_stream_test.cc
@@ -745,7 +745,7 @@
       .Times(0);
   EXPECT_CALL(*session_, WriteControlFrame(_, _))
       .Times(AtLeast(1))
-      .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
+      .WillRepeatedly(&ClearControlFrameWithTransmissionType);
 
   std::string data(1000, 'x');
   for (QuicStreamOffset offset = 0;
@@ -1076,7 +1076,7 @@
               OnStreamReset(stream_->id(), QUIC_STREAM_CANCELLED));
   EXPECT_CALL(*session_, WriteControlFrame(_, _))
       .Times(AtLeast(1))
-      .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
+      .WillRepeatedly(&ClearControlFrameWithTransmissionType);
 
   EXPECT_CALL(*session_, MaybeSendRstStreamFrame(_, _, _))
       .WillOnce(InvokeWithoutArgs([this]() {
diff --git a/quiche/quic/core/quic_unacked_packet_map_test.cc b/quiche/quic/core/quic_unacked_packet_map_test.cc
index 3bfcc37..a94e006 100644
--- a/quiche/quic/core/quic_unacked_packet_map_test.cc
+++ b/quiche/quic/core/quic_unacked_packet_map_test.cc
@@ -21,7 +21,6 @@
 #include "quiche/quic/test_tools/quic_unacked_packet_map_peer.h"
 
 using testing::_;
-using testing::Invoke;
 using testing::Return;
 using testing::StrictMock;
 
@@ -653,8 +652,7 @@
       last_info->retransmittable_frames[0].padding_frame.num_padding_bytes;
 
   EXPECT_CALL(notifier_, OnFrameAcked(_, _, _, _))
-      .WillOnce(Invoke([&](const QuicFrame& frame, QuicTime::Delta, QuicTime,
-                           bool) {
+      .WillOnce([&](const QuicFrame& frame, QuicTime::Delta, QuicTime, bool) {
         EXPECT_EQ(frame.type, PADDING_FRAME);
         EXPECT_EQ(frame.padding_frame.num_padding_bytes, last_padding_bytes);
         // Append one more packet to the unacked packet map.
@@ -663,7 +661,7 @@
         unacked_packets_.AddSentPacket(&packet, NOT_RETRANSMISSION, now_, true,
                                        true, ECN_NOT_ECT);
         return true;
-      }));
+      });
 
   QuicTransmissionInfo* last_info_updated = last_info;
   unacked_packets_.NotifyFramesAcked(largest_sent_packet_before_acked,