diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index 73e0ca7..acb6de8 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -11034,14 +11034,13 @@
     return;
   }
   // Received frame causes connection close.
-  EXPECT_CALL(visitor_, OnMaxStreamsFrame(_))
-      .WillOnce(InvokeWithoutArgs([this]() {
-        EXPECT_CALL(visitor_, OnConnectionClosed(_, _));
-        connection_.CloseConnection(
-            QUIC_TOO_MANY_BUFFERED_CONTROL_FRAMES, "error",
-            ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-        return true;
-      }));
+  EXPECT_CALL(visitor_, OnMaxStreamsFrame(_)).WillOnce([this]() {
+    EXPECT_CALL(visitor_, OnConnectionClosed(_, _));
+    connection_.CloseConnection(
+        QUIC_TOO_MANY_BUFFERED_CONTROL_FRAMES, "error",
+        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
+    return true;
+  });
   QuicFrames frames;
   frames.push_back(QuicFrame(QuicMaxStreamsFrame()));
   frames.push_back(QuicFrame(QuicPaddingFrame(-1)));
@@ -11053,14 +11052,13 @@
     return;
   }
   // Received frame causes connection close.
-  EXPECT_CALL(visitor_, OnStreamsBlockedFrame(_))
-      .WillOnce(InvokeWithoutArgs([this]() {
-        EXPECT_CALL(visitor_, OnConnectionClosed(_, _));
-        connection_.CloseConnection(
-            QUIC_TOO_MANY_BUFFERED_CONTROL_FRAMES, "error",
-            ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-        return true;
-      }));
+  EXPECT_CALL(visitor_, OnStreamsBlockedFrame(_)).WillOnce([this]() {
+    EXPECT_CALL(visitor_, OnConnectionClosed(_, _));
+    connection_.CloseConnection(
+        QUIC_TOO_MANY_BUFFERED_CONTROL_FRAMES, "error",
+        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
+    return true;
+  });
   QuicFrames frames;
   frames.push_back(
       QuicFrame(QuicStreamsBlockedFrame(kInvalidControlFrameId, 10, false)));
diff --git a/quiche/quic/core/quic_crypto_stream_test.cc b/quiche/quic/core/quic_crypto_stream_test.cc
index 269614e..6da190f 100644
--- a/quiche/quic/core/quic_crypto_stream_test.cc
+++ b/quiche/quic/core/quic_crypto_stream_test.cc
@@ -502,11 +502,11 @@
       session_,
       WritevData(QuicUtils::GetCryptoStreamId(connection_->transport_version()),
                  650, 1350, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
+      .WillOnce([this]() {
         return session_.ConsumeData(
             QuicUtils::GetCryptoStreamId(connection_->transport_version()), 150,
             1350, NO_FIN, HANDSHAKE_RETRANSMISSION, std::nullopt);
-      }));
+      });
 
   EXPECT_FALSE(stream_->RetransmitStreamData(1350, 1350, false,
                                              HANDSHAKE_RETRANSMISSION));
diff --git a/quiche/quic/core/quic_sent_packet_manager_test.cc b/quiche/quic/core/quic_sent_packet_manager_test.cc
index ede33a9..eb5288b 100644
--- a/quiche/quic/core/quic_sent_packet_manager_test.cc
+++ b/quiche/quic/core/quic_sent_packet_manager_test.cc
@@ -886,10 +886,8 @@
   // The first retransmits 2 packets.
   EXPECT_CALL(notifier_, RetransmitFrames(_, _))
       .Times(2)
-      .WillOnce(
-          InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(6); }))
-      .WillOnce(
-          InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(7); }));
+      .WillOnce([this]() { return RetransmitCryptoPacket(6); })
+      .WillOnce([this]() { return RetransmitCryptoPacket(7); });
   manager_.OnRetransmissionTimeout();
   // Expect all 4 handshake packets to be in flight and 3 data packets.
   EXPECT_EQ(7 * kDefaultLength, manager_.GetBytesInFlight());
