diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc
index c328160..e57c1f4 100644
--- a/quiche/quic/moqt/moqt_session_test.cc
+++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -49,7 +49,6 @@
 
 using ::quic::test::MemSliceFromString;
 using ::testing::_;
-using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::StrictMock;
 
@@ -201,36 +200,36 @@
           .WillOnce(Return(stream))
           .WillOnce(Return(nullptr));
       EXPECT_CALL(*stream, SetVisitor(_))
-          .WillOnce(Invoke(
+          .WillOnce(
               [&](std::unique_ptr<webtransport::StreamVisitor> new_visitor) {
                 visitor = std::move(new_visitor);
-              }));
-      EXPECT_CALL(*stream, visitor()).WillRepeatedly(Invoke([&]() {
+              });
+      EXPECT_CALL(*stream, visitor()).WillRepeatedly([&]() {
         return visitor.get();
-      }));
+      });
     }
-    EXPECT_CALL(*stream, PeekNextReadableRegion()).WillRepeatedly(Invoke([&]() {
+    EXPECT_CALL(*stream, PeekNextReadableRegion()).WillRepeatedly([&]() {
       return quiche::ReadStream::PeekResult(
           absl::string_view(buffer.data() + data_read,
                             buffer.size() - data_read),
           fin && data_read == buffer.size(), fin);
-    }));
-    EXPECT_CALL(*stream, ReadableBytes()).WillRepeatedly(Invoke([&]() {
+    });
+    EXPECT_CALL(*stream, ReadableBytes()).WillRepeatedly([&]() {
       return buffer.size() - data_read;
-    }));
+    });
     EXPECT_CALL(*stream, Read(testing::An<absl::Span<char>>()))
-        .WillRepeatedly(Invoke([&](absl::Span<char> bytes_to_read) {
+        .WillRepeatedly([&](absl::Span<char> bytes_to_read) {
           size_t read_size =
               std::min(bytes_to_read.size(), buffer.size() - data_read);
           memcpy(bytes_to_read.data(), buffer.data() + data_read, read_size);
           data_read += read_size;
           return quiche::ReadStream::ReadResult(
               read_size, fin && data_read == buffer.size());
-        }));
-    EXPECT_CALL(*stream, SkipBytes(_)).WillRepeatedly(Invoke([&](size_t bytes) {
+        });
+    EXPECT_CALL(*stream, SkipBytes(_)).WillRepeatedly([&](size_t bytes) {
       data_read += bytes;
       return fin && data_read == buffer.size();
-    }));
+    });
     EXPECT_CALL(*track_visitor, OnObjectFragment).Times(1);
     if (visitor == nullptr) {
       session_.OnIncomingUnidirectionalStreamAvailable();
@@ -535,14 +534,14 @@
   MoqtSubscribe request = DefaultSubscribe();
   MockTrackPublisher* track = CreateTrackPublisher();
   EXPECT_CALL(*track, AddObjectListener)
-      .WillOnce(Invoke([&](MoqtObjectListener* listener) {
+      .WillOnce([&](MoqtObjectListener* listener) {
         EXPECT_CALL(
             mock_stream_,
             Writev(ControlMessageOfType(MoqtMessageType::kSubscribeError), _));
         EXPECT_CALL(*track, RemoveObjectListener);
         listener->OnSubscribeRejected(MoqtSubscribeErrorReason(
             RequestErrorCode::kInternalError, "Test error"));
-      }));
+      });
   stream_input->OnSubscribeMessage(request);
   EXPECT_EQ(MoqtSessionPeer::GetSubscription(&session_, kDefaultPeerRequestId),
             nullptr);
@@ -2323,10 +2322,9 @@
   EXPECT_CALL(session, OpenOutgoingUnidirectionalStream())
       .WillOnce(Return(&data_stream));
   EXPECT_CALL(data_stream, SetVisitor)
-      .WillOnce(
-          Invoke([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
-            stream_visitor = std::move(visitor);
-          }));
+      .WillOnce([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
+        stream_visitor = std::move(visitor);
+      });
   EXPECT_CALL(data_stream, SetPriority).Times(1);
 }
 
@@ -2343,7 +2341,7 @@
   QUICHE_DCHECK(second_result != MoqtFetchTask::GetNextObjectResult::kSuccess);
   EXPECT_CALL(data_stream, CanWrite).WillRepeatedly(Return(true));
   EXPECT_CALL(*fetch_task, GetNextObject)
-      .WillOnce(Invoke([=](PublishedObject& output) {
+      .WillOnce([=](PublishedObject& output) {
         output.metadata.location = location;
         output.metadata.subgroup = 0;
         output.metadata.status = status;
@@ -2351,38 +2349,37 @@
         output.payload = quiche::QuicheMemSlice::Copy(payload);
         output.fin_after_this = true;  // should be ignored.
         return MoqtFetchTask::GetNextObjectResult::kSuccess;
-      }))
-      .WillOnce(
-          Invoke([=](PublishedObject& /*output*/) { return second_result; }));
+      })
+      .WillOnce([=](PublishedObject& /*output*/) { return second_result; });
   if (second_result == MoqtFetchTask::GetNextObjectResult::kEof) {
     EXPECT_CALL(data_stream, Writev)
-        .WillOnce(Invoke([](absl::Span<quiche::QuicheMemSlice> data,
-                            const quiche::StreamWriteOptions& options) {
+        .WillOnce([](absl::Span<quiche::QuicheMemSlice> data,
+                     const quiche::StreamWriteOptions& options) {
           quic::QuicDataReader reader(data[0].AsStringView());
           uint64_t type;
           EXPECT_TRUE(reader.ReadVarInt62(&type));
           EXPECT_EQ(type, MoqtDataStreamType::Fetch().value());
           EXPECT_FALSE(options.send_fin());  // fin_after_this is ignored.
           return absl::OkStatus();
-        }))
-        .WillOnce(Invoke([](absl::Span<quiche::QuicheMemSlice> data,
-                            const quiche::StreamWriteOptions& options) {
+        })
+        .WillOnce([](absl::Span<quiche::QuicheMemSlice> data,
+                     const quiche::StreamWriteOptions& options) {
           EXPECT_TRUE(data.empty());
           EXPECT_TRUE(options.send_fin());
           return absl::OkStatus();
-        }));
+        });
     return;
   }
   EXPECT_CALL(data_stream, Writev)
