diff --git a/quic/test_tools/crypto_test_utils.cc b/quic/test_tools/crypto_test_utils.cc
index 0b67287..517ad14 100644
--- a/quic/test_tools/crypto_test_utils.cc
+++ b/quic/test_tools/crypto_test_utils.cc
@@ -50,7 +50,7 @@
  public:
   CryptoFramerVisitor() : error_(false) {}
 
-  void OnError(CryptoFramer* framer) override { error_ = true; }
+  void OnError(CryptoFramer* /*framer*/) override { error_ = true; }
 
   void OnHandshakeMessage(const CryptoHandshakeMessage& message) override {
     messages_.push_back(message);
@@ -150,12 +150,12 @@
    public:
     explicit ProcessClientHelloCallback(FullChloGenerator* generator)
         : generator_(generator) {}
-    void Run(
-        QuicErrorCode error,
-        const std::string& error_details,
-        std::unique_ptr<CryptoHandshakeMessage> message,
-        std::unique_ptr<DiversificationNonce> diversification_nonce,
-        std::unique_ptr<ProofSource::Details> proof_source_details) override {
+    void Run(QuicErrorCode /*error*/,
+             const std::string& /*error_details*/,
+             std::unique_ptr<CryptoHandshakeMessage> message,
+             std::unique_ptr<DiversificationNonce> /*diversification_nonce*/,
+             std::unique_ptr<ProofSource::Details> /*proof_source_details*/)
+        override {
       generator_->ProcessClientHelloDone(std::move(message));
     }
 
@@ -303,7 +303,7 @@
 
 void SendHandshakeMessageToStream(QuicCryptoStream* stream,
                                   const CryptoHandshakeMessage& message,
-                                  Perspective perspective) {
+                                  Perspective /*perspective*/) {
   const QuicData& data = message.GetSerialized();
   QuicSession* session = QuicStreamPeer::session(stream);
   if (!QuicVersionUsesCryptoFrames(
diff --git a/quic/test_tools/crypto_test_utils_test.cc b/quic/test_tools/crypto_test_utils_test.cc
index e7f9679..2335d67 100644
--- a/quic/test_tools/crypto_test_utils_test.cc
+++ b/quic/test_tools/crypto_test_utils_test.cc
@@ -68,12 +68,12 @@
    public:
     explicit ProcessClientHelloCallback(ShloVerifier* shlo_verifier)
         : shlo_verifier_(shlo_verifier) {}
-    void Run(
-        QuicErrorCode error,
-        const std::string& error_details,
-        std::unique_ptr<CryptoHandshakeMessage> message,
-        std::unique_ptr<DiversificationNonce> diversification_nonce,
-        std::unique_ptr<ProofSource::Details> proof_source_details) override {
+    void Run(QuicErrorCode /*error*/,
+             const std::string& /*error_details*/,
+             std::unique_ptr<CryptoHandshakeMessage> message,
+             std::unique_ptr<DiversificationNonce> /*diversification_nonce*/,
+             std::unique_ptr<ProofSource::Details> /*proof_source_details*/)
+        override {
       shlo_verifier_->ProcessClientHelloDone(std::move(message));
     }
 
diff --git a/quic/test_tools/failing_proof_source.cc b/quic/test_tools/failing_proof_source.cc
index 339b793..60b6a95 100644
--- a/quic/test_tools/failing_proof_source.cc
+++ b/quic/test_tools/failing_proof_source.cc
@@ -7,26 +7,26 @@
 namespace quic {
 namespace test {
 
-void FailingProofSource::GetProof(const QuicSocketAddress& server_address,
-                                  const std::string& hostname,
-                                  const std::string& server_config,
-                                  QuicTransportVersion transport_version,
-                                  QuicStringPiece chlo_hash,
+void FailingProofSource::GetProof(const QuicSocketAddress& /*server_address*/,
+                                  const std::string& /*hostname*/,
+                                  const std::string& /*server_config*/,
+                                  QuicTransportVersion /*transport_version*/,
+                                  QuicStringPiece /*chlo_hash*/,
                                   std::unique_ptr<Callback> callback) {
   callback->Run(false, nullptr, QuicCryptoProof(), nullptr);
 }
 
 QuicReferenceCountedPointer<ProofSource::Chain>
-FailingProofSource::GetCertChain(const QuicSocketAddress& server_address,
-                                 const std::string& hostname) {
+FailingProofSource::GetCertChain(const QuicSocketAddress& /*server_address*/,
+                                 const std::string& /*hostname*/) {
   return QuicReferenceCountedPointer<Chain>();
 }
 
 void FailingProofSource::ComputeTlsSignature(
-    const QuicSocketAddress& server_address,
-    const std::string& hostname,
-    uint16_t signature_algorithm,
-    QuicStringPiece in,
+    const QuicSocketAddress& /*server_address*/,
+    const std::string& /*hostname*/,
+    uint16_t /*signature_algorithm*/,
+    QuicStringPiece /*in*/,
     std::unique_ptr<SignatureCallback> callback) {
   callback->Run(false, "");
 }
diff --git a/quic/test_tools/packet_dropping_test_writer.h b/quic/test_tools/packet_dropping_test_writer.h
index eb4ad1c..92c8956 100644
--- a/quic/test_tools/packet_dropping_test_writer.h
+++ b/quic/test_tools/packet_dropping_test_writer.h
@@ -54,8 +54,9 @@
 
   void SetWritable() override;
 
-  char* GetNextWriteLocation(const QuicIpAddress& self_address,
-                             const QuicSocketAddress& peer_address) override {
+  char* GetNextWriteLocation(
+      const QuicIpAddress& /*self_address*/,
+      const QuicSocketAddress& /*peer_address*/) override {
     // If the wrapped writer supports zero-copy, disable it, because it is not
     // compatible with delayed writes in this class.
     return nullptr;
diff --git a/quic/test_tools/quic_test_client.cc b/quic/test_tools/quic_test_client.cc
index caeaa51..e2e33c7 100644
--- a/quic/test_tools/quic_test_client.cc
+++ b/quic/test_tools/quic_test_client.cc
@@ -90,14 +90,14 @@
   }
 
   QuicAsyncStatus VerifyCertChain(
-      const std::string& hostname,
-      const std::vector<std::string>& certs,
-      const std::string& ocsp_response,
-      const std::string& cert_sct,
-      const ProofVerifyContext* context,
-      std::string* error_details,
-      std::unique_ptr<ProofVerifyDetails>* details,
-      std::unique_ptr<ProofVerifierCallback> callback) override {
+      const std::string& /*hostname*/,
+      const std::vector<std::string>& /*certs*/,
+      const std::string& /*ocsp_response*/,
+      const std::string& /*cert_sct*/,
+      const ProofVerifyContext* /*context*/,
+      std::string* /*error_details*/,
+      std::unique_ptr<ProofVerifyDetails>* /*details*/,
+      std::unique_ptr<ProofVerifierCallback> /*callback*/) override {
     return QUIC_SUCCESS;
   }
 
@@ -742,9 +742,10 @@
   open_streams_.erase(id);
 }
 
-bool QuicTestClient::CheckVary(const spdy::SpdyHeaderBlock& client_request,
-                               const spdy::SpdyHeaderBlock& promise_request,
-                               const spdy::SpdyHeaderBlock& promise_response) {
+bool QuicTestClient::CheckVary(
+    const spdy::SpdyHeaderBlock& /*client_request*/,
+    const spdy::SpdyHeaderBlock& /*promise_request*/,
+    const spdy::SpdyHeaderBlock& /*promise_response*/) {
   return true;
 }
 
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index dbfca44..4ff4554 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -232,130 +232,135 @@
 
 MockFramerVisitor::~MockFramerVisitor() {}
 
-bool NoOpFramerVisitor::OnProtocolVersionMismatch(ParsedQuicVersion version,
-                                                  PacketHeaderFormat form) {
+bool NoOpFramerVisitor::OnProtocolVersionMismatch(ParsedQuicVersion /*version*/,
+                                                  PacketHeaderFormat /*form*/) {
   return false;
 }
 
 bool NoOpFramerVisitor::OnUnauthenticatedPublicHeader(
-    const QuicPacketHeader& header) {
+    const QuicPacketHeader& /*header*/) {
   return true;
 }
 
 bool NoOpFramerVisitor::OnUnauthenticatedHeader(
-    const QuicPacketHeader& header) {
+    const QuicPacketHeader& /*header*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::OnPacketHeader(const QuicPacketHeader& header) {
+bool NoOpFramerVisitor::OnPacketHeader(const QuicPacketHeader& /*header*/) {
   return true;
 }
 
-void NoOpFramerVisitor::OnCoalescedPacket(const QuicEncryptedPacket& packet) {}
+void NoOpFramerVisitor::OnCoalescedPacket(
+    const QuicEncryptedPacket& /*packet*/) {}
 
-bool NoOpFramerVisitor::OnStreamFrame(const QuicStreamFrame& frame) {
+bool NoOpFramerVisitor::OnStreamFrame(const QuicStreamFrame& /*frame*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::OnCryptoFrame(const QuicCryptoFrame& frame) {
+bool NoOpFramerVisitor::OnCryptoFrame(const QuicCryptoFrame& /*frame*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::OnAckFrameStart(QuicPacketNumber largest_acked,
-                                        QuicTime::Delta ack_delay_time) {
+bool NoOpFramerVisitor::OnAckFrameStart(QuicPacketNumber /*largest_acked*/,
+                                        QuicTime::Delta /*ack_delay_time*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::OnAckRange(QuicPacketNumber start,
-                                   QuicPacketNumber end) {
+bool NoOpFramerVisitor::OnAckRange(QuicPacketNumber /*start*/,
+                                   QuicPacketNumber /*end*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::OnAckTimestamp(QuicPacketNumber packet_number,
-                                       QuicTime timestamp) {
+bool NoOpFramerVisitor::OnAckTimestamp(QuicPacketNumber /*packet_number*/,
+                                       QuicTime /*timestamp*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::OnAckFrameEnd(QuicPacketNumber start) {
+bool NoOpFramerVisitor::OnAckFrameEnd(QuicPacketNumber /*start*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::OnStopWaitingFrame(const QuicStopWaitingFrame& frame) {
+bool NoOpFramerVisitor::OnStopWaitingFrame(
+    const QuicStopWaitingFrame& /*frame*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::OnPaddingFrame(const QuicPaddingFrame& frame) {
+bool NoOpFramerVisitor::OnPaddingFrame(const QuicPaddingFrame& /*frame*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::OnPingFrame(const QuicPingFrame& frame) {
+bool NoOpFramerVisitor::OnPingFrame(const QuicPingFrame& /*frame*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
+bool NoOpFramerVisitor::OnRstStreamFrame(const QuicRstStreamFrame& /*frame*/) {
   return true;
 }
 
 bool NoOpFramerVisitor::OnConnectionCloseFrame(
-    const QuicConnectionCloseFrame& frame) {
+    const QuicConnectionCloseFrame& /*frame*/) {
   return true;
 }
 
 bool NoOpFramerVisitor::OnNewConnectionIdFrame(
-    const QuicNewConnectionIdFrame& frame) {
+    const QuicNewConnectionIdFrame& /*frame*/) {
   return true;
 }
 
 bool NoOpFramerVisitor::OnRetireConnectionIdFrame(
-    const QuicRetireConnectionIdFrame& frame) {
+    const QuicRetireConnectionIdFrame& /*frame*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::OnNewTokenFrame(const QuicNewTokenFrame& frame) {
+bool NoOpFramerVisitor::OnNewTokenFrame(const QuicNewTokenFrame& /*frame*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::OnStopSendingFrame(const QuicStopSendingFrame& frame) {
+bool NoOpFramerVisitor::OnStopSendingFrame(
+    const QuicStopSendingFrame& /*frame*/) {
   return true;
 }
 
 bool NoOpFramerVisitor::OnPathChallengeFrame(
-    const QuicPathChallengeFrame& frame) {
+    const QuicPathChallengeFrame& /*frame*/) {
   return true;
 }
 
 bool NoOpFramerVisitor::OnPathResponseFrame(
-    const QuicPathResponseFrame& frame) {
+    const QuicPathResponseFrame& /*frame*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
+bool NoOpFramerVisitor::OnGoAwayFrame(const QuicGoAwayFrame& /*frame*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame) {
+bool NoOpFramerVisitor::OnMaxStreamsFrame(
+    const QuicMaxStreamsFrame& /*frame*/) {
   return true;
 }
 
 bool NoOpFramerVisitor::OnStreamsBlockedFrame(
-    const QuicStreamsBlockedFrame& frame) {
+    const QuicStreamsBlockedFrame& /*frame*/) {
   return true;
 }
 
 bool NoOpFramerVisitor::OnWindowUpdateFrame(
-    const QuicWindowUpdateFrame& frame) {
+    const QuicWindowUpdateFrame& /*frame*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::OnBlockedFrame(const QuicBlockedFrame& frame) {
+bool NoOpFramerVisitor::OnBlockedFrame(const QuicBlockedFrame& /*frame*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::OnMessageFrame(const QuicMessageFrame& frame) {
+bool NoOpFramerVisitor::OnMessageFrame(const QuicMessageFrame& /*frame*/) {
   return true;
 }
 
-bool NoOpFramerVisitor::IsValidStatelessResetToken(QuicUint128 token) const {
+bool NoOpFramerVisitor::IsValidStatelessResetToken(
+    QuicUint128 /*token*/) const {
   return false;
 }
 
@@ -473,8 +478,9 @@
   static_cast<MockQuicConnectionHelper*>(helper())->AdvanceTime(delta);
 }
 
-bool MockQuicConnection::OnProtocolVersionMismatch(ParsedQuicVersion version,
-                                                   PacketHeaderFormat form) {
+bool MockQuicConnection::OnProtocolVersionMismatch(
+    ParsedQuicVersion /*version*/,
+    PacketHeaderFormat /*form*/) {
   return false;
 }
 
@@ -676,7 +682,7 @@
 
 TestQuicSpdyClientSession::~TestQuicSpdyClientSession() {}
 
-bool TestQuicSpdyClientSession::IsAuthorized(const std::string& authority) {
+bool TestQuicSpdyClientSession::IsAuthorized(const std::string& /*authority*/) {
   return true;
 }
 
@@ -698,9 +704,9 @@
     : match_(match), rendezvous_fired_(false), rendezvous_stream_(nullptr) {}
 
 bool TestPushPromiseDelegate::CheckVary(
-    const spdy::SpdyHeaderBlock& client_request,
-    const spdy::SpdyHeaderBlock& promise_request,
-    const spdy::SpdyHeaderBlock& promise_response) {
+    const spdy::SpdyHeaderBlock& /*client_request*/,
+    const spdy::SpdyHeaderBlock& /*promise_request*/,
+    const spdy::SpdyHeaderBlock& /*promise_response*/) {
   QUIC_DVLOG(1) << "match " << match_;
   return match_;
 }
@@ -1116,7 +1122,7 @@
 }
 
 void CreateServerSessionForTest(
-    QuicServerId server_id,
+    QuicServerId /*server_id*/,
     QuicTime::Delta connection_start_time,
     ParsedQuicVersionVector supported_versions,
     MockQuicConnectionHelper* helper,
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 82bdd20..5d168cc 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -298,19 +298,19 @@
   NoOpFramerVisitor(const NoOpFramerVisitor&) = delete;
   NoOpFramerVisitor& operator=(const NoOpFramerVisitor&) = delete;
 
-  void OnError(QuicFramer* framer) override {}
+  void OnError(QuicFramer* /*framer*/) override {}
   void OnPacket() override {}
-  void OnPublicResetPacket(const QuicPublicResetPacket& packet) override {}
+  void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) override {}
   void OnVersionNegotiationPacket(
-      const QuicVersionNegotiationPacket& packet) override {}
-  void OnRetryPacket(QuicConnectionId original_connection_id,
-                     QuicConnectionId new_connection_id,
-                     QuicStringPiece retry_token) override {}
+      const QuicVersionNegotiationPacket& /*packet*/) override {}
+  void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
+                     QuicConnectionId /*new_connection_id*/,
+                     QuicStringPiece /*retry_token*/) override {}
   bool OnProtocolVersionMismatch(ParsedQuicVersion version,
                                  PacketHeaderFormat form) override;
   bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override;
   bool OnUnauthenticatedPublicHeader(const QuicPacketHeader& header) override;
-  void OnDecryptedPacket(EncryptionLevel level) override {}
+  void OnDecryptedPacket(EncryptionLevel /*level*/) override {}
   bool OnPacketHeader(const QuicPacketHeader& header) override;
   void OnCoalescedPacket(const QuicEncryptedPacket& packet) override;
   bool OnStreamFrame(const QuicStreamFrame& frame) override;
@@ -342,7 +342,7 @@
   void OnPacketComplete() override {}
   bool IsValidStatelessResetToken(QuicUint128 token) const override;
   void OnAuthenticatedIetfStatelessResetPacket(
-      const QuicIetfStatelessResetPacket& packet) override {}
+      const QuicIetfStatelessResetPacket& /*packet*/) override {}
 };
 
 class MockQuicConnectionVisitor : public QuicConnectionVisitorInterface {
diff --git a/quic/test_tools/simple_quic_framer.cc b/quic/test_tools/simple_quic_framer.cc
index 06a6718..07988cc 100644
--- a/quic/test_tools/simple_quic_framer.cc
+++ b/quic/test_tools/simple_quic_framer.cc
@@ -24,8 +24,8 @@
 
   void OnError(QuicFramer* framer) override { error_ = framer->error(); }
 
-  bool OnProtocolVersionMismatch(ParsedQuicVersion version,
-                                 PacketHeaderFormat form) override {
+  bool OnProtocolVersionMismatch(ParsedQuicVersion /*version*/,
+                                 PacketHeaderFormat /*form*/) override {
     return false;
   }
 
@@ -39,14 +39,15 @@
         QuicMakeUnique<QuicVersionNegotiationPacket>((packet));
   }
 
-  void OnRetryPacket(QuicConnectionId original_connection_id,
-                     QuicConnectionId new_connection_id,
-                     QuicStringPiece retry_token) override {}
+  void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
+                     QuicConnectionId /*new_connection_id*/,
+                     QuicStringPiece /*retry_token*/) override {}
 
-  bool OnUnauthenticatedPublicHeader(const QuicPacketHeader& header) override {
+  bool OnUnauthenticatedPublicHeader(
+      const QuicPacketHeader& /*header*/) override {
     return true;
   }
-  bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override {
+  bool OnUnauthenticatedHeader(const QuicPacketHeader& /*header*/) override {
     return true;
   }
   void OnDecryptedPacket(EncryptionLevel level) override {
@@ -58,7 +59,7 @@
     return true;
   }
 
-  void OnCoalescedPacket(const QuicEncryptedPacket& packet) override {}
+  void OnCoalescedPacket(const QuicEncryptedPacket& /*packet*/) override {}
 
   bool OnStreamFrame(const QuicStreamFrame& frame) override {
     // Save a copy of the data so it is valid after the packet is processed.
@@ -97,8 +98,8 @@
     return true;
   }
 
-  bool OnAckTimestamp(QuicPacketNumber packet_number,
-                      QuicTime timestamp) override {
+  bool OnAckTimestamp(QuicPacketNumber /*packet_number*/,
+                      QuicTime /*timestamp*/) override {
     return true;
   }
 
@@ -191,7 +192,7 @@
 
   void OnPacketComplete() override {}
 
-  bool IsValidStatelessResetToken(QuicUint128 token) const override {
+  bool IsValidStatelessResetToken(QuicUint128 /*token*/) const override {
     return false;
   }
 
diff --git a/quic/test_tools/simple_session_notifier.h b/quic/test_tools/simple_session_notifier.h
index aab3769..7424053 100644
--- a/quic/test_tools/simple_session_notifier.h
+++ b/quic/test_tools/simple_session_notifier.h
@@ -67,7 +67,7 @@
   bool OnFrameAcked(const QuicFrame& frame,
                     QuicTime::Delta ack_delay_time,
                     QuicTime receive_timestamp) override;
-  void OnStreamFrameRetransmitted(const QuicStreamFrame& frame) override {}
+  void OnStreamFrameRetransmitted(const QuicStreamFrame& /*frame*/) override {}
   void OnFrameLost(const QuicFrame& frame) override;
   void RetransmitFrames(const QuicFrames& frames,
                         TransmissionType type) override;
diff --git a/quic/test_tools/simulator/quic_endpoint.cc b/quic/test_tools/simulator/quic_endpoint.cc
index ed9d5c0..28df15f 100644
--- a/quic/test_tools/simulator/quic_endpoint.cc
+++ b/quic/test_tools/simulator/quic_endpoint.cc
@@ -229,7 +229,7 @@
   DCHECK_LE(offsets_received_.Size(), 1000u);
 }
 
-void QuicEndpoint::OnCryptoFrame(const QuicCryptoFrame& frame) {}
+void QuicEndpoint::OnCryptoFrame(const QuicCryptoFrame& /*frame*/) {}
 
 void QuicEndpoint::OnCanWrite() {
   if (notifier_ != nullptr) {
@@ -308,8 +308,8 @@
 WriteResult QuicEndpoint::Writer::WritePacket(
     const char* buffer,
     size_t buf_len,
-    const QuicIpAddress& self_address,
-    const QuicSocketAddress& peer_address,
+    const QuicIpAddress& /*self_address*/,
+    const QuicSocketAddress& /*peer_address*/,
     PerPacketOptions* options) {
   DCHECK(!IsWriteBlocked());
   DCHECK(options == nullptr);
@@ -358,8 +358,8 @@
 }
 
 char* QuicEndpoint::Writer::GetNextWriteLocation(
-    const QuicIpAddress& self_address,
-    const QuicSocketAddress& peer_address) {
+    const QuicIpAddress& /*self_address*/,
+    const QuicSocketAddress& /*peer_address*/) {
   return nullptr;
 }
 
@@ -368,18 +368,18 @@
 }
 
 WriteStreamDataResult QuicEndpoint::DataProducer::WriteStreamData(
-    QuicStreamId id,
-    QuicStreamOffset offset,
+    QuicStreamId /*id*/,
+    QuicStreamOffset /*offset*/,
     QuicByteCount data_length,
     QuicDataWriter* writer) {
   writer->WriteRepeatedByte(kStreamDataContents, data_length);
   return WRITE_SUCCESS;
 }
 
-bool QuicEndpoint::DataProducer::WriteCryptoData(EncryptionLevel leve,
-                                                 QuicStreamOffset offset,
-                                                 QuicByteCount data_length,
-                                                 QuicDataWriter* writer) {
+bool QuicEndpoint::DataProducer::WriteCryptoData(EncryptionLevel /*level*/,
+                                                 QuicStreamOffset /*offset*/,
+                                                 QuicByteCount /*data_length*/,
+                                                 QuicDataWriter* /*writer*/) {
   QUIC_BUG << "QuicEndpoint::DataProducer::WriteCryptoData is unimplemented";
   return false;
 }
diff --git a/quic/test_tools/simulator/quic_endpoint.h b/quic/test_tools/simulator/quic_endpoint.h
index c547551..62f19a1 100644
--- a/quic/test_tools/simulator/quic_endpoint.h
+++ b/quic/test_tools/simulator/quic_endpoint.h
@@ -87,34 +87,35 @@
   bool HasPendingHandshake() const override;
   bool ShouldKeepConnectionAlive() const override;
 
-  void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override {}
-  void OnBlockedFrame(const QuicBlockedFrame& frame) override {}
-  void OnRstStream(const QuicRstStreamFrame& frame) override {}
-  void OnGoAway(const QuicGoAwayFrame& frame) override {}
-  void OnMessageReceived(QuicStringPiece message) override {}
-  void OnConnectionClosed(QuicErrorCode error,
-                          const std::string& error_details,
-                          ConnectionCloseSource source) override {}
+  void OnWindowUpdateFrame(const QuicWindowUpdateFrame& /*frame*/) override {}
+  void OnBlockedFrame(const QuicBlockedFrame& /*frame*/) override {}
+  void OnRstStream(const QuicRstStreamFrame& /*frame*/) override {}
+  void OnGoAway(const QuicGoAwayFrame& /*frame*/) override {}
+  void OnMessageReceived(QuicStringPiece /*message*/) override {}
+  void OnConnectionClosed(QuicErrorCode /*error*/,
+                          const std::string& /*error_details*/,
+                          ConnectionCloseSource /*source*/) override {}
   void OnWriteBlocked() override {}
   void OnSuccessfulVersionNegotiation(
-      const ParsedQuicVersion& version) override {}
+      const ParsedQuicVersion& /*version*/) override {}
   void OnConnectivityProbeReceived(
-      const QuicSocketAddress& self_address,
-      const QuicSocketAddress& peer_address) override {}
-  void OnCongestionWindowChange(QuicTime now) override {}
-  void OnConnectionMigration(AddressChangeType type) override {}
+      const QuicSocketAddress& /*self_address*/,
+      const QuicSocketAddress& /*peer_address*/) override {}
+  void OnCongestionWindowChange(QuicTime /*now*/) override {}
+  void OnConnectionMigration(AddressChangeType /*type*/) override {}
   void OnPathDegrading() override {}
   void OnAckNeedsRetransmittableFrame() override {}
   void SendPing() override {}
   bool AllowSelfAddressChange() const override;
   void OnForwardProgressConfirmed() override {}
-  bool OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame) override {
+  bool OnMaxStreamsFrame(const QuicMaxStreamsFrame& /*frame*/) override {
     return true;
   }
-  bool OnStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame) override {
+  bool OnStreamsBlockedFrame(
+      const QuicStreamsBlockedFrame& /*frame*/) override {
     return true;
   }
-  bool OnStopSendingFrame(const QuicStopSendingFrame& frame) override {
+  bool OnStopSendingFrame(const QuicStopSendingFrame& /*frame*/) override {
     return true;
   }
 
@@ -124,7 +125,7 @@
   bool OnFrameAcked(const QuicFrame& frame,
                     QuicTime::Delta ack_delay_time,
                     QuicTime receive_timestamp) override;
-  void OnStreamFrameRetransmitted(const QuicStreamFrame& frame) override {}
+  void OnStreamFrameRetransmitted(const QuicStreamFrame& /*frame*/) override {}
   void OnFrameLost(const QuicFrame& frame) override;
   void RetransmitFrames(const QuicFrames& frames,
                         TransmissionType type) override;