@@ -898,10 +896,8 @@
   // The second retransmits 2 packets.
   EXPECT_CALL(notifier_, RetransmitFrames(_, _))
       .Times(2)
-      .WillOnce(
-          InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(8); }))
-      .WillOnce(
-          InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(9); }));
+      .WillOnce([this]() { return RetransmitCryptoPacket(8); })
+      .WillOnce([this]() { return RetransmitCryptoPacket(9); });
   manager_.OnRetransmissionTimeout();
   EXPECT_EQ(9 * kDefaultLength, manager_.GetBytesInFlight());
   EXPECT_TRUE(manager_.HasUnackedCryptoPackets());
@@ -931,15 +927,15 @@
   EXPECT_TRUE(manager_.HasUnackedCryptoPackets());
 
   // Retransmit the crypto packet as 2.
-  EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(
-          InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(2); }));
+  EXPECT_CALL(notifier_, RetransmitFrames(_, _)).WillOnce([this]() {
+    return RetransmitCryptoPacket(2);
+  });
   manager_.OnRetransmissionTimeout();
 
   // Retransmit the crypto packet as 3.
-  EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(
-          InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(3); }));
+  EXPECT_CALL(notifier_, RetransmitFrames(_, _)).WillOnce([this]() {
+    return RetransmitCryptoPacket(3);
+  });
   manager_.OnRetransmissionTimeout();
 
   // Now ack the second crypto packet, and ensure the first gets removed, but
@@ -972,10 +968,8 @@
   // Retransmit 2 crypto packets, but not the serialized packet.
   EXPECT_CALL(notifier_, RetransmitFrames(_, _))
       .Times(2)
-      .WillOnce(
-          InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(4); }))
-      .WillOnce(
-          InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(5); }));
+      .WillOnce([this]() { return RetransmitCryptoPacket(4); })
+      .WillOnce([this]() { return RetransmitCryptoPacket(5); });
   manager_.OnRetransmissionTimeout();
   EXPECT_TRUE(manager_.HasUnackedCryptoPackets());
 }
@@ -988,16 +982,16 @@
   EXPECT_TRUE(manager_.HasUnackedCryptoPackets());
 
   // Retransmit the crypto packet as 2.
-  EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(
-          InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(2); }));
+  EXPECT_CALL(notifier_, RetransmitFrames(_, _)).WillOnce([this]() {
+    return RetransmitCryptoPacket(2);
+  });
   manager_.OnRetransmissionTimeout();
   EXPECT_TRUE(manager_.HasUnackedCryptoPackets());
 
   // Retransmit the crypto packet as 3.
-  EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(
-          InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(3); }));
+  EXPECT_CALL(notifier_, RetransmitFrames(_, _)).WillOnce([this]() {
+    return RetransmitCryptoPacket(3);
+  });
   manager_.OnRetransmissionTimeout();
   EXPECT_TRUE(manager_.HasUnackedCryptoPackets());
 
@@ -1049,9 +1043,9 @@
 
   // Retransmit the packet by invoking the retransmission timeout.
   clock_.AdvanceTime(1.5 * srtt);
-  EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(
-          InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(2); }));
+  EXPECT_CALL(notifier_, RetransmitFrames(_, _)).WillOnce([this]() {
+    return RetransmitCryptoPacket(2);
+  });
   // When session decides what to write, crypto_packet_send_time gets updated.
   crypto_packet_send_time = clock_.Now();
   manager_.OnRetransmissionTimeout();
@@ -1062,9 +1056,9 @@
 
   // Retransmit the packet for the 2nd time.
   clock_.AdvanceTime(2 * 1.5 * srtt);
-  EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(
-          InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(3); }));
+  EXPECT_CALL(notifier_, RetransmitFrames(_, _)).WillOnce([this]() {
+    return RetransmitCryptoPacket(3);
+  });
   // When session decides what to write, crypto_packet_send_time gets updated.
   crypto_packet_send_time = clock_.Now();
   manager_.OnRetransmissionTimeout();