-      .WillOnce(Invoke([](absl::Span<quiche::QuicheMemSlice> data,
-                          const quiche::StreamWriteOptions& options) {
+      .WillOnce([](absl::Span<quiche::QuicheMemSlice> data,
+                   const quiche::StreamWriteOptions& options) {
         quic::QuicDataReader reader(data[0].AsStringView());
         uint64_t type;
         EXPECT_TRUE(reader.ReadVarInt62(&type));
         EXPECT_EQ(type, MoqtDataStreamType::Fetch().value());
         EXPECT_FALSE(options.send_fin());  // fin_after_this is ignored.
         return absl::OkStatus();
-      }));
+      });
   if (second_result == MoqtFetchTask::GetNextObjectResult::kError) {
     EXPECT_CALL(data_stream, ResetWithUserCode);
   }
@@ -3158,14 +3155,13 @@
       .WillRepeatedly(Return(kOutgoingUniStreamId));
   std::unique_ptr<webtransport::StreamVisitor> stream_visitor;
   EXPECT_CALL(data_mock, SetVisitor(_))
-      .WillOnce(
-          Invoke([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
-            stream_visitor = std::move(visitor);
-          }));
+      .WillOnce([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
+        stream_visitor = std::move(visitor);
+      });
   EXPECT_CALL(data_mock, CanWrite()).WillRepeatedly(Return(true));
-  EXPECT_CALL(data_mock, visitor()).WillRepeatedly(Invoke([&]() {
+  EXPECT_CALL(data_mock, visitor()).WillRepeatedly([&]() {
     return stream_visitor.get();
-  }));
+  });
   EXPECT_CALL(*track_publisher, GetCachedObject)
       .WillOnce(
           Return(PublishedObject{PublishedObjectMetadata{
@@ -3178,9 +3174,9 @@
                                  },
                                  quiche::QuicheMemSlice(), false}));
   EXPECT_CALL(data_mock, ResetWithUserCode(kResetCodeDeliveryTimeout))
-      .WillOnce(Invoke([&](webtransport::StreamErrorCode /*error*/) {
+      .WillOnce([&](webtransport::StreamErrorCode /*error*/) {
         stream_visitor.reset();
-      }));
+      });
   // Arrival time is very old; reset immediately.
   ON_CALL(*track_publisher, largest_location)
       .WillByDefault(Return(Location(0, 0)));
@@ -3227,14 +3223,13 @@
       .WillRepeatedly(Return(kOutgoingUniStreamId));
   std::unique_ptr<webtransport::StreamVisitor> stream_visitor;
   EXPECT_CALL(data_mock, SetVisitor(_))
-      .WillOnce(
-          Invoke([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
-            stream_visitor = std::move(visitor);
-          }));
+      .WillOnce([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
+        stream_visitor = std::move(visitor);
+      });
   EXPECT_CALL(data_mock, CanWrite()).WillRepeatedly(Return(true));