@@ -1107,9 +1101,9 @@
 
   // Retransmit the packet by invoking the retransmission timeout.
   clock_.AdvanceTime(2 * srtt);
-  EXPECT_CALL(notifier_, RetransmitFrames(_, _))
-      .WillOnce(
-          InvokeWithoutArgs([this]() { return RetransmitCryptoPacket(2); }));
+  EXPECT_CALL(notifier_, RetransmitFrames(_, _)).WillOnce([this]() {
+    return RetransmitCryptoPacket(2);
+  });
   crypto_packet_send_time = clock_.Now();
   manager_.OnRetransmissionTimeout();
 
diff --git a/quiche/quic/core/quic_session_test.cc b/quiche/quic/core/quic_session_test.cc
index 7b1e79c..b99ac47 100644
--- a/quiche/quic/core/quic_session_test.cc
+++ b/quiche/quic/core/quic_session_test.cc
@@ -3348,13 +3348,11 @@
   // Try to send more data than the flow control limit allows.
   const uint64_t kOverflow = 15;
   std::string body(kWindow + kOverflow, 'a');
-  EXPECT_CALL(*connection_, SendControlFrame(_))
-      .WillOnce(testing::InvokeWithoutArgs([this]() {
-        connection_->ReallyCloseConnection(
-            QUIC_PACKET_WRITE_ERROR, "write error",
-            ConnectionCloseBehavior::SILENT_CLOSE);
-        return false;
-      }));
+  EXPECT_CALL(*connection_, SendControlFrame(_)).WillOnce([this]() {
+    connection_->ReallyCloseConnection(QUIC_PACKET_WRITE_ERROR, "write error",
+                                       ConnectionCloseBehavior::SILENT_CLOSE);
+    return false;
+  });
   stream->WriteOrBufferData(body, false, nullptr);
 }
 
@@ -3382,12 +3380,12 @@
   // Flush both frames.
   EXPECT_CALL(*connection_,
               SendCryptoData(ENCRYPTION_FORWARD_SECURE, 350, 1000))
-      .WillOnce(testing::InvokeWithoutArgs([this]() {
+      .WillOnce([this]() {
         connection_->ReallyCloseConnection(
             QUIC_PACKET_WRITE_ERROR, "write error",
             ConnectionCloseBehavior::SILENT_CLOSE);
         return 350;
-      }));
+      });
   if (!GetQuicReloadableFlag(
           quic_no_write_control_frame_upon_connection_close)) {
     EXPECT_CALL(*connection_, SendControlFrame(_)).WillOnce(Return(false));
diff --git a/quiche/quic/core/quic_stream_test.cc b/quiche/quic/core/quic_stream_test.cc
index 380d8b6..e3d2b2b 100644
--- a/quiche/quic/core/quic_stream_test.cc
+++ b/quiche/quic/core/quic_stream_test.cc
@@ -440,10 +440,10 @@
   // Write some data and no fin.  If we consume some but not all of the data,
   // we should be write blocked a not all the data was consumed.
   EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
+      .WillOnce([this]() {
         return session_->ConsumeData(stream_->id(), 1u, 0u, NO_FIN,
                                      NOT_RETRANSMISSION, std::nullopt);
-      }));
+      });
   stream_->WriteOrBufferData(absl::string_view(kData1, 2), false, nullptr);
   EXPECT_TRUE(session_->HasUnackedStreamData());
   ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
@@ -458,10 +458,10 @@
   // (This should never actually happen as the fin should be sent out with the
   // last data)
   EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
+      .WillOnce([this]() {
         return session_->ConsumeData(stream_->id(), 2u, 0u, NO_FIN,
                                      NOT_RETRANSMISSION, std::nullopt);
-      }));
+      });
   stream_->WriteOrBufferData(absl::string_view(kData1, 2), true, nullptr);
   EXPECT_TRUE(session_->HasUnackedStreamData());
   ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
@@ -503,11 +503,10 @@
               quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0u);
   connection_->SetMaxPacketLength(length);
 
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
-        return session_->ConsumeData(stream_->id(), kDataLen - 1, 0u, NO_FIN,
-                                     NOT_RETRANSMISSION, std::nullopt);
-      }));
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).WillOnce([this]() {
+    return session_->ConsumeData(stream_->id(), kDataLen - 1, 0u, NO_FIN,
+                                 NOT_RETRANSMISSION, std::nullopt);
+  });
   stream_->WriteOrBufferData(kData1, false, nullptr);
 
   EXPECT_TRUE(session_->HasUnackedStreamData());
@@ -519,21 +518,19 @@
   EXPECT_EQ(10u, stream_->BufferedDataBytes());
   // Make sure we get the tail of the first write followed by the bytes_consumed
   InSequence s;
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
-        return session_->ConsumeData(stream_->id(), kDataLen - 1, kDataLen - 1,
-                                     NO_FIN, NOT_RETRANSMISSION, std::nullopt);
-      }));
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).WillOnce([this]() {
+    return session_->ConsumeData(stream_->id(), kDataLen - 1, kDataLen - 1,
+                                 NO_FIN, NOT_RETRANSMISSION, std::nullopt);
+  });
   EXPECT_CALL(*stream_, OnCanWriteNewData());
   stream_->OnCanWrite();
   EXPECT_TRUE(session_->HasUnackedStreamData());
 
   // And finally the end of the bytes_consumed.
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
-        return session_->ConsumeData(stream_->id(), 2u, 2 * kDataLen - 2,
-                                     NO_FIN, NOT_RETRANSMISSION, std::nullopt);
-      }));
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).WillOnce([this]() {
+    return session_->ConsumeData(stream_->id(), 2u, 2 * kDataLen - 2, NO_FIN,
+                                 NOT_RETRANSMISSION, std::nullopt);
+  });
   EXPECT_CALL(*stream_, OnCanWriteNewData());
   stream_->OnCanWrite();
   EXPECT_TRUE(session_->HasUnackedStreamData());
@@ -590,10 +587,10 @@
 
   // Write some data, with no FIN.
   EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
+      .WillOnce([this]() {
         return session_->ConsumeData(stream_->id(), 1u, 0u, NO_FIN,
                                      NOT_RETRANSMISSION, std::nullopt);
-      }));
+      });
   stream_->WriteOrBufferData(absl::string_view(kData1, 1), false, nullptr);
   EXPECT_TRUE(session_->HasUnackedStreamData());
   EXPECT_FALSE(fin_sent());
@@ -627,10 +624,10 @@
 
   // Write some data, with FIN.
   EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
+      .WillOnce([this]() {
         return session_->ConsumeData(stream_->id(), 1u, 0u, FIN,
                                      NOT_RETRANSMISSION, std::nullopt);
-      }));
+      });
   stream_->WriteOrBufferData(absl::string_view(kData1, 1), true, nullptr);
   EXPECT_TRUE(fin_sent());
   EXPECT_FALSE(rst_sent());
@@ -890,10 +887,10 @@
 
   // Outgoing data with FIN.
   EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
+      .WillOnce([this]() {
         return session_->ConsumeData(stream_->id(), 2u, 0u, FIN,
                                      NOT_RETRANSMISSION, std::nullopt);
-      }));
+      });
   stream_->WriteOrBufferData(absl::string_view(kData1, 2), true, nullptr);
   EXPECT_TRUE(stream_->write_side_closed());
 
@@ -907,10 +904,10 @@
 
   // Outgoing data with FIN.
   EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
+      .WillOnce([this]() {
         return session_->ConsumeData(stream_->id(), 2u, 0u, FIN,
                                      NOT_RETRANSMISSION, std::nullopt);
-      }));
+      });
   stream_->WriteOrBufferData(absl::string_view(kData1, 2), true, nullptr);
   EXPECT_TRUE(stream_->write_side_closed());
 