-  EXPECT_CALL(data_mock, visitor()).WillRepeatedly(Invoke([&]() {
+  EXPECT_CALL(data_mock, visitor()).WillRepeatedly([&]() {
     return stream_visitor.get();
-  }));
+  });
   EXPECT_CALL(*track_publisher, GetCachedObject)
       .WillOnce(Return(PublishedObject{
           PublishedObjectMetadata{Location(0, 0), 0,
@@ -3251,9 +3246,9 @@
   auto* delivery_alarm = static_cast<quic::test::MockAlarmFactory::TestAlarm*>(
       MoqtSessionPeer::GetAlarm(stream_visitor.get()));
   EXPECT_CALL(data_mock, ResetWithUserCode(kResetCodeDeliveryTimeout))
-      .WillOnce(Invoke([&](webtransport::StreamErrorCode /*error*/) {
+      .WillOnce([&](webtransport::StreamErrorCode /*error*/) {
         stream_visitor.reset();
-      }));
+      });
   delivery_alarm->Fire();
 }
 
@@ -3281,14 +3276,13 @@
       .WillRepeatedly(Return(&data_mock));
   std::unique_ptr<webtransport::StreamVisitor> stream_visitor;
   EXPECT_CALL(data_mock, SetVisitor(_))
-      .WillOnce(
-          Invoke([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
-            stream_visitor = std::move(visitor);
-          }));
+      .WillOnce([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
+        stream_visitor = std::move(visitor);
+      });
   EXPECT_CALL(data_mock, CanWrite()).WillRepeatedly(Return(true));
-  EXPECT_CALL(data_mock, visitor()).WillRepeatedly(Invoke([&]() {
+  EXPECT_CALL(data_mock, visitor()).WillRepeatedly([&]() {
     return stream_visitor.get();
-  }));
+  });
   EXPECT_CALL(*track_publisher, GetCachedObject)
       .WillOnce(Return(PublishedObject{
           PublishedObjectMetadata{Location(0, 0), 0,
@@ -3307,9 +3301,9 @@
   auto* delivery_alarm = static_cast<quic::test::MockAlarmFactory::TestAlarm*>(
       MoqtSessionPeer::GetAlarm(stream_visitor.get()));
   EXPECT_CALL(data_mock, ResetWithUserCode(kResetCodeDeliveryTimeout))
-      .WillOnce(Invoke([&](webtransport::StreamErrorCode /*error*/) {
+      .WillOnce([&](webtransport::StreamErrorCode /*error*/) {
         stream_visitor.reset();
-      }));
+      });
   delivery_alarm->Fire();
 }
 
@@ -3338,14 +3332,13 @@
       .WillRepeatedly(Return(&data_mock1));
   std::unique_ptr<webtransport::StreamVisitor> stream_visitor1;
   EXPECT_CALL(data_mock1, SetVisitor(_))
-      .WillOnce(
-          Invoke([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
-            stream_visitor1 = std::move(visitor);
-          }));
+      .WillOnce([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
+        stream_visitor1 = std::move(visitor);
+      });
   EXPECT_CALL(data_mock1, CanWrite()).WillRepeatedly(Return(true));
-  EXPECT_CALL(data_mock1, visitor()).WillRepeatedly(Invoke([&]() {
+  EXPECT_CALL(data_mock1, visitor()).WillRepeatedly([&]() {
     return stream_visitor1.get();
-  }));
+  });
   EXPECT_CALL(*track_publisher, GetCachedObject)
       .WillOnce(Return(PublishedObject{
           PublishedObjectMetadata{Location(0, 0), 0,
@@ -3368,14 +3361,13 @@
       .WillRepeatedly(Return(&data_mock2));
   std::unique_ptr<webtransport::StreamVisitor> stream_visitor2;
   EXPECT_CALL(data_mock2, SetVisitor(_))
-      .WillOnce(
-          Invoke([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
-            stream_visitor2 = std::move(visitor);
-          }));
+      .WillOnce([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
+        stream_visitor2 = std::move(visitor);
+      });
   EXPECT_CALL(data_mock2, CanWrite()).WillRepeatedly(Return(true));
-  EXPECT_CALL(data_mock2, visitor()).WillRepeatedly(Invoke([&]() {
+  EXPECT_CALL(data_mock2, visitor()).WillRepeatedly([&]() {
     return stream_visitor2.get();
-  }));
+  });
   EXPECT_CALL(*track_publisher, GetCachedObject)
       .WillOnce(Return(PublishedObject{
           PublishedObjectMetadata{Location(1, 0), 0,
@@ -3393,9 +3385,9 @@
   auto* delivery_alarm = static_cast<quic::test::MockAlarmFactory::TestAlarm*>(
       MoqtSessionPeer::GetAlarm(stream_visitor1.get()));
   EXPECT_CALL(data_mock1, ResetWithUserCode(kResetCodeDeliveryTimeout))
-      .WillOnce(Invoke([&](webtransport::StreamErrorCode /*error*/) {
+      .WillOnce([&](webtransport::StreamErrorCode /*error*/) {
         stream_visitor1.reset();
-      }));
+      });
   delivery_alarm->Fire();
 }
 
@@ -3850,7 +3842,7 @@
 
   MoqtTrackStatus track_status = DefaultSubscribe();
   EXPECT_CALL(*track, AddObjectListener)
-      .WillOnce(Invoke([&](MoqtObjectListener* listener) {
+      .WillOnce([&](MoqtObjectListener* listener) {
         EXPECT_CALL(*track, expiration)
             .WillRepeatedly(
                 Return(quic::QuicTimeDelta::FromMilliseconds(10000)));
@@ -3868,7 +3860,7 @@
                     Writev(SerializedControlMessage(expected_ok), _));
         EXPECT_CALL(*track, RemoveObjectListener);
         listener->OnSubscribeAccepted();
-      }));
+      });
   stream_input->OnTrackStatusMessage(track_status);
 }
 
@@ -3909,7 +3901,7 @@
   MoqtTrackStatus track_status = DefaultSubscribe();
   bool executed_AddObjectListener = false;
   EXPECT_CALL(*track, AddObjectListener)
-      .WillOnce(Invoke([&](MoqtObjectListener* listener) {
+      .WillOnce([&](MoqtObjectListener* listener) {
         EXPECT_CALL(
             control_stream,
             Writev(ControlMessageOfType(MoqtMessageType::kTrackStatusError),
@@ -3918,7 +3910,7 @@
         listener->OnSubscribeRejected(MoqtSubscribeErrorReason(
             RequestErrorCode::kInternalError, "Test error"));
         executed_AddObjectListener = true;
-      }));
+      });
   stream_input->OnTrackStatusMessage(track_status);
   EXPECT_TRUE(executed_AddObjectListener);
 }
diff --git a/quiche/quic/qbone/bonnet/icmp_reachable_test.cc b/quiche/quic/qbone/bonnet/icmp_reachable_test.cc
index 8e43bd0..555aa9f 100644
--- a/quiche/quic/qbone/bonnet/icmp_reachable_test.cc
+++ b/quiche/quic/qbone/bonnet/icmp_reachable_test.cc
@@ -22,7 +22,6 @@
 
 using ::testing::_;
 using ::testing::InSequence;
-using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::StrictMock;
 
@@ -106,9 +105,9 @@
 
     EXPECT_CALL(kernel_, setsockopt(read_fd_, SOL_ICMPV6, ICMP6_FILTER, _, _));
 
-    EXPECT_CALL(kernel_, close(read_fd_)).WillOnce(Invoke([](int fd) {
+    EXPECT_CALL(kernel_, close(read_fd_)).WillOnce([](int fd) {
       return close(fd);
-    }));
+    });
   }
 
  protected:
@@ -131,13 +130,13 @@
   ASSERT_TRUE(reachable.Init());
 
   EXPECT_CALL(kernel_, sendto(kFakeWriteFd, _, _, _, _, _))
-      .WillOnce(Invoke([](int sockfd, const void* buf, size_t len, int flags,
-                          const struct sockaddr* dest_addr, socklen_t addrlen) {
+      .WillOnce([](int sockfd, const void* buf, size_t len, int flags,
+                   const struct sockaddr* dest_addr, socklen_t addrlen) {
         auto icmp_header = GetHeaderFromPacket(buf, len);
         EXPECT_EQ(icmp_header.icmp6_type, ICMP6_ECHO_REQUEST);
         EXPECT_EQ(icmp_header.icmp6_seq, 1);
         return len;
-      }));
+      });
 
   event_loop_->RunEventLoopOnce(QuicTime::Delta::FromSeconds(1));
   EXPECT_FALSE(stats_.HasWriteErrors());
@@ -152,9 +151,9 @@
 
   EXPECT_CALL(kernel_, sendto(kFakeWriteFd, _, _, _, _, _))
       .Times(2)
-      .WillRepeatedly(Invoke([](int sockfd, const void* buf, size_t len,
-                                int flags, const struct sockaddr* dest_addr,
-                                socklen_t addrlen) { return len; }));
+      .WillRepeatedly([](int sockfd, const void* buf, size_t len, int flags,
+                         const struct sockaddr* dest_addr,
+                         socklen_t addrlen) { return len; });
 
   event_loop_->RunEventLoopOnce(QuicTime::Delta::FromSeconds(1));
   EXPECT_EQ(stats_.unreachable_count(), 0);
@@ -175,25 +174,23 @@
   icmp6_hdr last_request_hdr{};
   EXPECT_CALL(kernel_, sendto(kFakeWriteFd, _, _, _, _, _))
       .Times(2)
-      .WillRepeatedly(
-          Invoke([&last_request_hdr](
-                     int sockfd, const void* buf, size_t len, int flags,
-                     const struct sockaddr* dest_addr, socklen_t addrlen) {
-            last_request_hdr = GetHeaderFromPacket(buf, len);
-            return len;
-          }));
+      .WillRepeatedly([&last_request_hdr](
+                          int sockfd, const void* buf, size_t len, int flags,
+                          const struct sockaddr* dest_addr, socklen_t addrlen) {
+        last_request_hdr = GetHeaderFromPacket(buf, len);
+        return len;
+      });
 
   sockaddr_in6 source_addr{};
   std::string packed_source = source_.ToPackedString();
   memcpy(&source_addr.sin6_addr, packed_source.data(), packed_source.size());
 
   EXPECT_CALL(kernel_, recvfrom(read_fd_, _, _, _, _, _))
-      .WillOnce(
-          Invoke([&source_addr](int sockfd, void* buf, size_t len, int flags,
-                                struct sockaddr* src_addr, socklen_t* addrlen) {
-            *reinterpret_cast<sockaddr_in6*>(src_addr) = source_addr;
-            return read(sockfd, buf, len);
-          }));
+      .WillOnce([&source_addr](int sockfd, void* buf, size_t len, int flags,
+                               struct sockaddr* src_addr, socklen_t* addrlen) {
+        *reinterpret_cast<sockaddr_in6*>(src_addr) = source_addr;
+        return read(sockfd, buf, len);
+      });
 
   event_loop_->RunEventLoopOnce(QuicTime::Delta::FromSeconds(1));
   EXPECT_EQ(stats_.reachable_count(), 0);
@@ -219,11 +216,11 @@
   ASSERT_TRUE(reachable.Init());
 
   EXPECT_CALL(kernel_, sendto(kFakeWriteFd, _, _, _, _, _))
-      .WillOnce(Invoke([](int sockfd, const void* buf, size_t len, int flags,
-                          const struct sockaddr* dest_addr, socklen_t addrlen) {
+      .WillOnce([](int sockfd, const void* buf, size_t len, int flags,
+                   const struct sockaddr* dest_addr, socklen_t addrlen) {
         errno = EAGAIN;
         return 0;
-      }));
+      });
 
   event_loop_->RunEventLoopOnce(QuicTime::Delta::FromSeconds(1));
   EXPECT_EQ(stats_.WriteErrorCount(EAGAIN), 1);
@@ -237,16 +234,16 @@
   ASSERT_TRUE(reachable.Init());
 
   EXPECT_CALL(kernel_, sendto(kFakeWriteFd, _, _, _, _, _))
-      .WillOnce(Invoke([](int sockfd, const void* buf, size_t len, int flags,
-                          const struct sockaddr* dest_addr,
-                          socklen_t addrlen) { return len; }));
+      .WillOnce([](int sockfd, const void* buf, size_t len, int flags,
+                   const struct sockaddr* dest_addr,
+                   socklen_t addrlen) { return len; });
 
   EXPECT_CALL(kernel_, recvfrom(read_fd_, _, _, _, _, _))
-      .WillOnce(Invoke([](int sockfd, void* buf, size_t len, int flags,
-                          struct sockaddr* src_addr, socklen_t* addrlen) {
+      .WillOnce([](int sockfd, void* buf, size_t len, int flags,
+                   struct sockaddr* src_addr, socklen_t* addrlen) {
         errno = EIO;
         return -1;
-      }));
+      });
 
   icmp6_hdr response{};
 
diff --git a/quiche/quic/qbone/bonnet/tun_device_controller_test.cc b/quiche/quic/qbone/bonnet/tun_device_controller_test.cc
index 58a57d0..863e0c9 100644
--- a/quiche/quic/qbone/bonnet/tun_device_controller_test.cc
+++ b/quiche/quic/qbone/bonnet/tun_device_controller_test.cc
@@ -35,7 +35,6 @@
 constexpr int kOldPrefixLen = 24;
 
 using ::testing::_;
-using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::StrictMock;
 
@@ -56,11 +55,11 @@
  protected:
   void ExpectLinkInfo(const std::string& interface_name, int ifindex) {
     EXPECT_CALL(netlink_, GetLinkInfo(interface_name, _))
-        .WillOnce(Invoke([ifindex](absl::string_view ifname,
-                                   NetlinkInterface::LinkInfo* link_info) {
+        .WillOnce([ifindex](absl::string_view ifname,
+                            NetlinkInterface::LinkInfo* link_info) {
           link_info->index = ifindex;
           return true;
-        }));
+        });
   }
 
   MockNetlink netlink_;
@@ -90,15 +89,15 @@
   ExpectLinkInfo(kIfname, kIfindex);
 
   EXPECT_CALL(netlink_, GetAddresses(kIfindex, _, _, _))
-      .WillOnce(Invoke([](int interface_index, uint8_t unwanted_flags,
-                          std::vector<NetlinkInterface::AddressInfo>* addresses,
-                          int* num_ipv6_nodad_dadfailed_addresses) {
+      .WillOnce([](int interface_index, uint8_t unwanted_flags,
+                   std::vector<NetlinkInterface::AddressInfo>* addresses,
+                   int* num_ipv6_nodad_dadfailed_addresses) {
         NetlinkInterface::AddressInfo info{};
         info.interface_address.FromString(kOldAddress);
         info.prefix_length = kOldPrefixLen;
         addresses->emplace_back(info);
         return true;
-      }));
+      });
 
   QuicIpAddress old_address;
   old_address.FromString(kOldAddress);
@@ -124,26 +123,25 @@
 
   const int num_matching_routes = 3;
   EXPECT_CALL(netlink_, GetRouteInfo(_))
-      .WillOnce(
-          Invoke([](std::vector<NetlinkInterface::RoutingRule>* routing_rules) {
-            NetlinkInterface::RoutingRule non_matching_route{};
-            non_matching_route.table = QboneConstants::kQboneRouteTableId;
-            non_matching_route.out_interface = kIfindex + 1;
-            routing_rules->push_back(non_matching_route);
+      .WillOnce([](std::vector<NetlinkInterface::RoutingRule>* routing_rules) {
+        NetlinkInterface::RoutingRule non_matching_route{};
+        non_matching_route.table = QboneConstants::kQboneRouteTableId;
+        non_matching_route.out_interface = kIfindex + 1;
+        routing_rules->push_back(non_matching_route);
 
-            NetlinkInterface::RoutingRule matching_route{};
-            matching_route.table = QboneConstants::kQboneRouteTableId;
-            matching_route.out_interface = kIfindex;
-            for (int i = 0; i < num_matching_routes; i++) {
-              routing_rules->push_back(matching_route);
-            }
+        NetlinkInterface::RoutingRule matching_route{};
+        matching_route.table = QboneConstants::kQboneRouteTableId;
+        matching_route.out_interface = kIfindex;
+        for (int i = 0; i < num_matching_routes; i++) {
+          routing_rules->push_back(matching_route);
+        }
 
-            NetlinkInterface::RoutingRule non_matching_table{};
-            non_matching_table.table = QboneConstants::kQboneRouteTableId + 1;
-            non_matching_table.out_interface = kIfindex;
-            routing_rules->push_back(non_matching_table);
-            return true;
-          }));
+        NetlinkInterface::RoutingRule non_matching_table{};
+        non_matching_table.table = QboneConstants::kQboneRouteTableId + 1;
+        non_matching_table.out_interface = kIfindex;
+        routing_rules->push_back(non_matching_table);
+        return true;
+      });
 
   EXPECT_CALL(netlink_, ChangeRoute(NetlinkInterface::Verb::kRemove,
                                     QboneConstants::kQboneRouteTableId, _, _, _,
diff --git a/quiche/quic/qbone/bonnet/tun_device_packet_exchanger_test.cc b/quiche/quic/qbone/bonnet/tun_device_packet_exchanger_test.cc
index 988b00e..e84a0f1 100644
--- a/quiche/quic/qbone/bonnet/tun_device_packet_exchanger_test.cc
+++ b/quiche/quic/qbone/bonnet/tun_device_packet_exchanger_test.cc
@@ -21,7 +21,6 @@
 const int kFd = 15;
 
 using ::testing::_;
-using ::testing::Invoke;
 using ::testing::StrEq;
 using ::testing::StrictMock;
 
@@ -53,10 +52,10 @@
 TEST_F(TunDevicePacketExchangerTest, WritePacketReturnsFalseOnError) {
   std::string packet = "fake packet";
   EXPECT_CALL(mock_kernel_, write(kFd, _, packet.size()))
-      .WillOnce(Invoke([](int fd, const void* buf, size_t count) {
+      .WillOnce([](int fd, const void* buf, size_t count) {
         errno = ECOMM;
         return -1;
-      }));
+      });
 
   EXPECT_CALL(mock_visitor_, OnWriteError(_));
   EXPECT_CALL(mock_visitor_, OnWrite(StrEq(packet))).Times(1);
@@ -67,10 +66,10 @@
        WritePacketReturnFalseAndBlockedOnBlockedTunnel) {
   std::string packet = "fake packet";
   EXPECT_CALL(mock_kernel_, write(kFd, _, packet.size()))
-      .WillOnce(Invoke([](int fd, const void* buf, size_t count) {
+      .WillOnce([](int fd, const void* buf, size_t count) {
         errno = EAGAIN;
         return -1;
-      }));
+      });
 
   EXPECT_CALL(mock_stats_, OnWriteError(_)).Times(1);
   EXPECT_CALL(mock_visitor_, OnWrite(StrEq(packet))).Times(1);
@@ -80,10 +79,10 @@
 TEST_F(TunDevicePacketExchangerTest, WritePacketReturnsTrueOnSuccessfulWrite) {
   std::string packet = "fake packet";
   EXPECT_CALL(mock_kernel_, write(kFd, _, packet.size()))
-      .WillOnce(Invoke([packet](int fd, const void* buf, size_t count) {
+      .WillOnce([packet](int fd, const void* buf, size_t count) {
         EXPECT_THAT(reinterpret_cast<const char*>(buf), StrEq(packet));
         return count;
-      }));
+      });
 
   EXPECT_CALL(mock_stats_, OnPacketWritten(_)).Times(1);
   EXPECT_CALL(mock_visitor_, OnWrite(StrEq(packet))).Times(1);
@@ -92,20 +91,20 @@
 
 TEST_F(TunDevicePacketExchangerTest, ReadPacketReturnsNullOnError) {
   EXPECT_CALL(mock_kernel_, read(kFd, _, kMtu))
-      .WillOnce(Invoke([](int fd, void* buf, size_t count) {
+      .WillOnce([](int fd, void* buf, size_t count) {
         errno = ECOMM;
         return -1;
-      }));
+      });
   EXPECT_CALL(mock_visitor_, OnReadError(_));
   exchanger_.ReadAndDeliverPacket(&mock_client_);
 }
 
 TEST_F(TunDevicePacketExchangerTest, ReadPacketReturnsNullOnBlockedRead) {
   EXPECT_CALL(mock_kernel_, read(kFd, _, kMtu))
-      .WillOnce(Invoke([](int fd, void* buf, size_t count) {
+      .WillOnce([](int fd, void* buf, size_t count) {
         errno = EAGAIN;
         return -1;
-      }));
+      });
   EXPECT_CALL(mock_stats_, OnReadError(_)).Times(1);
   EXPECT_FALSE(exchanger_.ReadAndDeliverPacket(&mock_client_));
 }
@@ -114,10 +113,10 @@
        ReadPacketReturnsThePacketOnSuccessfulRead) {
   std::string packet = "fake_packet";
   EXPECT_CALL(mock_kernel_, read(kFd, _, kMtu))
-      .WillOnce(Invoke([packet](int fd, void* buf, size_t count) {
+      .WillOnce([packet](int fd, void* buf, size_t count) {
         memcpy(buf, packet.data(), packet.size());
         return packet.size();
-      }));
+      });
   EXPECT_CALL(mock_client_, ProcessPacketFromNetwork(StrEq(packet)));
   EXPECT_CALL(mock_stats_, OnPacketRead(_)).Times(1);
   EXPECT_TRUE(exchanger_.ReadAndDeliverPacket(&mock_client_));
diff --git a/quiche/quic/qbone/bonnet/tun_device_test.cc b/quiche/quic/qbone/bonnet/tun_device_test.cc
index cc82a2f..5bb50e1 100644
--- a/quiche/quic/qbone/bonnet/tun_device_test.cc
+++ b/quiche/quic/qbone/bonnet/tun_device_test.cc
@@ -16,7 +16,6 @@
 
 using ::testing::_;
 using ::testing::AnyNumber;
-using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::StrEq;
 using ::testing::Unused;
@@ -35,38 +34,38 @@
   void SetUp() override {
     EXPECT_CALL(mock_kernel_, socket(AF_INET6, _, _))
         .Times(AnyNumber())
-        .WillRepeatedly(Invoke([this](Unused, Unused, Unused) {
+        .WillRepeatedly([this](Unused, Unused, Unused) {
           EXPECT_CALL(mock_kernel_, close(next_fd_)).WillOnce(Return(0));
           return next_fd_++;
-        }));
+        });
   }
 
   // Set the expectations for calling Init().
   void SetInitExpectations(int mtu, bool persist) {
     EXPECT_CALL(mock_kernel_, open(StrEq("/dev/net/tun"), _))
         .Times(AnyNumber())
-        .WillRepeatedly(Invoke([this](Unused, Unused) {
+        .WillRepeatedly([this](Unused, Unused) {
           EXPECT_CALL(mock_kernel_, close(next_fd_)).WillOnce(Return(0));
           return next_fd_++;
-        }));
+        });
     EXPECT_CALL(mock_kernel_, ioctl(_, TUNGETFEATURES, _))
         .Times(AnyNumber())
-        .WillRepeatedly(Invoke([](Unused, Unused, void* argp) {
+        .WillRepeatedly([](Unused, Unused, void* argp) {
           auto* actual_flags = reinterpret_cast<int*>(argp);
           *actual_flags = kSupportedFeatures;
           return 0;
-        }));
+        });
     EXPECT_CALL(mock_kernel_, ioctl(_, TUNSETIFF, _))
         .Times(AnyNumber())
-        .WillRepeatedly(Invoke([](Unused, Unused, void* argp) {
+        .WillRepeatedly([](Unused, Unused, void* argp) {
           auto* ifr = reinterpret_cast<struct ifreq*>(argp);
           EXPECT_EQ(IFF_TUN | IFF_MULTI_QUEUE | IFF_NO_PI, ifr->ifr_flags);
           EXPECT_THAT(ifr->ifr_name, StrEq(kDeviceName));
           return 0;
-        }));
+        });
     EXPECT_CALL(mock_kernel_, ioctl(_, TUNSETPERSIST, _))
         .Times(AnyNumber())
-        .WillRepeatedly(Invoke([persist](Unused, Unused, void* argp) {
+        .WillRepeatedly([persist](Unused, Unused, void* argp) {
           auto* ifr = reinterpret_cast<struct ifreq*>(argp);
           if (persist) {
             EXPECT_THAT(ifr->ifr_name, StrEq(kDeviceName));
@@ -74,21 +73,21 @@
             EXPECT_EQ(nullptr, ifr);
           }
           return 0;
-        }));
+        });
     EXPECT_CALL(mock_kernel_, ioctl(_, SIOCSIFMTU, _))
         .Times(AnyNumber())
-        .WillRepeatedly(Invoke([mtu](Unused, Unused, void* argp) {
+        .WillRepeatedly([mtu](Unused, Unused, void* argp) {
           auto* ifr = reinterpret_cast<struct ifreq*>(argp);
           EXPECT_EQ(mtu, ifr->ifr_mtu);
           EXPECT_THAT(ifr->ifr_name, StrEq(kDeviceName));
           return 0;
-        }));
+        });
   }
 
   // Expect that Up() will be called. Force the call to fail when fail == true.
   void ExpectUp(bool fail) {
     EXPECT_CALL(mock_kernel_, ioctl(_, SIOCSIFFLAGS, _))
-        .WillOnce(Invoke([fail](Unused, Unused, void* argp) {
+        .WillOnce([fail](Unused, Unused, void* argp) {
           auto* ifr = reinterpret_cast<struct ifreq*>(argp);
           EXPECT_TRUE(ifr->ifr_flags & IFF_UP);
           EXPECT_THAT(ifr->ifr_name, StrEq(kDeviceName));
@@ -97,14 +96,14 @@
           } else {
             return 0;
           }
-        }));
+        });
   }
 
   // Expect that Down() will be called *after* the interface is up. Force the
   // call to fail when fail == true.
   void ExpectDown(bool fail) {
     EXPECT_CALL(mock_kernel_, ioctl(_, SIOCSIFFLAGS, _))
-        .WillOnce(Invoke([fail](Unused, Unused, void* argp) {
+        .WillOnce([fail](Unused, Unused, void* argp) {
           auto* ifr = reinterpret_cast<struct ifreq*>(argp);
           EXPECT_FALSE(ifr->ifr_flags & IFF_UP);
           EXPECT_THAT(ifr->ifr_name, StrEq(kDeviceName));
@@ -113,7 +112,7 @@
           } else {
             return 0;
           }
-        }));
+        });
   }
 
   MockKernel mock_kernel_;
@@ -154,11 +153,11 @@
 TEST_F(TunDeviceTest, TooFewFeature) {
   SetInitExpectations(/* mtu = */ 1500, /* persist = */ false);
   EXPECT_CALL(mock_kernel_, ioctl(_, TUNGETFEATURES, _))
-      .WillOnce(Invoke([](Unused, Unused, void* argp) {
+      .WillOnce([](Unused, Unused, void* argp) {
         int* actual_features = reinterpret_cast<int*>(argp);
         *actual_features = IFF_TUN | IFF_ONE_QUEUE;
         return 0;
-      }));
+      });
   TunTapDevice tun_device(kDeviceName, 1500, false, true, false, &mock_kernel_);
   EXPECT_FALSE(tun_device.Init());
   EXPECT_EQ(tun_device.GetFileDescriptor(), -1);
diff --git a/quiche/quic/qbone/platform/netlink_test.cc b/quiche/quic/qbone/platform/netlink_test.cc
index e1f57c5..44f7e86 100644
--- a/quiche/quic/qbone/platform/netlink_test.cc
+++ b/quiche/quic/qbone/platform/netlink_test.cc
@@ -22,7 +22,6 @@
 using ::testing::_;
 using ::testing::Contains;
 using ::testing::InSequence;
-using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::Unused;
 
@@ -32,10 +31,10 @@
  protected:
   NetlinkTest() {
     ON_CALL(mock_kernel_, socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE))
-        .WillByDefault(Invoke([this](Unused, Unused, Unused) {
+        .WillByDefault([this](Unused, Unused, Unused) {
           EXPECT_CALL(mock_kernel_, close(kSocketFd)).WillOnce(Return(0));
           return kSocketFd;
-        }));
+        });
   }
 
   void ExpectNetlinkPacket(
@@ -48,8 +47,8 @@
     InSequence s;
 
     EXPECT_CALL(mock_kernel_, sendmsg(kSocketFd, _, _))
-        .WillOnce(Invoke([type, flags, send_callback](
-                             Unused, const struct msghdr* msg, int) {
+        .WillOnce([type, flags, send_callback](Unused, const struct msghdr* msg,
+                                               int) {
           EXPECT_EQ(sizeof(struct sockaddr_nl), msg->msg_namelen);
           auto* nl_addr =
               reinterpret_cast<const struct sockaddr_nl*>(msg->msg_name);
@@ -80,13 +79,13 @@
           QUICHE_CHECK_EQ(seq, -1);
           seq = netlink_message->nlmsg_seq;
           return buf.size();
-        }));
+        });
 
     EXPECT_CALL(mock_kernel_,
                 recvfrom(kSocketFd, _, 0, MSG_PEEK | MSG_TRUNC, _, _))
-        .WillOnce(Invoke([this, recv_callback](Unused, Unused, Unused, Unused,
-                                               struct sockaddr* src_addr,
-                                               socklen_t* addrlen) {
+        .WillOnce([this, recv_callback](Unused, Unused, Unused, Unused,
+                                        struct sockaddr* src_addr,
+                                        socklen_t* addrlen) {
           auto* nl_addr = reinterpret_cast<struct sockaddr_nl*>(src_addr);
           nl_addr->nl_family = AF_NETLINK;
           nl_addr->nl_pid = 0;     // from kernel
@@ -95,12 +94,12 @@
           int ret = recv_callback(reply_packet_, sizeof(reply_packet_), seq);
           QUICHE_CHECK_LE(ret, sizeof(reply_packet_));
           return ret;
-        }));
+        });
 
     EXPECT_CALL(mock_kernel_, recvfrom(kSocketFd, _, _, _, _, _))
-        .WillOnce(Invoke([recv_callback](Unused, void* buf, size_t len, Unused,
-                                         struct sockaddr* src_addr,
-                                         socklen_t* addrlen) {
+        .WillOnce([recv_callback](Unused, void* buf, size_t len, Unused,
+                                  struct sockaddr* src_addr,
+                                  socklen_t* addrlen) {
           auto* nl_addr = reinterpret_cast<struct sockaddr_nl*>(src_addr);
           nl_addr->nl_family = AF_NETLINK;
           nl_addr->nl_pid = 0;     // from kernel
@@ -110,7 +109,7 @@
           EXPECT_GE(len, ret);
           seq = -1;
           return ret;
-        }));
+        });
   }
 
   char reply_packet_[4096];
diff --git a/quiche/quic/qbone/qbone_packet_processor_test.cc b/quiche/quic/qbone/qbone_packet_processor_test.cc
index ec424e2..b29031d 100644
--- a/quiche/quic/qbone/qbone_packet_processor_test.cc
+++ b/quiche/quic/qbone/qbone_packet_processor_test.cc
@@ -21,7 +21,6 @@
 using OutputInterface = QbonePacketProcessor::OutputInterface;
 using ::testing::_;
 using ::testing::Eq;
-using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::WithArgs;
 
@@ -509,8 +508,8 @@
 TEST_F(QbonePacketProcessorTest, Icmp6EchoResponseHasRightPayload) {
   auto filter = std::make_unique<MockPacketFilter>();
   EXPECT_CALL(*filter, FilterPacket(_, _, _, _))
-      .WillOnce(WithArgs<2, 3>(
-          Invoke([](absl::string_view payload, icmp6_hdr* icmp_header) {
+      .WillOnce(
+          WithArgs<2, 3>([](absl::string_view payload, icmp6_hdr* icmp_header) {
             icmp_header->icmp6_type = ICMP6_ECHO_REPLY;
             icmp_header->icmp6_code = 0;
             auto* request_header =
@@ -518,12 +517,12 @@
             icmp_header->icmp6_id = request_header->icmp6_id;
             icmp_header->icmp6_seq = request_header->icmp6_seq;
             return ProcessingResult::ICMP;
-          })));
+          }));
   processor_->set_filter(std::move(filter));
 
   EXPECT_CALL(stats_, OnPacketDroppedWithIcmp(Direction::FROM_OFF_NETWORK, _));
   EXPECT_CALL(output_, SendPacketToClient(_))
-      .WillOnce(Invoke([](absl::string_view packet) {
+      .WillOnce([](absl::string_view packet) {
         // Explicit conversion because otherwise it is treated as a null
         // terminated string.
         absl::string_view expected = absl::string_view(
@@ -532,7 +531,7 @@
         EXPECT_THAT(packet, Eq(expected));
         QUIC_LOG(INFO) << "ICMP response:\n"
                        << quiche::QuicheTextUtils::HexDump(packet);
-      }));
+      });
   SendPacketFromClient(kReferenceEchoRequest);
 }
 
diff --git a/quiche/quic/qbone/qbone_session_test.cc b/quiche/quic/qbone/qbone_session_test.cc
index 9c943d7..6edeb00 100644
--- a/quiche/quic/qbone/qbone_session_test.cc
+++ b/quiche/quic/qbone/qbone_session_test.cc
@@ -40,7 +40,6 @@
 using ::testing::Contains;
 using ::testing::ElementsAre;
 using ::testing::Eq;
-using ::testing::Invoke;
 using ::testing::NiceMock;
 using ::testing::Not;
 
@@ -362,11 +361,11 @@
     MockPacketWriter* client_writer = static_cast<MockPacketWriter*>(
         QuicConnectionPeer::GetWriter(client_peer_->connection()));
     ON_CALL(*client_writer, WritePacket(_, _, _, _, _, _))
-        .WillByDefault(Invoke([this](const char* buffer, size_t buf_len,
-                                     const QuicIpAddress& self_address,
-                                     const QuicSocketAddress& peer_address,
-                                     PerPacketOptions* option,
-                                     const QuicPacketWriterParams& params) {
+        .WillByDefault([this](const char* buffer, size_t buf_len,
+                              const QuicIpAddress& self_address,
+                              const QuicSocketAddress& peer_address,
+                              PerPacketOptions* option,
+                              const QuicPacketWriterParams& params) {
           char* copy = new char[1024 * 1024];
           memcpy(copy, buffer, buf_len);
           runner_.Schedule([this, copy, buf_len] {
@@ -377,15 +376,15 @@
             delete[] copy;
           });
           return WriteResult(WRITE_STATUS_OK, buf_len);
-        }));
+        });
     MockPacketWriter* server_writer = static_cast<MockPacketWriter*>(
         QuicConnectionPeer::GetWriter(server_peer_->connection()));
     ON_CALL(*server_writer, WritePacket(_, _, _, _, _, _))
-        .WillByDefault(Invoke([this](const char* buffer, size_t buf_len,
-                                     const QuicIpAddress& self_address,
-                                     const QuicSocketAddress& peer_address,
-                                     PerPacketOptions* options,
-                                     const QuicPacketWriterParams& params) {
+        .WillByDefault([this](const char* buffer, size_t buf_len,
+                              const QuicIpAddress& self_address,
+                              const QuicSocketAddress& peer_address,
+                              PerPacketOptions* options,
+                              const QuicPacketWriterParams& params) {
           char* copy = new char[1024 * 1024];
           memcpy(copy, buffer, buf_len);
           runner_.Schedule([this, copy, buf_len] {
@@ -396,7 +395,7 @@
             delete[] copy;
           });
           return WriteResult(WRITE_STATUS_OK, buf_len);
-        }));
+        });
   }
 
   void StartHandshake() {
diff --git a/quiche/quic/tools/quic_simple_server_session_test.cc b/quiche/quic/tools/quic_simple_server_session_test.cc
index d290f81..a9616a0 100644
--- a/quiche/quic/tools/quic_simple_server_session_test.cc
+++ b/quiche/quic/tools/quic_simple_server_session_test.cc
@@ -38,7 +38,6 @@
 #include "quiche/quic/tools/quic_simple_server_stream.h"
 
 using testing::_;
-using testing::Invoke;
 using testing::StrictMock;
 
 namespace quic {
@@ -117,8 +116,7 @@
                                StreamSendingState state) {
       return QuicConsumedData(write_length, state != NO_FIN);
     };
-    ON_CALL(*this, SendStreamData(_, _, _, _))
-        .WillByDefault(Invoke(consume_all_data));
+    ON_CALL(*this, SendStreamData(_, _, _, _)).WillByDefault(consume_all_data);
   }
 
   MOCK_METHOD(QuicConsumedData, SendStreamData,
@@ -209,7 +207,7 @@
 
     if (VersionHasIetfQuicFrames(transport_version())) {
       EXPECT_CALL(*session_, WriteControlFrame(_, _))
-          .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
+          .WillRepeatedly(&ClearControlFrameWithTransmissionType);
     }
     session_->OnConfigNegotiated();
   }