@@ -1079,12 +1076,10 @@
       .Times(AtLeast(1))
       .WillRepeatedly(&ClearControlFrameWithTransmissionType);
 
-  EXPECT_CALL(*session_, MaybeSendRstStreamFrame(_, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
-        session_->ReallyMaybeSendRstStreamFrame(
-            stream_->id(), QUIC_STREAM_CANCELLED,
-            stream_->stream_bytes_written());
-      }));
+  EXPECT_CALL(*session_, MaybeSendRstStreamFrame(_, _, _)).WillOnce([this]() {
+    session_->ReallyMaybeSendRstStreamFrame(
+        stream_->id(), QUIC_STREAM_CANCELLED, stream_->stream_bytes_written());
+  });
 
   stream_->Reset(QUIC_STREAM_CANCELLED);
   EXPECT_EQ(1u, QuicStreamPeer::SendBuffer(stream_).size());
@@ -1193,11 +1188,10 @@
   EXPECT_TRUE(stream_->CanWriteNewData());
 
   // Testing WriteOrBufferData.
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
-        return session_->ConsumeData(stream_->id(), 100u, 0u, NO_FIN,
-                                     NOT_RETRANSMISSION, std::nullopt);
-      }));
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).WillOnce([this]() {
+    return session_->ConsumeData(stream_->id(), 100u, 0u, NO_FIN,
+                                 NOT_RETRANSMISSION, std::nullopt);
+  });
   stream_->WriteOrBufferData(data, false, nullptr);
   stream_->WriteOrBufferData(data, false, nullptr);
   stream_->WriteOrBufferData(data, false, nullptr);
@@ -1206,11 +1200,10 @@
   // Verify all data is saved.
   EXPECT_EQ(3 * data.length() - 100, stream_->BufferedDataBytes());
 
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
-        return session_->ConsumeData(stream_->id(), 100, 100u, NO_FIN,
-                                     NOT_RETRANSMISSION, std::nullopt);
-      }));
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).WillOnce([this]() {
+    return session_->ConsumeData(stream_->id(), 100, 100u, NO_FIN,
+                                 NOT_RETRANSMISSION, std::nullopt);
+  });
   // Buffered data size > threshold, do not ask upper layer for more data.
   EXPECT_CALL(*stream_, OnCanWriteNewData()).Times(0);
   stream_->OnCanWrite();
@@ -1221,10 +1214,10 @@
   QuicByteCount data_to_write =
       3 * data.length() - 200 - GetQuicFlag(quic_buffered_data_threshold) + 1;
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this, data_to_write]() {
+      .WillOnce([this, data_to_write]() {
         return session_->ConsumeData(stream_->id(), data_to_write, 200u, NO_FIN,
                                      NOT_RETRANSMISSION, std::nullopt);
-      }));
+      });
   // Buffered data size < threshold, ask upper layer for more data.
   EXPECT_CALL(*stream_, OnCanWriteNewData()).Times(1);
   stream_->OnCanWrite();
@@ -1264,10 +1257,10 @@
 
   data_to_write = data.length() - GetQuicFlag(quic_buffered_data_threshold) + 1;
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this, data_to_write]() {
+      .WillOnce([this, data_to_write]() {
         return session_->ConsumeData(stream_->id(), data_to_write, 0u, NO_FIN,
                                      NOT_RETRANSMISSION, std::nullopt);
-      }));
+      });
 
   EXPECT_CALL(*stream_, OnCanWriteNewData()).Times(1);
   stream_->OnCanWrite();
@@ -1325,11 +1318,10 @@
   absl::Span<quiche::QuicheMemSlice> span1(vector1);
   absl::Span<quiche::QuicheMemSlice> span2(vector2);
 
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
-        return session_->ConsumeData(stream_->id(), 100u, 0u, NO_FIN,
-                                     NOT_RETRANSMISSION, std::nullopt);
-      }));
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).WillOnce([this]() {
+    return session_->ConsumeData(stream_->id(), 100u, 0u, NO_FIN,
+                                 NOT_RETRANSMISSION, std::nullopt);
+  });
   // There is no buffered data before, all data should be consumed.
   QuicConsumedData consumed = stream_->WriteMemSlices(span1, false);
   EXPECT_EQ(2048u, consumed.bytes_consumed);
@@ -1348,10 +1340,10 @@
   QuicByteCount data_to_write =
       2 * kDataSize - 100 - GetQuicFlag(quic_buffered_data_threshold) + 1;
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this, data_to_write]() {
+      .WillOnce([this, data_to_write]() {
         return session_->ConsumeData(stream_->id(), data_to_write, 100u, NO_FIN,
                                      NOT_RETRANSMISSION, std::nullopt);
-      }));
+      });
   EXPECT_CALL(*stream_, OnCanWriteNewData()).Times(1);
   stream_->OnCanWrite();
   EXPECT_EQ(
@@ -1380,11 +1372,10 @@
   QuicStreamPeer::SetStreamBytesWritten(kMaxStreamLength - 5u, stream_);
   std::vector<std::pair<char*, size_t>> buffers;
   quiche::QuicheMemSlice slice1 = MemSliceFromString("12345");
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
-        return session_->ConsumeData(stream_->id(), 5u, 0u, NO_FIN,
-                                     NOT_RETRANSMISSION, std::nullopt);
-      }));
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).WillOnce([this]() {
+    return session_->ConsumeData(stream_->id(), 5u, 0u, NO_FIN,
+                                 NOT_RETRANSMISSION, std::nullopt);
+  });
   // There is no buffered data before, all data should be consumed.
   QuicConsumedData consumed = stream_->WriteMemSlice(std::move(slice1), false);
   EXPECT_EQ(5u, consumed.bytes_consumed);
@@ -1520,11 +1511,10 @@
   EXPECT_TRUE(stream_->HasPendingRetransmission());
   // This OnCanWrite causes [18, 27) and fin to be retransmitted. Verify fin can
   // be bundled with data.
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
-        return session_->ConsumeData(stream_->id(), 9u, 18u, FIN,
-                                     NOT_RETRANSMISSION, std::nullopt);
-      }));
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).WillOnce([this]() {
+    return session_->ConsumeData(stream_->id(), 9u, 18u, FIN,
+                                 NOT_RETRANSMISSION, std::nullopt);
+  });
   stream_->OnCanWrite();
   EXPECT_FALSE(stream_->HasPendingRetransmission());
   // Lost [9, 18) again, but it is not considered as lost because kData2
@@ -1550,11 +1540,10 @@
   // Retransmit lost data. Verify [0, 9) and fin are retransmitted in two
   // frames.
   InSequence s;
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
-        return session_->ConsumeData(stream_->id(), 9u, 0u, NO_FIN,
-                                     NOT_RETRANSMISSION, std::nullopt);
-      }));
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).WillOnce([this]() {
+    return session_->ConsumeData(stream_->id(), 9u, 0u, NO_FIN,
+                                 NOT_RETRANSMISSION, std::nullopt);
+  });
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
       .WillOnce(Return(QuicConsumedData(0, true)));
   stream_->OnCanWrite();
@@ -1639,10 +1628,10 @@
   EXPECT_EQ(3u, newly_acked_length);
   // Retransmit [0, 18) with fin, and only [0, 8) is consumed.
   EXPECT_CALL(*session_, WritevData(stream_->id(), 10, 0, NO_FIN, _, _))
-      .WillOnce(InvokeWithoutArgs([this]() {
+      .WillOnce([this]() {
         return session_->ConsumeData(stream_->id(), 8, 0u, NO_FIN,
                                      NOT_RETRANSMISSION, std::nullopt);
-      }));
+      });
   EXPECT_FALSE(stream_->RetransmitStreamData(0, 18, true, PTO_RETRANSMISSION));
 
   // Retransmit [0, 18) with fin, and all is consumed.