diff --git a/quic/core/chlo_extractor.cc b/quic/core/chlo_extractor.cc
index ec3a899..201c6df 100644
--- a/quic/core/chlo_extractor.cc
+++ b/quic/core/chlo_extractor.cc
@@ -30,19 +30,19 @@
   ~ChloFramerVisitor() override = default;
 
   // QuicFramerVisitorInterface implementation
-  void OnError(QuicFramer* framer) override {}
+  void OnError(QuicFramer* /*framer*/) override {}
   bool OnProtocolVersionMismatch(ParsedQuicVersion version,
                                  PacketHeaderFormat form) 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 OnUnauthenticatedPublicHeader(const QuicPacketHeader& header) override;
   bool OnUnauthenticatedHeader(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;
@@ -74,7 +74,7 @@
   void OnPacketComplete() override {}
   bool IsValidStatelessResetToken(QuicUint128 token) const override;
   void OnAuthenticatedIetfStatelessResetPacket(
-      const QuicIetfStatelessResetPacket& packet) override {}
+      const QuicIetfStatelessResetPacket& /*packet*/) override {}
 
   // CryptoFramerVisitorInterface implementation.
   void OnError(CryptoFramer* framer) override;
@@ -138,13 +138,14 @@
   return true;
 }
 bool ChloFramerVisitor::OnUnauthenticatedHeader(
-    const QuicPacketHeader& header) {
+    const QuicPacketHeader& /*header*/) {
   return true;
 }
-bool ChloFramerVisitor::OnPacketHeader(const QuicPacketHeader& header) {
+bool ChloFramerVisitor::OnPacketHeader(const QuicPacketHeader& /*header*/) {
   return true;
 }
-void ChloFramerVisitor::OnCoalescedPacket(const QuicEncryptedPacket& packet) {}
+void ChloFramerVisitor::OnCoalescedPacket(
+    const QuicEncryptedPacket& /*packet*/) {}
 bool ChloFramerVisitor::OnStreamFrame(const QuicStreamFrame& frame) {
   if (QuicVersionUsesCryptoFrames(framer_->transport_version())) {
     // CHLO will be sent in CRYPTO frames in v47 and above.
@@ -215,86 +216,90 @@
   return true;
 }
 
-bool ChloFramerVisitor::OnStopWaitingFrame(const QuicStopWaitingFrame& frame) {
+bool ChloFramerVisitor::OnStopWaitingFrame(
+    const QuicStopWaitingFrame& /*frame*/) {
   return true;
 }
 
-bool ChloFramerVisitor::OnPingFrame(const QuicPingFrame& frame) {
+bool ChloFramerVisitor::OnPingFrame(const QuicPingFrame& /*frame*/) {
   return true;
 }
 
-bool ChloFramerVisitor::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
+bool ChloFramerVisitor::OnRstStreamFrame(const QuicRstStreamFrame& /*frame*/) {
   return true;
 }
 
 bool ChloFramerVisitor::OnConnectionCloseFrame(
-    const QuicConnectionCloseFrame& frame) {
+    const QuicConnectionCloseFrame& /*frame*/) {
   return true;
 }
 
-bool ChloFramerVisitor::OnStopSendingFrame(const QuicStopSendingFrame& frame) {
+bool ChloFramerVisitor::OnStopSendingFrame(
+    const QuicStopSendingFrame& /*frame*/) {
   return true;
 }
 
 bool ChloFramerVisitor::OnPathChallengeFrame(
-    const QuicPathChallengeFrame& frame) {
+    const QuicPathChallengeFrame& /*frame*/) {
   return true;
 }
 
 bool ChloFramerVisitor::OnPathResponseFrame(
-    const QuicPathResponseFrame& frame) {
+    const QuicPathResponseFrame& /*frame*/) {
   return true;
 }
 
-bool ChloFramerVisitor::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
+bool ChloFramerVisitor::OnGoAwayFrame(const QuicGoAwayFrame& /*frame*/) {
   return true;
 }
 
 bool ChloFramerVisitor::OnWindowUpdateFrame(
-    const QuicWindowUpdateFrame& frame) {
+    const QuicWindowUpdateFrame& /*frame*/) {
   return true;
 }
 
-bool ChloFramerVisitor::OnBlockedFrame(const QuicBlockedFrame& frame) {
+bool ChloFramerVisitor::OnBlockedFrame(const QuicBlockedFrame& /*frame*/) {
   return true;
 }
 
 bool ChloFramerVisitor::OnNewConnectionIdFrame(
-    const QuicNewConnectionIdFrame& frame) {
+    const QuicNewConnectionIdFrame& /*frame*/) {
   return true;
 }
 
 bool ChloFramerVisitor::OnRetireConnectionIdFrame(
-    const QuicRetireConnectionIdFrame& frame) {
+    const QuicRetireConnectionIdFrame& /*frame*/) {
   return true;
 }
 
-bool ChloFramerVisitor::OnNewTokenFrame(const QuicNewTokenFrame& frame) {
+bool ChloFramerVisitor::OnNewTokenFrame(const QuicNewTokenFrame& /*frame*/) {
   return true;
 }
 
-bool ChloFramerVisitor::OnPaddingFrame(const QuicPaddingFrame& frame) {
+bool ChloFramerVisitor::OnPaddingFrame(const QuicPaddingFrame& /*frame*/) {
   return true;
 }
 
-bool ChloFramerVisitor::OnMessageFrame(const QuicMessageFrame& frame) {
+bool ChloFramerVisitor::OnMessageFrame(const QuicMessageFrame& /*frame*/) {
   return true;
 }
 
-bool ChloFramerVisitor::IsValidStatelessResetToken(QuicUint128 token) const {
+bool ChloFramerVisitor::IsValidStatelessResetToken(
+    QuicUint128 /*token*/) const {
   return false;
 }
 
-bool ChloFramerVisitor::OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame) {
+bool ChloFramerVisitor::OnMaxStreamsFrame(
+    const QuicMaxStreamsFrame& /*frame*/) {
   return true;
 }
 
 bool ChloFramerVisitor::OnStreamsBlockedFrame(
-    const QuicStreamsBlockedFrame& frame) {
+    const QuicStreamsBlockedFrame& /*frame*/) {
   return true;
 }
 
-void ChloFramerVisitor::OnError(CryptoFramer* framer) {}
+void ChloFramerVisitor::OnError(CryptoFramer* /*framer*/) {}
 
 void ChloFramerVisitor::OnHandshakeMessage(
     const CryptoHandshakeMessage& message) {
diff --git a/quic/core/congestion_control/bbr_sender.cc b/quic/core/congestion_control/bbr_sender.cc
index 858e57d..ef06cbf 100644
--- a/quic/core/congestion_control/bbr_sender.cc
+++ b/quic/core/congestion_control/bbr_sender.cc
@@ -187,7 +187,7 @@
   return bytes_in_flight < GetCongestionWindow();
 }
 
-QuicBandwidth BbrSender::PacingRate(QuicByteCount bytes_in_flight) const {
+QuicBandwidth BbrSender::PacingRate(QuicByteCount /*bytes_in_flight*/) const {
   if (pacing_rate_.IsZero()) {
     return high_gain_ * QuicBandwidth::FromBytesAndTimeDelta(
                             initial_congestion_window_, GetMinRtt());
diff --git a/quic/core/congestion_control/bbr_sender.h b/quic/core/congestion_control/bbr_sender.h
index b559134..5534144 100644
--- a/quic/core/congestion_control/bbr_sender.h
+++ b/quic/core/congestion_control/bbr_sender.h
@@ -110,7 +110,7 @@
   void AdjustNetworkParameters(QuicBandwidth bandwidth,
                                QuicTime::Delta rtt,
                                bool allow_cwnd_to_decrease) override;
-  void SetNumEmulatedConnections(int num_connections) override {}
+  void SetNumEmulatedConnections(int /*num_connections*/) override {}
   void SetInitialCongestionWindowInPackets(
       QuicPacketCount congestion_window) override;
   void OnCongestionEvent(bool rtt_updated,
@@ -123,7 +123,7 @@
                     QuicPacketNumber packet_number,
                     QuicByteCount bytes,
                     HasRetransmittableData is_retransmittable) override;
-  void OnRetransmissionTimeout(bool packets_retransmitted) override {}
+  void OnRetransmissionTimeout(bool /*packets_retransmitted*/) override {}
   void OnConnectionMigration() override {}
   bool CanSend(QuicByteCount bytes_in_flight) override;
   QuicBandwidth PacingRate(QuicByteCount bytes_in_flight) const override;
diff --git a/quic/core/congestion_control/rtt_stats.cc b/quic/core/congestion_control/rtt_stats.cc
index 40b4bcc..06bc60b 100644
--- a/quic/core/congestion_control/rtt_stats.cc
+++ b/quic/core/congestion_control/rtt_stats.cc
@@ -41,7 +41,7 @@
 // Updates the RTT based on a new sample.
 void RttStats::UpdateRtt(QuicTime::Delta send_delta,
                          QuicTime::Delta ack_delay,
-                         QuicTime now) {
+                         QuicTime /*now*/) {
   if (send_delta.IsInfinite() || send_delta <= QuicTime::Delta::Zero()) {
     QUIC_LOG_FIRST_N(WARNING, 3)
         << "Ignoring measured send_delta, because it's is "
diff --git a/quic/core/congestion_control/tcp_cubic_sender_bytes.cc b/quic/core/congestion_control/tcp_cubic_sender_bytes.cc
index 7cbf332..28f284e 100644
--- a/quic/core/congestion_control/tcp_cubic_sender_bytes.cc
+++ b/quic/core/congestion_control/tcp_cubic_sender_bytes.cc
@@ -261,7 +261,8 @@
   return "";
 }
 
-void TcpCubicSenderBytes::OnApplicationLimited(QuicByteCount bytes_in_flight) {}
+void TcpCubicSenderBytes::OnApplicationLimited(
+    QuicByteCount /*bytes_in_flight*/) {}
 
 void TcpCubicSenderBytes::SetCongestionWindowFromBandwidthAndRtt(
     QuicBandwidth bandwidth,
@@ -360,7 +361,7 @@
 // Called when we receive an ack. Normal TCP tracks how many packets one ack
 // represents, but quic has a separate ack for each packet.
 void TcpCubicSenderBytes::MaybeIncreaseCwnd(
-    QuicPacketNumber acked_packet_number,
+    QuicPacketNumber /*acked_packet_number*/,
     QuicByteCount acked_bytes,
     QuicByteCount prior_in_flight,
     QuicTime event_time) {
diff --git a/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc b/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc
index 32451a5..2d27896 100644
--- a/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc
+++ b/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc
@@ -64,7 +64,7 @@
     return SendAvailableSendWindow(kDefaultTCPMSS);
   }
 
-  int SendAvailableSendWindow(QuicPacketLength packet_length) {
+  int SendAvailableSendWindow(QuicPacketLength /*packet_length*/) {
     // Send as long as TimeUntilSend returns Zero.
     int packets_sent = 0;
     bool can_send = sender_->CanSend(bytes_in_flight_);
diff --git a/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc b/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc
index fefd09f..dd8a680 100644
--- a/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc
+++ b/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc
@@ -86,7 +86,7 @@
         "a2be08210d8c470a8df6e8fbd79ec5cf",
         nullptr  // FAIL
     },
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_1[] = {
     {
@@ -97,7 +97,7 @@
     {"2370e320d4344208e0ff5683f243b213", "04dbb82f044d30831c441228", "",
      "d43a8e5089eea0d026c03a85178b27da", "2a049c049d25aa95969b451d93c31c6e",
      ""},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_2[] = {
     {"e98b72a9881a84ca6b76e0f43e68647a", "8b23299fde174053f3d652ba",
@@ -112,7 +112,7 @@
         "a145319896329c96df291f64efbe0e3a",
         nullptr  // FAIL
     },
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_3[] = {
     {"af57f42c60c0fc5a09adb81ab86ca1c3", "a2dc01871f37025dc0fc9a79",
@@ -137,7 +137,7 @@
         "8ca4e38aa3dfa6b1d0297021ccf3ea5f",
         nullptr  // FAIL
     },
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_4[] = {
     {"da2bb7d581493d692380c77105590201", "44aa3e7856ca279d2eb020c6",
@@ -168,7 +168,7 @@
         "8b347853f11d75e81e8a95010be81f17",
         nullptr  // FAIL
     },
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_5[] = {
     {"387218b246c1a8257748b56980e50c94", "dd7e014198672be39f95b69d",
@@ -185,7 +185,7 @@
         "a85b66c3cb5eab91d5bdc8bc0e", "", "dc054efc01f3afd21d9c2484819f569a",
         nullptr  // FAIL
     },
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector* const test_group_array[] = {
     test_group_0, test_group_1, test_group_2,
diff --git a/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc b/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc
index 578c3be..5ccc44d 100644
--- a/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc
+++ b/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc
@@ -78,7 +78,7 @@
      "250327c674aaf477aef2675748cf6971"},
     {"ca47248ac0b6f8372a97ac43508308ed", "ffd2b598feabc9019262d2be", "", "", "",
      "60d20404af527d248d893ae495707d1a"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_1[] = {
     {"77be63708971c4e240d1cb79e8d77feb", "e0e00f19fed7ba0136a797f3", "",
@@ -87,7 +87,7 @@
     {"7680c5d3ca6154758e510f4d25b98820", "f8f105f9c3df4965780321f8", "",
      "c94c410194c765e3dcc7964379758ed3", "",
      "94dca8edfcf90bb74b153c8d48a17930"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_2[] = {
     {"7fddb57453c241d03efbed3ac44e371c", "ee283a3fc75575e33efd4887",
@@ -96,7 +96,7 @@
     {"ab72c77b97cb5fe9a382d9fe81ffdbed", "54cc7dc2c37ec006bcc6d1da",
      "007c5e5b3e59df24a7c355584fc1518d", "", "0e1bde206a07a9c2c1b65300f8c64997",
      "2b4401346697138c7a4891ee59867d0c"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_3[] = {
     {"fe47fcce5fc32665d2ae399e4eec72ba", "5adb9609dbaeb58cbd6e7275",
@@ -113,7 +113,7 @@
      "a7443d31c26bdf2a1c945e29ee4bd344a99cfaf3aa71f8b3f191f83c2adfc7a0716299"
      "5506fde6309ffc19e716eddf1a828c5a",
      "890147971946b627c40016da1ecf3e77"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_4[] = {
     {"2c1f21cf0f6fb3661943155c3e3d8492", "23cb5ff362e22426984d1907",
@@ -134,7 +134,7 @@
      "aaadbd5c92e9151ce3db7210b8714126b73e43436d242677afa50384f2149b831f1d57"
      "3c7891c2a91fbc48db29967ec9542b23",
      "21b51ca862cb637cdd03b99a0f93b134"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_5[] = {
     {"fe9bb47deb3a61e423c2231841cfd1fb", "4d328eb776f500a2f7fb47aa",
@@ -143,7 +143,7 @@
     {"6703df3701a7f54911ca72e24dca046a", "12823ab601c350ea4bc2488c",
      "793cd125b0b84a043e3ac67717", "", "b2051c80014f42f08735a7b0cd",
      "38e6bcd29962e5f2c13626b85a877101"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector* const test_group_array[] = {
     test_group_0, test_group_1, test_group_2,
diff --git a/quic/core/crypto/aes_128_gcm_decrypter_test.cc b/quic/core/crypto/aes_128_gcm_decrypter_test.cc
index 13c6827..54793f8 100644
--- a/quic/core/crypto/aes_128_gcm_decrypter_test.cc
+++ b/quic/core/crypto/aes_128_gcm_decrypter_test.cc
@@ -86,7 +86,7 @@
         "a2be08210d8c470a8df6e8fbd79ec5cf",
         nullptr  // FAIL
     },
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_1[] = {
     {
@@ -97,7 +97,7 @@
     {"2370e320d4344208e0ff5683f243b213", "04dbb82f044d30831c441228", "",
      "d43a8e5089eea0d026c03a85178b27da", "2a049c049d25aa95969b451d93c31c6e",
      ""},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_2[] = {
     {"e98b72a9881a84ca6b76e0f43e68647a", "8b23299fde174053f3d652ba",
@@ -112,7 +112,7 @@
         "a145319896329c96df291f64efbe0e3a",
         nullptr  // FAIL
     },
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_3[] = {
     {"af57f42c60c0fc5a09adb81ab86ca1c3", "a2dc01871f37025dc0fc9a79",
@@ -137,7 +137,7 @@
         "8ca4e38aa3dfa6b1d0297021ccf3ea5f",
         nullptr  // FAIL
     },
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_4[] = {
     {"da2bb7d581493d692380c77105590201", "44aa3e7856ca279d2eb020c6",
@@ -168,7 +168,7 @@
         "8b347853f11d75e81e8a95010be81f17",
         nullptr  // FAIL
     },
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_5[] = {
     {"387218b246c1a8257748b56980e50c94", "dd7e014198672be39f95b69d",
@@ -185,7 +185,7 @@
         "a85b66c3cb5eab91d5bdc8bc0e", "", "dc054efc01f3afd21d9c2484819f569a",
         nullptr  // FAIL
     },
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector* const test_group_array[] = {
     test_group_0, test_group_1, test_group_2,
diff --git a/quic/core/crypto/aes_128_gcm_encrypter_test.cc b/quic/core/crypto/aes_128_gcm_encrypter_test.cc
index 3efe529..c557e11 100644
--- a/quic/core/crypto/aes_128_gcm_encrypter_test.cc
+++ b/quic/core/crypto/aes_128_gcm_encrypter_test.cc
@@ -78,7 +78,7 @@
      "250327c674aaf477aef2675748cf6971"},
     {"ca47248ac0b6f8372a97ac43508308ed", "ffd2b598feabc9019262d2be", "", "", "",
      "60d20404af527d248d893ae495707d1a"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_1[] = {
     {"77be63708971c4e240d1cb79e8d77feb", "e0e00f19fed7ba0136a797f3", "",
@@ -87,7 +87,7 @@
     {"7680c5d3ca6154758e510f4d25b98820", "f8f105f9c3df4965780321f8", "",
      "c94c410194c765e3dcc7964379758ed3", "",
      "94dca8edfcf90bb74b153c8d48a17930"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_2[] = {
     {"7fddb57453c241d03efbed3ac44e371c", "ee283a3fc75575e33efd4887",
@@ -96,7 +96,7 @@
     {"ab72c77b97cb5fe9a382d9fe81ffdbed", "54cc7dc2c37ec006bcc6d1da",
      "007c5e5b3e59df24a7c355584fc1518d", "", "0e1bde206a07a9c2c1b65300f8c64997",
      "2b4401346697138c7a4891ee59867d0c"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_3[] = {
     {"fe47fcce5fc32665d2ae399e4eec72ba", "5adb9609dbaeb58cbd6e7275",
@@ -113,7 +113,7 @@
      "a7443d31c26bdf2a1c945e29ee4bd344a99cfaf3aa71f8b3f191f83c2adfc7a0716299"
      "5506fde6309ffc19e716eddf1a828c5a",
      "890147971946b627c40016da1ecf3e77"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_4[] = {
     {"2c1f21cf0f6fb3661943155c3e3d8492", "23cb5ff362e22426984d1907",
@@ -134,7 +134,7 @@
      "aaadbd5c92e9151ce3db7210b8714126b73e43436d242677afa50384f2149b831f1d57"
      "3c7891c2a91fbc48db29967ec9542b23",
      "21b51ca862cb637cdd03b99a0f93b134"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_5[] = {
     {"fe9bb47deb3a61e423c2231841cfd1fb", "4d328eb776f500a2f7fb47aa",
@@ -143,7 +143,7 @@
     {"6703df3701a7f54911ca72e24dca046a", "12823ab601c350ea4bc2488c",
      "793cd125b0b84a043e3ac67717", "", "b2051c80014f42f08735a7b0cd",
      "38e6bcd29962e5f2c13626b85a877101"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector* const test_group_array[] = {
     test_group_0, test_group_1, test_group_2,
diff --git a/quic/core/crypto/aes_256_gcm_decrypter_test.cc b/quic/core/crypto/aes_256_gcm_decrypter_test.cc
index 4e7e05b..73a3b3d 100644
--- a/quic/core/crypto/aes_256_gcm_decrypter_test.cc
+++ b/quic/core/crypto/aes_256_gcm_decrypter_test.cc
@@ -88,7 +88,7 @@
         "51e43385bf533e168427e1ad", "", "", "38fe845c66e66bdd884c2aecafd280e6",
         nullptr  // FAIL
     },
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_1[] = {
     {"6dfdafd6703c285c01f14fd10a6012862b2af950d4733abb403b2e745b26945d",
@@ -99,7 +99,7 @@
         "0723fb84a08f4ea09841f32a", "", "140be561b6171eab942c486a94d33d43",
         "aa0e1c9b57975bfc91aa137231977d2c", nullptr  // FAIL
     },
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_2[] = {
     {"4c8ebfe1444ec1b2d503c6986659af2c94fafe945f72c1e8486a5acfedb8a0f8",
@@ -113,7 +113,7 @@
         "835090aed9552dbdd45277e2", "9f6607d68e22ccf21928db0986be126e", "",
         "f32617f67c574fd9f44ef76ff880ab9f", nullptr  // FAIL
     },
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_3[] = {
     {
@@ -141,7 +141,7 @@
      "9cb3d04637048bc0bddef803ffbb56cf",
      "1d21639640e11638a2769e3fab78778f84be3f4a8ce28dfd99cb2e75171e05ea8e94e30aa"
      "78b54bb402b39d613616a8ed951dc"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_4[] = {
     {
@@ -175,7 +175,7 @@
      "e0299e079bff46fd12e36d1c60e41434",
      "e5a3ce804a8516cdd12122c091256b789076576040dbf3c55e8be3c016025896b8a72532b"
      "fd51196cc82efca47aa0fd8e2e0dc"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_5[] = {
     {
@@ -189,7 +189,7 @@
     {"dc1f64681014be221b00793bbcf5a5bc675b968eb7a3a3d5aa5978ef4fa45ecc",
      "056ae9a1a69e38af603924fe", "33013a48d9ea0df2911d583271", "",
      "5b8f9cc22303e979cd1524187e9f70fe", "2a7e05612191c8bce2f529dca9"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector* const test_group_array[] = {
     test_group_0, test_group_1, test_group_2,
diff --git a/quic/core/crypto/aes_256_gcm_encrypter_test.cc b/quic/core/crypto/aes_256_gcm_encrypter_test.cc
index 86bf0c4..03f6b75 100644
--- a/quic/core/crypto/aes_256_gcm_encrypter_test.cc
+++ b/quic/core/crypto/aes_256_gcm_encrypter_test.cc
@@ -81,7 +81,7 @@
     {"5fe0861cdc2690ce69b3658c7f26f8458eec1c9243c5ba0845305d897e96ca0f",
      "770ac1a5a3d476d5d96944a1", "", "", "",
      "196d691e1047093ca4b3d2ef4baba216"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_1[] = {
     {"78dc4e0aaf52d935c3c01eea57428f00ca1fd475f5da86a49c8dd73d68c8e223",
@@ -90,7 +90,7 @@
     {"4457ff33683cca6ca493878bdc00373893a9763412eef8cddb54f91318e0da88",
      "699d1f29d7b8c55300bb1fd2", "", "6749daeea367d0e9809e2dc2f309e6e3", "",
      "d60c74d2517fde4a74e0cd4709ed43a9"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_2[] = {
     {"31bdadd96698c204aa9ce1448ea94ae1fb4a9a0b3c9d773b51bb1822666b8f22",
@@ -99,7 +99,7 @@
     {"460fc864972261c2560e1eb88761ff1c992b982497bd2ac36c04071cbb8e5d99",
      "8a4a16b9e210eb68bcb6f58d", "99e4e926ffe927f691893fb79a96b067", "",
      "133fc15751621b5f325c7ff71ce08324", "ec4e87e0cf74a13618d0b68636ba9fa7"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_3[] = {
     {"24501ad384e473963d476edcfe08205237acfd49b5b8f33857f8114e863fec7f",
@@ -118,7 +118,7 @@
      "871cd53d95a8b806bd4821e6c4456204d27fd704ba3d07ce25872dc604ea5c5ea13322186"
      "b7489db4fa060c1fd4159692612c8",
      "07b48e4a32fac47e115d7ac7445d8330"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_4[] = {
     {"148579a3cbca86d5520d66c0ec71ca5f7e41ba78e56dc6eebd566fed547fe691",
@@ -141,7 +141,7 @@
      "32ca3588e3e56eb4c8301b009d8b84b8a900b2b88ca3c21944205e9dd7311757b51394ae9"
      "0d8bb3807b471677614f4198af909",
      "3e403d035c71d88f1be1a256c89ba6ad"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector test_group_5[] = {
     {"82c4f12eeec3b2d3d157b0f992d292b237478d2cecc1d5f161389b97f999057a",
@@ -150,7 +150,7 @@
     {"db4340af2f835a6c6d7ea0ca9d83ca81ba02c29b7410f221cb6071114e393240",
      "40e438357dd80a85cac3349e", "8ddb3397bd42853193cb0f80c9", "",
      "b694118c85c41abf69e229cb0f", "c07f1b8aafbd152f697eb67f2a85fe45"},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 const TestVector* const test_group_array[] = {
     test_group_0, test_group_1, test_group_2,
diff --git a/quic/core/crypto/chacha20_poly1305_decrypter_test.cc b/quic/core/crypto/chacha20_poly1305_decrypter_test.cc
index 39c0e8a..a9c4999 100644
--- a/quic/core/crypto/chacha20_poly1305_decrypter_test.cc
+++ b/quic/core/crypto/chacha20_poly1305_decrypter_test.cc
@@ -103,7 +103,7 @@
      "1ae10b594f09e26a7e902ecb",  // "d0600691" truncated
 
      nullptr},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 }  // namespace
 
diff --git a/quic/core/crypto/chacha20_poly1305_encrypter_test.cc b/quic/core/crypto/chacha20_poly1305_encrypter_test.cc
index e04d864..4584d96 100644
--- a/quic/core/crypto/chacha20_poly1305_encrypter_test.cc
+++ b/quic/core/crypto/chacha20_poly1305_encrypter_test.cc
@@ -60,7 +60,7 @@
         "6116"
         "1ae10b594f09e26a7e902ecb",  // "d0600691" truncated
     },
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 }  // namespace
 
diff --git a/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc b/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc
index 02ecc73..ce4dea9 100644
--- a/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc
+++ b/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc
@@ -103,7 +103,7 @@
      "1ae10b594f09e26a7e902ecbd0600691",
 
      nullptr},
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 }  // namespace
 
diff --git a/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc b/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc
index 32fde50..ef4a8e8 100644
--- a/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc
+++ b/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc
@@ -30,36 +30,37 @@
   const char* ct;
 };
 
-const TestVector test_vectors[] = {{
-                                       "808182838485868788898a8b8c8d8e8f"
-                                       "909192939495969798999a9b9c9d9e9f",
+const TestVector test_vectors[] = {
+    {
+        "808182838485868788898a8b8c8d8e8f"
+        "909192939495969798999a9b9c9d9e9f",
 
-                                       "4c616469657320616e642047656e746c"
-                                       "656d656e206f662074686520636c6173"
-                                       "73206f66202739393a20496620492063"
-                                       "6f756c64206f6666657220796f75206f"
-                                       "6e6c79206f6e652074697020666f7220"
-                                       "746865206675747572652c2073756e73"
-                                       "637265656e20776f756c642062652069"
-                                       "742e",
+        "4c616469657320616e642047656e746c"
+        "656d656e206f662074686520636c6173"
+        "73206f66202739393a20496620492063"
+        "6f756c64206f6666657220796f75206f"
+        "6e6c79206f6e652074697020666f7220"
+        "746865206675747572652c2073756e73"
+        "637265656e20776f756c642062652069"
+        "742e",
 
-                                       "4041424344454647",
+        "4041424344454647",
 
-                                       "07000000",
+        "07000000",
 
-                                       "50515253c0c1c2c3c4c5c6c7",
+        "50515253c0c1c2c3c4c5c6c7",
 
-                                       "d31a8d34648e60db7b86afbc53ef7ec2"
-                                       "a4aded51296e08fea9e2b5a736ee62d6"
-                                       "3dbea45e8ca9671282fafb69da92728b"
-                                       "1a71de0a9e060b2905d6a5b67ecd3b36"
-                                       "92ddbd7f2d778b8c9803aee328091b58"
-                                       "fab324e4fad675945585808b4831d7bc"
-                                       "3ff4def08e4b7a9de576d26586cec64b"
-                                       "6116"
-                                       "1ae10b594f09e26a7e902ecbd0600691",
-                                   },
-                                   {nullptr}};
+        "d31a8d34648e60db7b86afbc53ef7ec2"
+        "a4aded51296e08fea9e2b5a736ee62d6"
+        "3dbea45e8ca9671282fafb69da92728b"
+        "1a71de0a9e060b2905d6a5b67ecd3b36"
+        "92ddbd7f2d778b8c9803aee328091b58"
+        "fab324e4fad675945585808b4831d7bc"
+        "3ff4def08e4b7a9de576d26586cec64b"
+        "6116"
+        "1ae10b594f09e26a7e902ecbd0600691",
+    },
+    {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}};
 
 }  // namespace
 
diff --git a/quic/core/crypto/channel_id_test.cc b/quic/core/crypto/channel_id_test.cc
index d367382..c69e328 100644
--- a/quic/core/crypto/channel_id_test.cc
+++ b/quic/core/crypto/channel_id_test.cc
@@ -197,7 +197,7 @@
         "62b5cdd591e5b507e560167ba8f6f7cda74673eb315680cb89ccbc4eec477dce",
         true  // P (0 )
     },
-    {nullptr}};
+    {nullptr, nullptr, nullptr, nullptr, nullptr, false}};
 
 // Returns true if |ch| is a lowercase hexadecimal digit.
 bool IsHexDigit(char ch) {
diff --git a/quic/core/crypto/crypto_framer.cc b/quic/core/crypto/crypto_framer.cc
index ddfd466..931ac99 100644
--- a/quic/core/crypto/crypto_framer.cc
+++ b/quic/core/crypto/crypto_framer.cc
@@ -29,7 +29,7 @@
  public:
   OneShotVisitor() : error_(false) {}
 
-  void OnError(CryptoFramer* framer) override { error_ = true; }
+  void OnError(CryptoFramer* /*framer*/) override { error_ = true; }
 
   void OnHandshakeMessage(const CryptoHandshakeMessage& message) override {
     out_ = QuicMakeUnique<CryptoHandshakeMessage>(message);
@@ -80,7 +80,8 @@
   return error_detail_;
 }
 
-bool CryptoFramer::ProcessInput(QuicStringPiece input, EncryptionLevel level) {
+bool CryptoFramer::ProcessInput(QuicStringPiece input,
+                                EncryptionLevel /*level*/) {
   return ProcessInput(input);
 }
 
diff --git a/quic/core/crypto/crypto_server_test.cc b/quic/core/crypto/crypto_server_test.cc
index 92f774c..b212089 100644
--- a/quic/core/crypto/crypto_server_test.cc
+++ b/quic/core/crypto/crypto_server_test.cc
@@ -44,9 +44,9 @@
   DummyProofVerifierCallback() {}
   ~DummyProofVerifierCallback() override {}
 
-  void Run(bool ok,
-           const std::string& error_details,
-           std::unique_ptr<ProofVerifyDetails>* details) override {
+  void Run(bool /*ok*/,
+           const std::string& /*error_details*/,
+           std::unique_ptr<ProofVerifyDetails>* /*details*/) override {
     DCHECK(false);
   }
 };
@@ -252,12 +252,12 @@
       *called_ = false;
     }
 
-    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 {
       if (should_succeed_) {
         ASSERT_EQ(error, QUIC_NO_ERROR)
             << "Message failed with error " << error_details << ": "
diff --git a/quic/core/crypto/crypto_utils.cc b/quic/core/crypto/crypto_utils.cc
index be12ad4..2b3023e 100644
--- a/quic/core/crypto/crypto_utils.cc
+++ b/quic/core/crypto/crypto_utils.cc
@@ -476,7 +476,7 @@
 // static
 std::string CryptoUtils::HashHandshakeMessage(
     const CryptoHandshakeMessage& message,
-    Perspective perspective) {
+    Perspective /*perspective*/) {
   std::string output;
   const QuicData& serialized = message.GetSerialized();
   uint8_t digest[SHA256_DIGEST_LENGTH];
diff --git a/quic/core/crypto/null_decrypter.cc b/quic/core/crypto/null_decrypter.cc
index 4934f62..e89fecc 100644
--- a/quic/core/crypto/null_decrypter.cc
+++ b/quic/core/crypto/null_decrypter.cc
@@ -32,12 +32,13 @@
   return key.empty();
 }
 
-bool NullDecrypter::SetPreliminaryKey(QuicStringPiece key) {
+bool NullDecrypter::SetPreliminaryKey(QuicStringPiece /*key*/) {
   QUIC_BUG << "Should not be called";
   return false;
 }
 
-bool NullDecrypter::SetDiversificationNonce(const DiversificationNonce& nonce) {
+bool NullDecrypter::SetDiversificationNonce(
+    const DiversificationNonce& /*nonce*/) {
   QUIC_BUG << "Should not be called";
   return true;
 }
@@ -71,7 +72,7 @@
 }
 
 std::string NullDecrypter::GenerateHeaderProtectionMask(
-    QuicDataReader* sample_reader) {
+    QuicDataReader* /*sample_reader*/) {
   return std::string(5, 0);
 }
 
diff --git a/quic/core/crypto/null_encrypter.cc b/quic/core/crypto/null_encrypter.cc
index 69db96d..4ad9b2a 100644
--- a/quic/core/crypto/null_encrypter.cc
+++ b/quic/core/crypto/null_encrypter.cc
@@ -58,7 +58,7 @@
 }
 
 std::string NullEncrypter::GenerateHeaderProtectionMask(
-    QuicStringPiece sample) {
+    QuicStringPiece /*sample*/) {
   return std::string(5, 0);
 }
 
diff --git a/quic/core/crypto/quic_crypto_client_config.cc b/quic/core/crypto/quic_crypto_client_config.cc
index 14f1347..31cb269 100644
--- a/quic/core/crypto/quic_crypto_client_config.cc
+++ b/quic/core/crypto/quic_crypto_client_config.cc
@@ -670,7 +670,7 @@
 QuicErrorCode QuicCryptoClientConfig::CacheNewServerConfig(
     const CryptoHandshakeMessage& message,
     QuicWallTime now,
-    QuicTransportVersion version,
+    QuicTransportVersion /*version*/,
     QuicStringPiece chlo_hash,
     const std::vector<std::string>& cached_certs,
     CachedState* cached,
@@ -771,8 +771,8 @@
 
 QuicErrorCode QuicCryptoClientConfig::ProcessServerHello(
     const CryptoHandshakeMessage& server_hello,
-    QuicConnectionId connection_id,
-    ParsedQuicVersion version,
+    QuicConnectionId /*connection_id*/,
+    ParsedQuicVersion /*version*/,
     const ParsedQuicVersionVector& negotiated_versions,
     CachedState* cached,
     QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
diff --git a/quic/core/crypto/quic_crypto_client_config_test.cc b/quic/core/crypto/quic_crypto_client_config_test.cc
index 7b473de..d337fdc 100644
--- a/quic/core/crypto/quic_crypto_client_config_test.cc
+++ b/quic/core/crypto/quic_crypto_client_config_test.cc
@@ -46,7 +46,9 @@
 
 class AllServerIdsFilter : public QuicCryptoClientConfig::ServerIdFilter {
  public:
-  bool Matches(const QuicServerId& server_id) const override { return true; }
+  bool Matches(const QuicServerId& /*server_id*/) const override {
+    return true;
+  }
 };
 
 }  // namespace
diff --git a/quic/core/crypto/quic_crypto_server_config.cc b/quic/core/crypto/quic_crypto_server_config.cc
index 24d0500..328360d 100644
--- a/quic/core/crypto/quic_crypto_server_config.cc
+++ b/quic/core/crypto/quic_crypto_server_config.cc
@@ -76,7 +76,7 @@
   ~DefaultKeyExchangeSource() override = default;
 
   std::unique_ptr<AsynchronousKeyExchange> Create(
-      std::string server_config_id,
+      std::string /*server_config_id*/,
       bool /* is_fallback */,
       QuicTag type,
       QuicStringPiece private_key) override {
@@ -1199,7 +1199,7 @@
 
 void QuicCryptoServerConfig::EvaluateClientHello(
     const QuicSocketAddress& server_address,
-    QuicTransportVersion version,
+    QuicTransportVersion /*version*/,
     const Configs& configs,
     QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
         client_hello_state,
@@ -1384,7 +1384,7 @@
     const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
     const std::string& signature,
     const std::string& leaf_cert_sct,
-    std::unique_ptr<ProofSource::Details> details,
+    std::unique_ptr<ProofSource::Details> /*details*/,
     CryptoHandshakeMessage message,
     std::unique_ptr<BuildServerConfigUpdateMessageResultCallback> cb) const {
   if (!ok) {
diff --git a/quic/core/crypto/quic_crypto_server_config_test.cc b/quic/core/crypto/quic_crypto_server_config_test.cc
index 90da3cd..17cdaac 100644
--- a/quic/core/crypto/quic_crypto_server_config_test.cc
+++ b/quic/core/crypto/quic_crypto_server_config_test.cc
@@ -465,8 +465,8 @@
 
 class ValidateCallback : public ValidateClientHelloResultCallback {
  public:
-  void Run(QuicReferenceCountedPointer<Result> result,
-           std::unique_ptr<ProofSource::Details> /* details */) override {}
+  void Run(QuicReferenceCountedPointer<Result> /*result*/,
+           std::unique_ptr<ProofSource::Details> /*details*/) override {}
 };
 
 TEST_F(CryptoServerConfigsTest, AdvancePrimaryViaValidate) {
diff --git a/quic/core/crypto/tls_server_connection.cc b/quic/core/crypto/tls_server_connection.cc
index a3a1815..927c75a 100644
--- a/quic/core/crypto/tls_server_connection.cc
+++ b/quic/core/crypto/tls_server_connection.cc
@@ -40,7 +40,7 @@
 // static
 int TlsServerConnection::SelectCertificateCallback(SSL* ssl,
                                                    int* out_alert,
-                                                   void* arg) {
+                                                   void* /*arg*/) {
   return ConnectionFromSsl(ssl)->delegate_->SelectCertificate(out_alert);
 }
 
@@ -50,7 +50,7 @@
                                             uint8_t* out_len,
                                             const uint8_t* in,
                                             unsigned in_len,
-                                            void* arg) {
+                                            void* /*arg*/) {
   return ConnectionFromSsl(ssl)->delegate_->SelectAlpn(out, out_len, in,
                                                        in_len);
 }
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index a64b289..b3aaf20 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -3328,12 +3328,14 @@
 
   size_t num_ping_frames() const { return num_ping_frames_; }
 
-  void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame,
-                           const QuicTime& receive_time) override {
+  void OnWindowUpdateFrame(const QuicWindowUpdateFrame& /*frame*/,
+                           const QuicTime& /*receive_time*/) override {
     ++num_window_update_frames_;
   }
 
-  void OnPingFrame(const QuicPingFrame& frame) override { ++num_ping_frames_; }
+  void OnPingFrame(const QuicPingFrame& /*frame*/) override {
+    ++num_ping_frames_;
+  }
 
  private:
   size_t num_window_update_frames_;
diff --git a/quic/core/http/quic_client_promised_info_test.cc b/quic/core/http/quic_client_promised_info_test.cc
index 24d4821..fcc85ba 100644
--- a/quic/core/http/quic_client_promised_info_test.cc
+++ b/quic/core/http/quic_client_promised_info_test.cc
@@ -46,7 +46,7 @@
       delete;
   ~MockQuicSpdyClientSession() override {}
 
-  bool IsAuthorized(const std::string& authority) override {
+  bool IsAuthorized(const std::string& /*authority*/) override {
     return authorized_;
   }
 
diff --git a/quic/core/http/quic_receive_control_stream.cc b/quic/core/http/quic_receive_control_stream.cc
index 91f65c8..986c4e4 100644
--- a/quic/core/http/quic_receive_control_stream.cc
+++ b/quic/core/http/quic_receive_control_stream.cc
@@ -18,28 +18,28 @@
   HttpDecoderVisitor(const HttpDecoderVisitor&) = delete;
   HttpDecoderVisitor& operator=(const HttpDecoderVisitor&) = delete;
 
-  void OnError(HttpDecoder* decoder) override {
+  void OnError(HttpDecoder* /*decoder*/) override {
     stream_->session()->connection()->CloseConnection(
         QUIC_HTTP_DECODER_ERROR, "Http decoder internal error",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
   }
 
-  bool OnPriorityFrame(const PriorityFrame& frame) override {
+  bool OnPriorityFrame(const PriorityFrame& /*frame*/) override {
     CloseConnectionOnWrongFrame("Priority");
     return false;
   }
 
-  bool OnCancelPushFrame(const CancelPushFrame& frame) override {
+  bool OnCancelPushFrame(const CancelPushFrame& /*frame*/) override {
     CloseConnectionOnWrongFrame("Cancel Push");
     return false;
   }
 
-  bool OnMaxPushIdFrame(const MaxPushIdFrame& frame) override {
+  bool OnMaxPushIdFrame(const MaxPushIdFrame& /*frame*/) override {
     CloseConnectionOnWrongFrame("Max Push Id");
     return false;
   }
 
-  bool OnGoAwayFrame(const GoAwayFrame& frame) override {
+  bool OnGoAwayFrame(const GoAwayFrame& /*frame*/) override {
     CloseConnectionOnWrongFrame("Goaway");
     return false;
   }
@@ -52,17 +52,17 @@
     return stream_->OnSettingsFrame(frame);
   }
 
-  bool OnDuplicatePushFrame(const DuplicatePushFrame& frame) override {
+  bool OnDuplicatePushFrame(const DuplicatePushFrame& /*frame*/) override {
     CloseConnectionOnWrongFrame("Duplicate Push");
     return false;
   }
 
-  bool OnDataFrameStart(Http3FrameLengths frame_lengths) override {
+  bool OnDataFrameStart(Http3FrameLengths /*frame_lengths*/) override {
     CloseConnectionOnWrongFrame("Data");
     return false;
   }
 
-  bool OnDataFramePayload(QuicStringPiece payload) override {
+  bool OnDataFramePayload(QuicStringPiece /*payload*/) override {
     CloseConnectionOnWrongFrame("Data");
     return false;
   }
@@ -72,12 +72,12 @@
     return false;
   }
 
-  bool OnHeadersFrameStart(Http3FrameLengths frame_length) override {
+  bool OnHeadersFrameStart(Http3FrameLengths /*frame_length*/) override {
     CloseConnectionOnWrongFrame("Headers");
     return false;
   }
 
-  bool OnHeadersFramePayload(QuicStringPiece payload) override {
+  bool OnHeadersFramePayload(QuicStringPiece /*payload*/) override {
     CloseConnectionOnWrongFrame("Headers");
     return false;
   }
@@ -87,12 +87,12 @@
     return false;
   }
 
-  bool OnPushPromiseFrameStart(PushId push_id) override {
+  bool OnPushPromiseFrameStart(PushId /*push_id*/) override {
     CloseConnectionOnWrongFrame("Push Promise");
     return false;
   }
 
-  bool OnPushPromiseFramePayload(QuicStringPiece payload) override {
+  bool OnPushPromiseFramePayload(QuicStringPiece /*payload*/) override {
     CloseConnectionOnWrongFrame("Push Promise");
     return false;
   }
@@ -124,7 +124,8 @@
 
 QuicReceiveControlStream::~QuicReceiveControlStream() {}
 
-void QuicReceiveControlStream::OnStreamReset(const QuicRstStreamFrame& frame) {
+void QuicReceiveControlStream::OnStreamReset(
+    const QuicRstStreamFrame& /*frame*/) {
   // TODO(renjietang) Change the error code to H/3 specific
   // HTTP_CLOSED_CRITICAL_STREAM.
   session()->connection()->CloseConnection(
diff --git a/quic/core/http/quic_send_control_stream.cc b/quic/core/http/quic_send_control_stream.cc
index 8002b0c..941c6c0 100644
--- a/quic/core/http/quic_send_control_stream.cc
+++ b/quic/core/http/quic_send_control_stream.cc
@@ -14,7 +14,7 @@
     : QuicStream(id, session, /*is_static = */ true, WRITE_UNIDIRECTIONAL),
       settings_sent_(false) {}
 
-void QuicSendControlStream::OnStreamReset(const QuicRstStreamFrame& frame) {
+void QuicSendControlStream::OnStreamReset(const QuicRstStreamFrame& /*frame*/) {
   // TODO(renjietang) Change the error code to H/3 specific
   // HTTP_CLOSED_CRITICAL_STREAM.
   session()->connection()->CloseConnection(
diff --git a/quic/core/http/quic_spdy_client_session.cc b/quic/core/http/quic_spdy_client_session.cc
index ee81dcf..50ed00d 100644
--- a/quic/core/http/quic_spdy_client_session.cc
+++ b/quic/core/http/quic_spdy_client_session.cc
@@ -176,7 +176,7 @@
       this);
 }
 
-bool QuicSpdyClientSession::IsAuthorized(const std::string& authority) {
+bool QuicSpdyClientSession::IsAuthorized(const std::string& /*authority*/) {
   return true;
 }
 
diff --git a/quic/core/http/quic_spdy_client_session_base.cc b/quic/core/http/quic_spdy_client_session_base.cc
index 93f6880..fe7e21c 100644
--- a/quic/core/http/quic_spdy_client_session_base.cc
+++ b/quic/core/http/quic_spdy_client_session_base.cc
@@ -186,7 +186,8 @@
   headers_stream()->MaybeReleaseSequencerBuffer();
 }
 
-void QuicSpdyClientSessionBase::OnPushStreamTimedOut(QuicStreamId stream_id) {}
+void QuicSpdyClientSessionBase::OnPushStreamTimedOut(
+    QuicStreamId /*stream_id*/) {}
 
 void QuicSpdyClientSessionBase::ResetPromised(
     QuicStreamId id,
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 5004557..fbe8407 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -106,19 +106,19 @@
     header_list_.Clear();
   }
 
-  void OnStreamFrameData(SpdyStreamId stream_id,
-                         const char* data,
-                         size_t len) override {
+  void OnStreamFrameData(SpdyStreamId /*stream_id*/,
+                         const char* /*data*/,
+                         size_t /*len*/) override {
     CloseConnection("SPDY DATA frame received.",
                     QUIC_INVALID_HEADERS_STREAM_DATA);
   }
 
-  void OnStreamEnd(SpdyStreamId stream_id) override {
+  void OnStreamEnd(SpdyStreamId /*stream_id*/) override {
     // The framer invokes OnStreamEnd after processing a frame that had the fin
     // bit set.
   }
 
-  void OnStreamPadding(SpdyStreamId stream_id, size_t len) override {
+  void OnStreamPadding(SpdyStreamId /*stream_id*/, size_t /*len*/) override {
     CloseConnection("SPDY frame padding received.",
                     QUIC_INVALID_HEADERS_STREAM_DATA);
   }
@@ -138,14 +138,15 @@
         code);
   }
 
-  void OnDataFrameHeader(SpdyStreamId stream_id,
-                         size_t length,
-                         bool fin) override {
+  void OnDataFrameHeader(SpdyStreamId /*stream_id*/,
+                         size_t /*length*/,
+                         bool /*fin*/) override {
     CloseConnection("SPDY DATA frame received.",
                     QUIC_INVALID_HEADERS_STREAM_DATA);
   }
 
-  void OnRstStream(SpdyStreamId stream_id, SpdyErrorCode error_code) override {
+  void OnRstStream(SpdyStreamId /*stream_id*/,
+                   SpdyErrorCode /*error_code*/) override {
     CloseConnection("SPDY RST_STREAM frame received.",
                     QUIC_INVALID_HEADERS_STREAM_DATA);
   }
@@ -185,13 +186,13 @@
 
   void OnSettingsEnd() override {}
 
-  void OnPing(SpdyPingId unique_id, bool is_ack) override {
+  void OnPing(SpdyPingId /*unique_id*/, bool /*is_ack*/) override {
     CloseConnection("SPDY PING frame received.",
                     QUIC_INVALID_HEADERS_STREAM_DATA);
   }
 
-  void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                SpdyErrorCode error_code) override {
+  void OnGoAway(SpdyStreamId /*last_accepted_stream_id*/,
+                SpdyErrorCode /*error_code*/) override {
     CloseConnection("SPDY GOAWAY frame received.",
                     QUIC_INVALID_HEADERS_STREAM_DATA);
   }
@@ -202,7 +203,7 @@
                  SpdyStreamId /*parent_stream_id*/,
                  bool /*exclusive*/,
                  bool fin,
-                 bool end) override {
+                 bool /*end*/) override {
     if (!session_->IsConnected()) {
       return;
     }
@@ -220,14 +221,15 @@
     session_->OnHeaders(stream_id, has_priority, priority, fin);
   }
 
-  void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) override {
+  void OnWindowUpdate(SpdyStreamId /*stream_id*/,
+                      int /*delta_window_size*/) override {
     CloseConnection("SPDY WINDOW_UPDATE frame received.",
                     QUIC_INVALID_HEADERS_STREAM_DATA);
   }
 
   void OnPushPromise(SpdyStreamId stream_id,
                      SpdyStreamId promised_stream_id,
-                     bool end) override {
+                     bool /*end*/) override {
     if (!session_->supports_push_promise()) {
       CloseConnection("PUSH_PROMISE not supported.",
                       QUIC_INVALID_HEADERS_STREAM_DATA);
@@ -239,12 +241,12 @@
     session_->OnPushPromise(stream_id, promised_stream_id);
   }
 
-  void OnContinuation(SpdyStreamId stream_id, bool end) override {}
+  void OnContinuation(SpdyStreamId /*stream_id*/, bool /*end*/) override {}
 
   void OnPriority(SpdyStreamId stream_id,
-                  SpdyStreamId parent_id,
+                  SpdyStreamId /*parent_id*/,
                   int weight,
-                  bool exclusive) override {
+                  bool /*exclusive*/) override {
     if (session_->connection()->transport_version() <= QUIC_VERSION_39) {
       CloseConnection("SPDY PRIORITY frame received.",
                       QUIC_INVALID_HEADERS_STREAM_DATA);
@@ -259,15 +261,16 @@
     session_->OnPriority(stream_id, priority);
   }
 
-  bool OnUnknownFrame(SpdyStreamId stream_id, uint8_t frame_type) override {
+  bool OnUnknownFrame(SpdyStreamId /*stream_id*/,
+                      uint8_t /*frame_type*/) override {
     CloseConnection("Unknown frame type received.",
                     QUIC_INVALID_HEADERS_STREAM_DATA);
     return false;
   }
 
   // SpdyFramerDebugVisitorInterface implementation
-  void OnSendCompressedFrame(SpdyStreamId stream_id,
-                             SpdyFrameType type,
+  void OnSendCompressedFrame(SpdyStreamId /*stream_id*/,
+                             SpdyFrameType /*type*/,
                              size_t payload_len,
                              size_t frame_len) override {
     if (payload_len == 0) {
@@ -278,8 +281,8 @@
     QUIC_DVLOG(1) << "Net.QuicHpackCompressionPercentage: " << compression_pct;
   }
 
-  void OnReceiveCompressedFrame(SpdyStreamId stream_id,
-                                SpdyFrameType type,
+  void OnReceiveCompressedFrame(SpdyStreamId /*stream_id*/,
+                                SpdyFrameType /*type*/,
                                 size_t frame_len) override {
     if (session_->IsConnected()) {
       session_->OnCompressedFrameSize(frame_len);
@@ -396,28 +399,28 @@
   set_max_decode_buffer_size_bytes(2 * max_inbound_header_list_size_);
 }
 
-void QuicSpdySession::OnDecoderStreamError(QuicStringPiece error_message) {
+void QuicSpdySession::OnDecoderStreamError(QuicStringPiece /*error_message*/) {
   DCHECK(VersionUsesQpack(connection()->transport_version()));
 
   // TODO(112770235): Signal connection error on decoder stream errors.
   QUIC_NOTREACHED();
 }
 
-void QuicSpdySession::WriteEncoderStreamData(QuicStringPiece data) {
+void QuicSpdySession::WriteEncoderStreamData(QuicStringPiece /*data*/) {
   DCHECK(VersionUsesQpack(connection()->transport_version()));
 
   // TODO(112770235): Send encoder stream data on encoder stream.
   QUIC_NOTREACHED();
 }
 
-void QuicSpdySession::OnEncoderStreamError(QuicStringPiece error_message) {
+void QuicSpdySession::OnEncoderStreamError(QuicStringPiece /*error_message*/) {
   DCHECK(VersionUsesQpack(connection()->transport_version()));
 
   // TODO(112770235): Signal connection error on encoder stream errors.
   QUIC_NOTREACHED();
 }
 
-void QuicSpdySession::WriteDecoderStreamData(QuicStringPiece data) {
+void QuicSpdySession::WriteDecoderStreamData(QuicStringPiece /*data*/) {
   DCHECK(VersionUsesQpack(connection()->transport_version()));
 
   // TODO(112770235): Send decoder stream data on decoder stream.
@@ -614,10 +617,11 @@
   return frame.size();
 }
 
-void QuicSpdySession::OnPromiseHeaderList(QuicStreamId stream_id,
-                                          QuicStreamId promised_stream_id,
-                                          size_t frame_len,
-                                          const QuicHeaderList& header_list) {
+void QuicSpdySession::OnPromiseHeaderList(
+    QuicStreamId /*stream_id*/,
+    QuicStreamId /*promised_stream_id*/,
+    size_t /*frame_len*/,
+    const QuicHeaderList& /*header_list*/) {
   std::string error =
       "OnPromiseHeaderList should be overridden in client code.";
   QUIC_BUG << error;
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index fa43d54..6c1f2ad 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -39,43 +39,43 @@
   HttpDecoderVisitor(const HttpDecoderVisitor&) = delete;
   HttpDecoderVisitor& operator=(const HttpDecoderVisitor&) = delete;
 
-  void OnError(HttpDecoder* decoder) override {
+  void OnError(HttpDecoder* /*decoder*/) override {
     stream_->session()->connection()->CloseConnection(
         QUIC_HTTP_DECODER_ERROR, "Http decoder internal error",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
   }
 
-  bool OnPriorityFrame(const PriorityFrame& frame) override {
+  bool OnPriorityFrame(const PriorityFrame& /*frame*/) override {
     CloseConnectionOnWrongFrame("Priority");
     return false;
   }
 
-  bool OnCancelPushFrame(const CancelPushFrame& frame) override {
+  bool OnCancelPushFrame(const CancelPushFrame& /*frame*/) override {
     CloseConnectionOnWrongFrame("Cancel Push");
     return false;
   }
 
-  bool OnMaxPushIdFrame(const MaxPushIdFrame& frame) override {
+  bool OnMaxPushIdFrame(const MaxPushIdFrame& /*frame*/) override {
     CloseConnectionOnWrongFrame("Max Push Id");
     return false;
   }
 
-  bool OnGoAwayFrame(const GoAwayFrame& frame) override {
+  bool OnGoAwayFrame(const GoAwayFrame& /*frame*/) override {
     CloseConnectionOnWrongFrame("Goaway");
     return false;
   }
 
-  bool OnSettingsFrameStart(Http3FrameLengths frame_lengths) override {
+  bool OnSettingsFrameStart(Http3FrameLengths /*frame_lengths*/) override {
     CloseConnectionOnWrongFrame("Settings");
     return false;
   }
 
-  bool OnSettingsFrame(const SettingsFrame& frame) override {
+  bool OnSettingsFrame(const SettingsFrame& /*frame*/) override {
     CloseConnectionOnWrongFrame("Settings");
     return false;
   }
 
-  bool OnDuplicatePushFrame(const DuplicatePushFrame& frame) override {
+  bool OnDuplicatePushFrame(const DuplicatePushFrame& /*frame*/) override {
     CloseConnectionOnWrongFrame("Duplicate Push");
     return false;
   }
@@ -119,7 +119,7 @@
     return stream_->OnHeadersFrameEnd();
   }
 
-  bool OnPushPromiseFrameStart(PushId push_id) override {
+  bool OnPushPromiseFrameStart(PushId /*push_id*/) override {
     CloseConnectionOnWrongFrame("Push Promise");
     return false;
   }
diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index caff21b..c0431f1 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -51,8 +51,8 @@
     virtual void OnClose(QuicSpdyStream* stream) = 0;
 
     // Allows subclasses to override and do work.
-    virtual void OnPromiseHeadersComplete(QuicStreamId promised_id,
-                                          size_t frame_len) {}
+    virtual void OnPromiseHeadersComplete(QuicStreamId /*promised_id*/,
+                                          size_t /*frame_len*/) {}
 
    protected:
     virtual ~Visitor() {}
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index 66100bb..64e45b9 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -78,7 +78,7 @@
   size_t WriteHeadersImpl(spdy::SpdyHeaderBlock header_block,
                           bool fin,
                           QuicReferenceCountedPointer<QuicAckListenerInterface>
-                              ack_listener) override {
+                          /*ack_listener*/) override {
     saved_headers_ = std::move(header_block);
     WriteHeadersMock(fin);
     if (VersionUsesQpack(transport_version())) {
diff --git a/quic/core/qpack/fuzzer/qpack_encoder_stream_receiver_fuzzer.cc b/quic/core/qpack/fuzzer/qpack_encoder_stream_receiver_fuzzer.cc
index 9991d9a..9b5fe11 100644
--- a/quic/core/qpack/fuzzer/qpack_encoder_stream_receiver_fuzzer.cc
+++ b/quic/core/qpack/fuzzer/qpack_encoder_stream_receiver_fuzzer.cc
@@ -22,14 +22,14 @@
   NoOpDelegate() : error_detected_(false) {}
   ~NoOpDelegate() override = default;
 
-  void OnInsertWithNameReference(bool is_static,
-                                 uint64_t name_index,
-                                 QuicStringPiece value) override {}
-  void OnInsertWithoutNameReference(QuicStringPiece name,
-                                    QuicStringPiece value) override {}
-  void OnDuplicate(uint64_t index) override {}
-  void OnSetDynamicTableCapacity(uint64_t capacity) override {}
-  void OnErrorDetected(QuicStringPiece error_message) override {
+  void OnInsertWithNameReference(bool /*is_static*/,
+                                 uint64_t /*name_index*/,
+                                 QuicStringPiece /*value*/) override {}
+  void OnInsertWithoutNameReference(QuicStringPiece /*name*/,
+                                    QuicStringPiece /*value*/) override {}
+  void OnDuplicate(uint64_t /*index*/) override {}
+  void OnSetDynamicTableCapacity(uint64_t /*capacity*/) override {}
+  void OnErrorDetected(QuicStringPiece /*error_message*/) override {
     error_detected_ = true;
   }
 
diff --git a/quic/core/qpack/qpack_decoder_test_utils.cc b/quic/core/qpack/qpack_decoder_test_utils.cc
index d19ae4a..d00e528 100644
--- a/quic/core/qpack/qpack_decoder_test_utils.cc
+++ b/quic/core/qpack/qpack_decoder_test_utils.cc
@@ -14,10 +14,10 @@
 namespace test {
 
 void NoopEncoderStreamErrorDelegate::OnEncoderStreamError(
-    QuicStringPiece error_message) {}
+    QuicStringPiece /*error_message*/) {}
 
 void NoopDecoderStreamSenderDelegate::WriteDecoderStreamData(
-    QuicStringPiece data) {}
+    QuicStringPiece /*data*/) {}
 
 TestHeadersHandler::TestHeadersHandler()
     : decoding_completed_(false), decoding_error_detected_(false) {}
@@ -38,7 +38,7 @@
 }
 
 void TestHeadersHandler::OnDecodingErrorDetected(
-    QuicStringPiece error_message) {
+    QuicStringPiece /*error_message*/) {
   ASSERT_FALSE(decoding_completed_);
   ASSERT_FALSE(decoding_error_detected_);
 
diff --git a/quic/core/qpack/qpack_decoder_test_utils.h b/quic/core/qpack/qpack_decoder_test_utils.h
index 55761b6..7cc684c 100644
--- a/quic/core/qpack/qpack_decoder_test_utils.h
+++ b/quic/core/qpack/qpack_decoder_test_utils.h
@@ -96,9 +96,10 @@
  public:
   ~NoOpHeadersHandler() override = default;
 
-  void OnHeaderDecoded(QuicStringPiece name, QuicStringPiece value) override {}
+  void OnHeaderDecoded(QuicStringPiece /*name*/,
+                       QuicStringPiece /*value*/) override {}
   void OnDecodingCompleted() override {}
-  void OnDecodingErrorDetected(QuicStringPiece error_message) override {}
+  void OnDecodingErrorDetected(QuicStringPiece /*error_message*/) override {}
 };
 
 void QpackDecode(
diff --git a/quic/core/qpack/qpack_encoder.cc b/quic/core/qpack/qpack_encoder.cc
index 09c4286..2c1e453 100644
--- a/quic/core/qpack/qpack_encoder.cc
+++ b/quic/core/qpack/qpack_encoder.cc
@@ -35,15 +35,15 @@
   decoder_stream_receiver_.Decode(data);
 }
 
-void QpackEncoder::OnInsertCountIncrement(uint64_t increment) {
+void QpackEncoder::OnInsertCountIncrement(uint64_t /*increment*/) {
   // TODO(bnc): Implement dynamic table management for encoding.
 }
 
-void QpackEncoder::OnHeaderAcknowledgement(QuicStreamId stream_id) {
+void QpackEncoder::OnHeaderAcknowledgement(QuicStreamId /*stream_id*/) {
   // TODO(bnc): Implement dynamic table management for encoding.
 }
 
-void QpackEncoder::OnStreamCancellation(QuicStreamId stream_id) {
+void QpackEncoder::OnStreamCancellation(QuicStreamId /*stream_id*/) {
   // TODO(bnc): Implement dynamic table management for encoding.
 }
 
diff --git a/quic/core/qpack/qpack_encoder_test_utils.cc b/quic/core/qpack/qpack_encoder_test_utils.cc
index dd1ccb3..a58b0ae 100644
--- a/quic/core/qpack/qpack_encoder_test_utils.cc
+++ b/quic/core/qpack/qpack_encoder_test_utils.cc
@@ -10,10 +10,10 @@
 namespace test {
 
 void NoopDecoderStreamErrorDelegate::OnDecoderStreamError(
-    QuicStringPiece error_message) {}
+    QuicStringPiece /*error_message*/) {}
 
 void NoopEncoderStreamSenderDelegate::WriteEncoderStreamData(
-    QuicStringPiece data) {}
+    QuicStringPiece /*data*/) {}
 
 std::string QpackEncode(
     QpackEncoder::DecoderStreamErrorDelegate* decoder_stream_error_delegate,
diff --git a/quic/core/qpack/qpack_instruction_encoder.cc b/quic/core/qpack/qpack_instruction_encoder.cc
index 3ae38f6..0da9567 100644
--- a/quic/core/qpack/qpack_instruction_encoder.cc
+++ b/quic/core/qpack/qpack_instruction_encoder.cc
@@ -107,7 +107,7 @@
   state_ = State::kStartField;
 }
 
-size_t QpackInstructionEncoder::DoVarintStart(size_t max_encoded_bytes,
+size_t QpackInstructionEncoder::DoVarintStart(size_t /*max_encoded_bytes*/,
                                               std::string* output) {
   DCHECK(field_->type == QpackInstructionFieldType::kVarint ||
          field_->type == QpackInstructionFieldType::kVarint2 ||
diff --git a/quic/core/qpack/qpack_receive_stream.cc b/quic/core/qpack/qpack_receive_stream.cc
index 1cf2060..f0c4a3d 100644
--- a/quic/core/qpack/qpack_receive_stream.cc
+++ b/quic/core/qpack/qpack_receive_stream.cc
@@ -10,7 +10,7 @@
 QpackReceiveStream::QpackReceiveStream(PendingStream* pending)
     : QuicStream(pending, READ_UNIDIRECTIONAL, /*is_static=*/true) {}
 
-void QpackReceiveStream::OnStreamReset(const QuicRstStreamFrame& frame) {
+void QpackReceiveStream::OnStreamReset(const QuicRstStreamFrame& /*frame*/) {
   // TODO(renjietang) Change the error code to H/3 specific
   // HTTP_CLOSED_CRITICAL_STREAM.
   session()->connection()->CloseConnection(
diff --git a/quic/core/qpack/qpack_send_stream.cc b/quic/core/qpack/qpack_send_stream.cc
index 620ab2b..75b9c57 100644
--- a/quic/core/qpack/qpack_send_stream.cc
+++ b/quic/core/qpack/qpack_send_stream.cc
@@ -15,7 +15,7 @@
       stream_type_(stream_type),
       stream_type_sent_(false) {}
 
-void QpackSendStream::OnStreamReset(const QuicRstStreamFrame& frame) {
+void QpackSendStream::OnStreamReset(const QuicRstStreamFrame& /*frame*/) {
   // TODO(renjietang) Change the error code to H/3 specific
   // HTTP_CLOSED_CRITICAL_STREAM.
   session()->connection()->CloseConnection(
diff --git a/quic/core/quic_buffered_packet_store_test.cc b/quic/core/quic_buffered_packet_store_test.cc
index 466dffb..a00f213 100644
--- a/quic/core/quic_buffered_packet_store_test.cc
+++ b/quic/core/quic_buffered_packet_store_test.cc
@@ -36,7 +36,7 @@
 
   ~QuicBufferedPacketStoreVisitor() override {}
 
-  void OnExpiredPackets(QuicConnectionId connection_id,
+  void OnExpiredPackets(QuicConnectionId /*connection_id*/,
                         BufferedPacketList early_arrived_packets) override {
     last_expired_packet_queue_ = std::move(early_arrived_packets);
   }
diff --git a/quic/core/quic_config.cc b/quic/core/quic_config.cc
index 2423023..e24e84b 100644
--- a/quic/core/quic_config.cc
+++ b/quic/core/quic_config.cc
@@ -170,7 +170,7 @@
 
 QuicErrorCode QuicFixedUint32::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
-    HelloType hello_type,
+    HelloType /*hello_type*/,
     std::string* error_details) {
   DCHECK(error_details != nullptr);
   QuicErrorCode error = peer_hello.GetUint32(tag_, &receive_value_);
@@ -235,7 +235,7 @@
 
 QuicErrorCode QuicFixedUint128::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
-    HelloType hello_type,
+    HelloType /*hello_type*/,
     std::string* error_details) {
   DCHECK(error_details != nullptr);
   QuicErrorCode error = peer_hello.GetUint128(tag_, &receive_value_);
@@ -305,7 +305,7 @@
 
 QuicErrorCode QuicFixedTagVector::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
-    HelloType hello_type,
+    HelloType /*hello_type*/,
     std::string* error_details) {
   DCHECK(error_details != nullptr);
   QuicTagVector values;
@@ -378,7 +378,7 @@
 
 QuicErrorCode QuicFixedSocketAddress::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
-    HelloType hello_type,
+    HelloType /*hello_type*/,
     std::string* error_details) {
   QuicStringPiece address;
   if (!peer_hello.GetStringPiece(tag_, &address)) {
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 895227c..71d3156 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -1460,16 +1460,16 @@
 }
 
 bool QuicConnection::OnNewConnectionIdFrame(
-    const QuicNewConnectionIdFrame& frame) {
+    const QuicNewConnectionIdFrame& /*frame*/) {
   return true;
 }
 
 bool QuicConnection::OnRetireConnectionIdFrame(
-    const QuicRetireConnectionIdFrame& frame) {
+    const QuicRetireConnectionIdFrame& /*frame*/) {
   return true;
 }
 
-bool QuicConnection::OnNewTokenFrame(const QuicNewTokenFrame& frame) {
+bool QuicConnection::OnNewTokenFrame(const QuicNewTokenFrame& /*frame*/) {
   return true;
 }
 
@@ -1630,7 +1630,7 @@
 }
 
 void QuicConnection::OnAuthenticatedIetfStatelessResetPacket(
-    const QuicIetfStatelessResetPacket& packet) {
+    const QuicIetfStatelessResetPacket& /*packet*/) {
   // TODO(fayang): Add OnAuthenticatedIetfStatelessResetPacket to
   // debug_visitor_.
   const std::string error_details = "Received stateless reset.";
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 186d50f..a0299a2 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -201,107 +201,108 @@
   ~QuicConnectionDebugVisitor() override {}
 
   // Called when a packet has been sent.
-  virtual void OnPacketSent(const SerializedPacket& serialized_packet,
-                            QuicPacketNumber original_packet_number,
-                            TransmissionType transmission_type,
-                            QuicTime sent_time) {}
+  virtual void OnPacketSent(const SerializedPacket& /*serialized_packet*/,
+                            QuicPacketNumber /*original_packet_number*/,
+                            TransmissionType /*transmission_type*/,
+                            QuicTime /*sent_time*/) {}
 
   // Called when a PING frame has been sent.
   virtual void OnPingSent() {}
 
   // Called when a packet has been received, but before it is
   // validated or parsed.
-  virtual void OnPacketReceived(const QuicSocketAddress& self_address,
-                                const QuicSocketAddress& peer_address,
-                                const QuicEncryptedPacket& packet) {}
+  virtual void OnPacketReceived(const QuicSocketAddress& /*self_address*/,
+                                const QuicSocketAddress& /*peer_address*/,
+                                const QuicEncryptedPacket& /*packet*/) {}
 
   // Called when the unauthenticated portion of the header has been parsed.
-  virtual void OnUnauthenticatedHeader(const QuicPacketHeader& header) {}
+  virtual void OnUnauthenticatedHeader(const QuicPacketHeader& /*header*/) {}
 
   // Called when a packet is received with a connection id that does not
   // match the ID of this connection.
-  virtual void OnIncorrectConnectionId(QuicConnectionId connection_id) {}
+  virtual void OnIncorrectConnectionId(QuicConnectionId /*connection_id*/) {}
 
   // Called when an undecryptable packet has been received.
   virtual void OnUndecryptablePacket() {}
 
   // Called when a duplicate packet has been received.
-  virtual void OnDuplicatePacket(QuicPacketNumber packet_number) {}
+  virtual void OnDuplicatePacket(QuicPacketNumber /*packet_number*/) {}
 
   // Called when the protocol version on the received packet doensn't match
   // current protocol version of the connection.
-  virtual void OnProtocolVersionMismatch(ParsedQuicVersion version) {}
+  virtual void OnProtocolVersionMismatch(ParsedQuicVersion /*version*/) {}
 
   // Called when the complete header of a packet has been parsed.
-  virtual void OnPacketHeader(const QuicPacketHeader& header) {}
+  virtual void OnPacketHeader(const QuicPacketHeader& /*header*/) {}
 
   // Called when a StreamFrame has been parsed.
-  virtual void OnStreamFrame(const QuicStreamFrame& frame) {}
+  virtual void OnStreamFrame(const QuicStreamFrame& /*frame*/) {}
 
   // Called when a StopWaitingFrame has been parsed.
-  virtual void OnStopWaitingFrame(const QuicStopWaitingFrame& frame) {}
+  virtual void OnStopWaitingFrame(const QuicStopWaitingFrame& /*frame*/) {}
 
   // Called when a QuicPaddingFrame has been parsed.
-  virtual void OnPaddingFrame(const QuicPaddingFrame& frame) {}
+  virtual void OnPaddingFrame(const QuicPaddingFrame& /*frame*/) {}
 
   // Called when a Ping has been parsed.
-  virtual void OnPingFrame(const QuicPingFrame& frame) {}
+  virtual void OnPingFrame(const QuicPingFrame& /*frame*/) {}
 
   // Called when a GoAway has been parsed.
-  virtual void OnGoAwayFrame(const QuicGoAwayFrame& frame) {}
+  virtual void OnGoAwayFrame(const QuicGoAwayFrame& /*frame*/) {}
 
   // Called when a RstStreamFrame has been parsed.
-  virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) {}
+  virtual void OnRstStreamFrame(const QuicRstStreamFrame& /*frame*/) {}
 
   // Called when a ConnectionCloseFrame has been parsed. All forms
   // of CONNECTION CLOSE are handled, Google QUIC, IETF QUIC
   // CONNECTION CLOSE/Transport and IETF QUIC CONNECTION CLOSE/Application
-  virtual void OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) {}
+  virtual void OnConnectionCloseFrame(
+      const QuicConnectionCloseFrame& /*frame*/) {}
 
   // Called when a WindowUpdate has been parsed.
-  virtual void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame,
-                                   const QuicTime& receive_time) {}
+  virtual void OnWindowUpdateFrame(const QuicWindowUpdateFrame& /*frame*/,
+                                   const QuicTime& /*receive_time*/) {}
 
   // Called when a BlockedFrame has been parsed.
-  virtual void OnBlockedFrame(const QuicBlockedFrame& frame) {}
+  virtual void OnBlockedFrame(const QuicBlockedFrame& /*frame*/) {}
 
   // Called when a MessageFrame has been parsed.
-  virtual void OnMessageFrame(const QuicMessageFrame& frame) {}
+  virtual void OnMessageFrame(const QuicMessageFrame& /*frame*/) {}
 
   // Called when a public reset packet has been received.
-  virtual void OnPublicResetPacket(const QuicPublicResetPacket& packet) {}
+  virtual void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) {}
 
   // Called when a version negotiation packet has been received.
   virtual void OnVersionNegotiationPacket(
-      const QuicVersionNegotiationPacket& packet) {}
+      const QuicVersionNegotiationPacket& /*packet*/) {}
 
   // Called when the connection is closed.
-  virtual void OnConnectionClosed(QuicErrorCode error,
-                                  const std::string& error_details,
-                                  ConnectionCloseSource source) {}
+  virtual void OnConnectionClosed(QuicErrorCode /*error*/,
+                                  const std::string& /*error_details*/,
+                                  ConnectionCloseSource /*source*/) {}
 
   // Called when the version negotiation is successful.
   virtual void OnSuccessfulVersionNegotiation(
-      const ParsedQuicVersion& version) {}
+      const ParsedQuicVersion& /*version*/) {}
 
   // Called when a CachedNetworkParameters is sent to the client.
   virtual void OnSendConnectionState(
-      const CachedNetworkParameters& cached_network_params) {}
+      const CachedNetworkParameters& /*cached_network_params*/) {}
 
   // Called when a CachedNetworkParameters are received from the client.
   virtual void OnReceiveConnectionState(
-      const CachedNetworkParameters& cached_network_params) {}
+      const CachedNetworkParameters& /*cached_network_params*/) {}
 
   // Called when the connection parameters are set from the supplied
   // |config|.
-  virtual void OnSetFromConfig(const QuicConfig& config) {}
+  virtual void OnSetFromConfig(const QuicConfig& /*config*/) {}
 
   // Called when RTT may have changed, including when an RTT is read from
   // the config.
-  virtual void OnRttChanged(QuicTime::Delta rtt) const {}
+  virtual void OnRttChanged(QuicTime::Delta /*rtt*/) const {}
 
   // Called when a StopSendingFrame has been parsed.
-  virtual void OnStopSendingFrame(const QuicStopSendingFrame& frame) {}
+  virtual void OnStopSendingFrame(const QuicStopSendingFrame& /*frame*/) {}
 };
 
 class QUIC_EXPORT_PRIVATE QuicConnectionHelperInterface {
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index fcefc82..534b6a3 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -124,16 +124,18 @@
   ~TaggingEncrypter() override {}
 
   // QuicEncrypter interface.
-  bool SetKey(QuicStringPiece key) override { return true; }
+  bool SetKey(QuicStringPiece /*key*/) override { return true; }
 
-  bool SetNoncePrefix(QuicStringPiece nonce_prefix) override { return true; }
+  bool SetNoncePrefix(QuicStringPiece /*nonce_prefix*/) override {
+    return true;
+  }
 
-  bool SetIV(QuicStringPiece iv) override { return true; }
+  bool SetIV(QuicStringPiece /*iv*/) override { return true; }
 
-  bool SetHeaderProtectionKey(QuicStringPiece key) override { return true; }
+  bool SetHeaderProtectionKey(QuicStringPiece /*key*/) override { return true; }
 
-  bool EncryptPacket(uint64_t packet_number,
-                     QuicStringPiece associated_data,
+  bool EncryptPacket(uint64_t /*packet_number*/,
+                     QuicStringPiece /*associated_data*/,
                      QuicStringPiece plaintext,
                      char* output,
                      size_t* output_length,
@@ -150,7 +152,8 @@
     return true;
   }
 
-  std::string GenerateHeaderProtectionMask(QuicStringPiece sample) override {
+  std::string GenerateHeaderProtectionMask(
+      QuicStringPiece /*sample*/) override {
     return std::string(5, 0);
   }
 
@@ -185,29 +188,31 @@
   ~TaggingDecrypter() override {}
 
   // QuicDecrypter interface
-  bool SetKey(QuicStringPiece key) override { return true; }
+  bool SetKey(QuicStringPiece /*key*/) override { return true; }
 
-  bool SetNoncePrefix(QuicStringPiece nonce_prefix) override { return true; }
+  bool SetNoncePrefix(QuicStringPiece /*nonce_prefix*/) override {
+    return true;
+  }
 
-  bool SetIV(QuicStringPiece iv) override { return true; }
+  bool SetIV(QuicStringPiece /*iv*/) override { return true; }
 
-  bool SetHeaderProtectionKey(QuicStringPiece key) override { return true; }
+  bool SetHeaderProtectionKey(QuicStringPiece /*key*/) override { return true; }
 
-  bool SetPreliminaryKey(QuicStringPiece key) override {
+  bool SetPreliminaryKey(QuicStringPiece /*key*/) override {
     QUIC_BUG << "should not be called";
     return false;
   }
 
-  bool SetDiversificationNonce(const DiversificationNonce& key) override {
+  bool SetDiversificationNonce(const DiversificationNonce& /*key*/) override {
     return true;
   }
 
-  bool DecryptPacket(uint64_t packet_number,
-                     QuicStringPiece associated_data,
+  bool DecryptPacket(uint64_t /*packet_number*/,
+                     QuicStringPiece /*associated_data*/,
                      QuicStringPiece ciphertext,
                      char* output,
                      size_t* output_length,
-                     size_t max_output_length) override {
+                     size_t /*max_output_length*/) override {
     if (ciphertext.size() < kTagSize) {
       return false;
     }
@@ -220,7 +225,7 @@
   }
 
   std::string GenerateHeaderProtectionMask(
-      QuicDataReader* sample_reader) override {
+      QuicDataReader* /*sample_reader*/) override {
     return std::string(5, 0);
   }
 
@@ -260,7 +265,7 @@
   ~StrictTaggingDecrypter() override {}
 
   // TaggingQuicDecrypter
-  uint8_t GetTag(QuicStringPiece ciphertext) override { return tag_; }
+  uint8_t GetTag(QuicStringPiece /*ciphertext*/) override { return tag_; }
 
   // Use a distinct value starting with 0xFFFFFF, which is never used by TLS.
   uint32_t cipher_id() const override { return 0xFFFFFFF1; }
@@ -348,9 +353,9 @@
   // QuicPacketWriter interface
   WriteResult WritePacket(const char* buffer,
                           size_t buf_len,
-                          const QuicIpAddress& self_address,
-                          const QuicSocketAddress& peer_address,
-                          PerPacketOptions* options) override {
+                          const QuicIpAddress& /*self_address*/,
+                          const QuicSocketAddress& /*peer_address*/,
+                          PerPacketOptions* /*options*/) override {
     QuicEncryptedPacket packet(buffer, buf_len);
     ++packets_write_attempts_;
 
@@ -428,8 +433,9 @@
 
   bool IsBatchMode() const override { return is_batch_mode_; }
 
-  char* GetNextWriteLocation(const QuicIpAddress& self_address,
-                             const QuicSocketAddress& peer_address) override {
+  char* GetNextWriteLocation(
+      const QuicIpAddress& /*self_address*/,
+      const QuicSocketAddress& /*peer_address*/) override {
     return nullptr;
   }
 
@@ -620,7 +626,7 @@
     QuicConnectionPeer::SetLossAlgorithm(this, loss_algorithm);
   }
 
-  void SendPacket(EncryptionLevel level,
+  void SendPacket(EncryptionLevel /*level*/,
                   uint64_t packet_number,
                   std::unique_ptr<QuicPacket> packet,
                   HasRetransmittableData retransmittable,
@@ -1194,7 +1200,8 @@
                                     level);
   }
 
-  size_t ProcessCryptoPacketAtLevel(uint64_t number, EncryptionLevel level) {
+  size_t ProcessCryptoPacketAtLevel(uint64_t number,
+                                    EncryptionLevel /*level*/) {
     QuicPacketHeader header = ConstructPacketHeader(number, ENCRYPTION_INITIAL);
     QuicFrames frames;
     if (QuicVersionUsesCryptoFrames(connection_.transport_version())) {
@@ -1317,7 +1324,7 @@
 
   size_t ProcessStopWaitingPacketAtLevel(uint64_t number,
                                          QuicStopWaitingFrame frame,
-                                         EncryptionLevel level) {
+                                         EncryptionLevel /*level*/) {
     return ProcessFramePacketAtLevel(number, QuicFrame(frame),
                                      ENCRYPTION_ZERO_RTT);
   }
diff --git a/quic/core/quic_crypto_client_handshaker_test.cc b/quic/core/quic_crypto_client_handshaker_test.cc
index d9e33b7..9658ab7 100644
--- a/quic/core/quic_crypto_client_handshaker_test.cc
+++ b/quic/core/quic_crypto_client_handshaker_test.cc
@@ -17,9 +17,9 @@
  public:
   ~TestProofHandler() override {}
   void OnProofValid(
-      const QuicCryptoClientConfig::CachedState& cached) override {}
+      const QuicCryptoClientConfig::CachedState& /*cached*/) override {}
   void OnProofVerifyDetailsAvailable(
-      const ProofVerifyDetails& verify_details) override {}
+      const ProofVerifyDetails& /*verify_details*/) override {}
 };
 
 class InsecureProofVerifier : public ProofVerifier {
@@ -29,30 +29,30 @@
 
   // ProofVerifier override.
   QuicAsyncStatus VerifyProof(
-      const std::string& hostname,
-      const uint16_t port,
-      const std::string& server_config,
-      QuicTransportVersion transport_version,
-      QuicStringPiece chlo_hash,
-      const std::vector<std::string>& certs,
-      const std::string& cert_sct,
-      const std::string& signature,
-      const ProofVerifyContext* context,
-      std::string* error_details,
-      std::unique_ptr<ProofVerifyDetails>* verify_details,
-      std::unique_ptr<ProofVerifierCallback> callback) override {
+      const std::string& /*hostname*/,
+      const uint16_t /*port*/,
+      const std::string& /*server_config*/,
+      QuicTransportVersion /*transport_version*/,
+      QuicStringPiece /*chlo_hash*/,
+      const std::vector<std::string>& /*certs*/,
+      const std::string& /*cert_sct*/,
+      const std::string& /*signature*/,
+      const ProofVerifyContext* /*context*/,
+      std::string* /*error_details*/,
+      std::unique_ptr<ProofVerifyDetails>* /*verify_details*/,
+      std::unique_ptr<ProofVerifierCallback> /*callback*/) override {
     return QUIC_SUCCESS;
   }
 
   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;
   }
 
@@ -69,21 +69,21 @@
   // ProofSource override.
   void GetProof(const QuicSocketAddress& server_address,
                 const std::string& hostname,
-                const std::string& server_config,
-                QuicTransportVersion transport_version,
-                QuicStringPiece chlo_hash,
+                const std::string& /*server_config*/,
+                QuicTransportVersion /*transport_version*/,
+                QuicStringPiece /*chlo_hash*/,
                 std::unique_ptr<Callback> callback) override {
     QuicReferenceCountedPointer<ProofSource::Chain> chain =
         GetCertChain(server_address, hostname);
     QuicCryptoProof proof;
     proof.signature = "Dummy signature";
     proof.leaf_cert_scts = "Dummy timestamp";
-    callback->Run(true, chain, proof, nullptr /* details */);
+    callback->Run(true, chain, proof, /*details=*/nullptr);
   }
 
   QuicReferenceCountedPointer<Chain> GetCertChain(
-      const QuicSocketAddress& server_address,
-      const std::string& hostname) override {
+      const QuicSocketAddress& /*server_address*/,
+      const std::string& /*hostname*/) override {
     std::vector<std::string> certs;
     certs.push_back("Dummy cert");
     return QuicReferenceCountedPointer<ProofSource::Chain>(
@@ -91,10 +91,10 @@
   }
 
   void 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_algorit*/,
+      QuicStringPiece /*in*/,
       std::unique_ptr<SignatureCallback> callback) override {
     callback->Run(true, "Dummy signature");
   }
diff --git a/quic/core/quic_crypto_server_handshaker.cc b/quic/core/quic_crypto_server_handshaker.cc
index 5ccc109..26134d7 100644
--- a/quic/core/quic_crypto_server_handshaker.cc
+++ b/quic/core/quic_crypto_server_handshaker.cc
@@ -156,7 +156,7 @@
         const std::string& error_details,
         std::unique_ptr<CryptoHandshakeMessage> reply,
         std::unique_ptr<DiversificationNonce> diversification_nonce,
-        std::unique_ptr<ProofSource::Details> proof_source_details) {
+        std::unique_ptr<ProofSource::Details> /*proof_source_details*/) {
   // Clear the callback that got us here.
   DCHECK(process_client_hello_cb_ != nullptr);
   DCHECK(validate_client_hello_cb_ == nullptr);
@@ -376,7 +376,7 @@
 void QuicCryptoServerHandshaker::ProcessClientHello(
     QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
         result,
-    std::unique_ptr<ProofSource::Details> proof_source_details,
+    std::unique_ptr<ProofSource::Details> /*proof_source_details*/,
     std::unique_ptr<ProcessClientHelloResultCallback> done_cb) {
   const CryptoHandshakeMessage& message = result->client_hello;
   std::string error_details;
@@ -417,7 +417,7 @@
 }
 
 void QuicCryptoServerHandshaker::OverrideQuicConfigDefaults(
-    QuicConfig* config) {}
+    QuicConfig* /*config*/) {}
 
 QuicCryptoServerHandshaker::ValidateCallback::ValidateCallback(
     QuicCryptoServerHandshaker* parent)
diff --git a/quic/core/quic_crypto_stream.cc b/quic/core/quic_crypto_stream.cc
index a38cb82..f95a491 100644
--- a/quic/core/quic_crypto_stream.cc
+++ b/quic/core/quic_crypto_stream.cc
@@ -171,10 +171,10 @@
 }
 
 void QuicCryptoStream::OnSuccessfulVersionNegotiation(
-    const ParsedQuicVersion& version) {}
+    const ParsedQuicVersion& /*version*/) {}
 
 bool QuicCryptoStream::OnCryptoFrameAcked(const QuicCryptoFrame& frame,
-                                          QuicTime::Delta ack_delay_time) {
+                                          QuicTime::Delta /*ack_delay_time*/) {
   QuicByteCount newly_acked_length = 0;
   if (!substreams_[frame.level].send_buffer.OnStreamDataAcked(
           frame.offset, frame.data_length, &newly_acked_length)) {
diff --git a/quic/core/quic_default_packet_writer.cc b/quic/core/quic_default_packet_writer.cc
index a9147c0..d092958 100644
--- a/quic/core/quic_default_packet_writer.cc
+++ b/quic/core/quic_default_packet_writer.cc
@@ -39,7 +39,7 @@
 }
 
 QuicByteCount QuicDefaultPacketWriter::GetMaxPacketSize(
-    const QuicSocketAddress& peer_address) const {
+    const QuicSocketAddress& /*peer_address*/) const {
   return kMaxOutgoingPacketSize;
 }
 
@@ -52,8 +52,8 @@
 }
 
 char* QuicDefaultPacketWriter::GetNextWriteLocation(
-    const QuicIpAddress& self_address,
-    const QuicSocketAddress& peer_address) {
+    const QuicIpAddress& /*self_address*/,
+    const QuicSocketAddress& /*peer_address*/) {
   return nullptr;
 }
 
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index 994e2bc..140c45a 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -71,11 +71,11 @@
     return nullptr;
   }
 
-  void OnUnrecoverableError(QuicErrorCode error,
-                            const std::string& error_details) override {}
+  void OnUnrecoverableError(QuicErrorCode /*error*/,
+                            const std::string& /*error_details*/) override {}
 
   // QuicStreamFrameDataProducer
-  WriteStreamDataResult WriteStreamData(QuicStreamId id,
+  WriteStreamDataResult WriteStreamData(QuicStreamId /*id*/,
                                         QuicStreamOffset offset,
                                         QuicByteCount data_length,
                                         QuicDataWriter* writer) override {
@@ -84,7 +84,7 @@
     }
     return WRITE_FAILED;
   }
-  bool WriteCryptoData(EncryptionLevel level,
+  bool WriteCryptoData(EncryptionLevel /*level*/,
                        QuicStreamOffset offset,
                        QuicByteCount data_length,
                        QuicDataWriter* writer) override {
@@ -163,8 +163,8 @@
 // Class which extracts the ALPN from a CHLO packet.
 class ChloAlpnExtractor : public ChloExtractor::Delegate {
  public:
-  void OnChlo(QuicTransportVersion version,
-              QuicConnectionId server_connection_id,
+  void OnChlo(QuicTransportVersion /*version*/,
+              QuicConnectionId /*server_connection_id*/,
               const CryptoHandshakeMessage& chlo) override {
     QuicStringPiece alpn_value;
     if (chlo.GetStringPiece(kALPN, &alpn_value)) {
@@ -581,7 +581,7 @@
 
 void QuicDispatcher::CleanUpSession(SessionMap::iterator it,
                                     QuicConnection* connection,
-                                    ConnectionCloseSource source) {
+                                    ConnectionCloseSource /*source*/) {
   write_blocked_list_.erase(connection);
   QuicTimeWaitListManager::TimeWaitAction action =
       QuicTimeWaitListManager::SEND_STATELESS_RESET;
@@ -733,9 +733,10 @@
   write_blocked_list_.insert(std::make_pair(blocked_writer, true));
 }
 
-void QuicDispatcher::OnRstStreamReceived(const QuicRstStreamFrame& frame) {}
+void QuicDispatcher::OnRstStreamReceived(const QuicRstStreamFrame& /*frame*/) {}
 
-void QuicDispatcher::OnStopSendingReceived(const QuicStopSendingFrame& frame) {}
+void QuicDispatcher::OnStopSendingReceived(
+    const QuicStopSendingFrame& /*frame*/) {}
 
 void QuicDispatcher::OnConnectionAddedToTimeWaitList(
     QuicConnectionId server_connection_id) {
@@ -851,7 +852,7 @@
   DCHECK(false);
 }
 
-void QuicDispatcher::OnDecryptedPacket(EncryptionLevel level) {
+void QuicDispatcher::OnDecryptedPacket(EncryptionLevel /*level*/) {
   DCHECK(false);
 }
 
@@ -923,12 +924,12 @@
   return false;
 }
 
-bool QuicDispatcher::OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame) {
+bool QuicDispatcher::OnMaxStreamsFrame(const QuicMaxStreamsFrame& /*frame*/) {
   return true;
 }
 
 bool QuicDispatcher::OnStreamsBlockedFrame(
-    const QuicStreamsBlockedFrame& frame) {
+    const QuicStreamsBlockedFrame& /*frame*/) {
   return true;
 }
 
@@ -960,29 +961,29 @@
   return false;
 }
 
-bool QuicDispatcher::OnBlockedFrame(const QuicBlockedFrame& frame) {
+bool QuicDispatcher::OnBlockedFrame(const QuicBlockedFrame& /*frame*/) {
   DCHECK(false);
   return false;
 }
 
 bool QuicDispatcher::OnNewConnectionIdFrame(
-    const QuicNewConnectionIdFrame& frame) {
+    const QuicNewConnectionIdFrame& /*frame*/) {
   DCHECK(false);
   return false;
 }
 
 bool QuicDispatcher::OnRetireConnectionIdFrame(
-    const QuicRetireConnectionIdFrame& frame) {
+    const QuicRetireConnectionIdFrame& /*frame*/) {
   DCHECK(false);
   return false;
 }
 
-bool QuicDispatcher::OnNewTokenFrame(const QuicNewTokenFrame& frame) {
+bool QuicDispatcher::OnNewTokenFrame(const QuicNewTokenFrame& /*frame*/) {
   DCHECK(false);
   return false;
 }
 
-bool QuicDispatcher::OnMessageFrame(const QuicMessageFrame& frame) {
+bool QuicDispatcher::OnMessageFrame(const QuicMessageFrame& /*frame*/) {
   DCHECK(false);
   return false;
 }
@@ -991,13 +992,13 @@
   DCHECK(false);
 }
 
-bool QuicDispatcher::IsValidStatelessResetToken(QuicUint128 token) const {
+bool QuicDispatcher::IsValidStatelessResetToken(QuicUint128 /*token*/) const {
   DCHECK(false);
   return false;
 }
 
 void QuicDispatcher::OnAuthenticatedIetfStatelessResetPacket(
-    const QuicIetfStatelessResetPacket& packet) {
+    const QuicIetfStatelessResetPacket& /*packet*/) {
   DCHECK(false);
 }
 
@@ -1049,7 +1050,7 @@
 
 bool QuicDispatcher::ShouldCreateOrBufferPacketForConnection(
     QuicConnectionId server_connection_id,
-    bool ietf_quic) {
+    bool /*ietf_quic*/) {
   QUIC_VLOG(1) << "Received packet from new connection "
                << server_connection_id;
   return true;
@@ -1166,7 +1167,7 @@
 }
 
 bool QuicDispatcher::OnUnauthenticatedUnknownPublicHeader(
-    const QuicPacketHeader& header) {
+    const QuicPacketHeader& /*header*/) {
   return true;
 }
 
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 4a14ef7..b05a0ab 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -330,7 +330,7 @@
       TestDispatcher* dispatcher,
       const QuicConfig& config,
       QuicConnectionId connection_id,
-      const QuicSocketAddress& peer_address,
+      const QuicSocketAddress& /*peer_address*/,
       MockQuicConnectionHelper* helper,
       MockAlarmFactory* alarm_factory,
       const QuicCryptoServerConfig* crypto_config,
@@ -972,11 +972,11 @@
   bool IsWriteBlocked() const override { return write_blocked_; }
   void SetWritable() override { write_blocked_ = false; }
 
-  WriteResult WritePacket(const char* buffer,
-                          size_t buf_len,
-                          const QuicIpAddress& self_client_address,
-                          const QuicSocketAddress& peer_client_address,
-                          PerPacketOptions* options) override {
+  WriteResult WritePacket(const char* /*buffer*/,
+                          size_t /*buf_len*/,
+                          const QuicIpAddress& /*self_client_address*/,
+                          const QuicSocketAddress& /*peer_client_address*/,
+                          PerPacketOptions* /*options*/) override {
     // It would be quite possible to actually implement this method here with
     // the fake blocked status, but it would be significantly more work in
     // Chromium, and since it's not called anyway, don't bother.
diff --git a/quic/core/quic_error_codes.h b/quic/core/quic_error_codes.h
index 3de93f6..34019de 100644
--- a/quic/core/quic_error_codes.h
+++ b/quic/core/quic_error_codes.h
@@ -352,7 +352,7 @@
 }
 
 QUIC_EXPORT_PRIVATE inline std::string HistogramEnumDescription(
-    QuicErrorCode dummy) {
+    QuicErrorCode /*dummy*/) {
   return "cause";
 }
 
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 836b4bf..cc58806 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -176,8 +176,9 @@
   }
 }
 
-QuicPacketNumberLength ReadAckPacketNumberLength(QuicTransportVersion version,
-                                                 uint8_t flags) {
+QuicPacketNumberLength ReadAckPacketNumberLength(
+    QuicTransportVersion /*version*/,
+    uint8_t flags) {
   switch (flags & PACKET_FLAGS_8BYTE_PACKET) {
     case PACKET_FLAGS_8BYTE_PACKET:
       return PACKET_6BYTE_PACKET_NUMBER;
@@ -545,7 +546,7 @@
 
 // static
 size_t QuicFramer::GetStopWaitingFrameSize(
-    QuicTransportVersion version,
+    QuicTransportVersion /*version*/,
     QuicPacketNumberLength packet_number_length) {
   size_t min_size = kQuicFrameTypeSize + packet_number_length;
   return min_size;
@@ -746,7 +747,7 @@
 }
 
 // static
-size_t QuicFramer::GetStreamOffsetSize(QuicTransportVersion version,
+size_t QuicFramer::GetStreamOffsetSize(QuicTransportVersion /*version*/,
                                        QuicStreamOffset offset) {
   // 0 is a special case.
   if (offset == 0) {
@@ -1354,7 +1355,7 @@
 
 // static
 std::unique_ptr<QuicEncryptedPacket> QuicFramer::BuildIetfStatelessResetPacket(
-    QuicConnectionId connection_id,
+    QuicConnectionId /*connection_id*/,
     QuicUint128 stateless_reset_token) {
   QUIC_DVLOG(1) << "Building IETF stateless reset packet.";
   size_t len = kPacketHeaderTypeSize + kMinRandomBytesLengthInStatelessReset +
@@ -2396,7 +2397,7 @@
 
 // static
 QuicPacketNumberLength QuicFramer::GetMinPacketNumberLength(
-    QuicTransportVersion version,
+    QuicTransportVersion /*version*/,
     QuicPacketNumber packet_number) {
   DCHECK(packet_number.IsInitialized());
   if (packet_number < QuicPacketNumber(1 << (PACKET_1BYTE_PACKET_NUMBER * 8))) {
@@ -4621,7 +4622,7 @@
 
 size_t QuicFramer::GetAckFrameSize(
     const QuicAckFrame& ack,
-    QuicPacketNumberLength packet_number_length) {
+    QuicPacketNumberLength /*packet_number_length*/) {
   DCHECK(!ack.packets.Empty());
   size_t ack_size = 0;
 
@@ -5328,7 +5329,7 @@
 }
 
 int QuicFramer::CalculateIetfAckBlockCount(const QuicAckFrame& frame,
-                                           QuicDataWriter* writer,
+                                           QuicDataWriter* /*writer*/,
                                            size_t available_space) {
   // Number of blocks requested in the frame
   uint64_t ack_block_count = frame.packets.NumIntervals();
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index d1a2055..bb57d0d 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -88,16 +88,18 @@
 class TestEncrypter : public QuicEncrypter {
  public:
   ~TestEncrypter() override {}
-  bool SetKey(QuicStringPiece key) override { return true; }
-  bool SetNoncePrefix(QuicStringPiece nonce_prefix) override { return true; }
-  bool SetIV(QuicStringPiece iv) override { return true; }
-  bool SetHeaderProtectionKey(QuicStringPiece key) override { return true; }
+  bool SetKey(QuicStringPiece /*key*/) override { return true; }
+  bool SetNoncePrefix(QuicStringPiece /*nonce_prefix*/) override {
+    return true;
+  }
+  bool SetIV(QuicStringPiece /*iv*/) override { return true; }
+  bool SetHeaderProtectionKey(QuicStringPiece /*key*/) override { return true; }
   bool EncryptPacket(uint64_t packet_number,
                      QuicStringPiece associated_data,
                      QuicStringPiece plaintext,
                      char* output,
                      size_t* output_length,
-                     size_t max_output_length) override {
+                     size_t /*max_output_length*/) override {
     packet_number_ = QuicPacketNumber(packet_number);
     associated_data_ = std::string(associated_data);
     plaintext_ = std::string(plaintext);
@@ -105,7 +107,8 @@
     *output_length = plaintext.length();
     return true;
   }
-  std::string GenerateHeaderProtectionMask(QuicStringPiece sample) override {
+  std::string GenerateHeaderProtectionMask(
+      QuicStringPiece /*sample*/) override {
     return std::string(5, 0);
   }
   size_t GetKeySize() const override { return 0; }
@@ -128,15 +131,17 @@
 class TestDecrypter : public QuicDecrypter {
  public:
   ~TestDecrypter() override {}
-  bool SetKey(QuicStringPiece key) override { return true; }
-  bool SetNoncePrefix(QuicStringPiece nonce_prefix) override { return true; }
-  bool SetIV(QuicStringPiece iv) override { return true; }
-  bool SetHeaderProtectionKey(QuicStringPiece key) override { return true; }
-  bool SetPreliminaryKey(QuicStringPiece key) override {
+  bool SetKey(QuicStringPiece /*key*/) override { return true; }
+  bool SetNoncePrefix(QuicStringPiece /*nonce_prefix*/) override {
+    return true;
+  }
+  bool SetIV(QuicStringPiece /*iv*/) override { return true; }
+  bool SetHeaderProtectionKey(QuicStringPiece /*key*/) override { return true; }
+  bool SetPreliminaryKey(QuicStringPiece /*key*/) override {
     QUIC_BUG << "should not be called";
     return false;
   }
-  bool SetDiversificationNonce(const DiversificationNonce& key) override {
+  bool SetDiversificationNonce(const DiversificationNonce& /*key*/) override {
     return true;
   }
   bool DecryptPacket(uint64_t packet_number,
@@ -144,7 +149,7 @@
                      QuicStringPiece ciphertext,
                      char* output,
                      size_t* output_length,
-                     size_t max_output_length) override {
+                     size_t /*max_output_length*/) override {
     packet_number_ = QuicPacketNumber(packet_number);
     associated_data_ = std::string(associated_data);
     ciphertext_ = std::string(ciphertext);
@@ -153,7 +158,7 @@
     return true;
   }
   std::string GenerateHeaderProtectionMask(
-      QuicDataReader* sample_reader) override {
+      QuicDataReader* /*sample_reader*/) override {
     return std::string(5, 0);
   }
   size_t GetKeySize() const override { return 0; }
@@ -221,11 +226,11 @@
     return accept_public_header_;
   }
 
-  bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override {
+  bool OnUnauthenticatedHeader(const QuicPacketHeader& /*header*/) override {
     return true;
   }
 
-  void OnDecryptedPacket(EncryptionLevel level) override {}
+  void OnDecryptedPacket(EncryptionLevel /*level*/) override {}
 
   bool OnPacketHeader(const QuicPacketHeader& header) override {
     ++packet_count_;
diff --git a/quic/core/quic_ietf_framer_test.cc b/quic/core/quic_ietf_framer_test.cc
index f30fc99..e00ced6 100644
--- a/quic/core/quic_ietf_framer_test.cc
+++ b/quic/core/quic_ietf_framer_test.cc
@@ -91,116 +91,131 @@
 
   void OnPacket() override {}
 
-  void OnPublicResetPacket(const QuicPublicResetPacket& packet) override {}
+  void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) override {}
 
   void OnVersionNegotiationPacket(
-      const QuicVersionNegotiationPacket& packet) override {}
+      const QuicVersionNegotiationPacket& /*packet*/) override {}
 
-  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 OnProtocolVersionMismatch(ParsedQuicVersion received_version,
-                                 PacketHeaderFormat form) override {
+  bool OnProtocolVersionMismatch(ParsedQuicVersion /*received_version*/,
+                                 PacketHeaderFormat /*form*/) override {
     return true;
   }
 
-  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 {}
+  void OnDecryptedPacket(EncryptionLevel /*level*/) override {}
 
-  bool OnPacketHeader(const QuicPacketHeader& header) override { return true; }
-
-  void OnCoalescedPacket(const QuicEncryptedPacket& packet) override {}
-
-  bool OnStreamFrame(const QuicStreamFrame& frame) override { return true; }
-
-  bool OnCryptoFrame(const QuicCryptoFrame& frame) override { return true; }
-
-  bool OnAckFrameStart(QuicPacketNumber largest_acked,
-                       QuicTime::Delta ack_delay_time) override {
+  bool OnPacketHeader(const QuicPacketHeader& /*header*/) override {
     return true;
   }
 
-  bool OnAckRange(QuicPacketNumber start, QuicPacketNumber end) override {
+  void OnCoalescedPacket(const QuicEncryptedPacket& /*packet*/) override {}
+
+  bool OnStreamFrame(const QuicStreamFrame& /*frame*/) override { return true; }
+
+  bool OnCryptoFrame(const QuicCryptoFrame& /*frame*/) override { return true; }
+
+  bool OnAckFrameStart(QuicPacketNumber /*largest_acked*/,
+                       QuicTime::Delta /*ack_delay_time*/) override {
     return true;
   }
 
-  bool OnAckTimestamp(QuicPacketNumber packet_number,
-                      QuicTime timestamp) override {
+  bool OnAckRange(QuicPacketNumber /*start*/,
+                  QuicPacketNumber /*end*/) override {
     return true;
   }
 
-  bool OnAckFrameEnd(QuicPacketNumber start) override { return true; }
-
-  bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override {
+  bool OnAckTimestamp(QuicPacketNumber /*packet_number*/,
+                      QuicTime /*timestamp*/) override {
     return true;
   }
 
-  bool OnPaddingFrame(const QuicPaddingFrame& frame) override { return true; }
+  bool OnAckFrameEnd(QuicPacketNumber /*start*/) override { return true; }
 
-  bool OnPingFrame(const QuicPingFrame& frame) override { return true; }
+  bool OnStopWaitingFrame(const QuicStopWaitingFrame& /*frame*/) override {
+    return true;
+  }
 
-  bool OnMessageFrame(const QuicMessageFrame& frame) override { return true; }
+  bool OnPaddingFrame(const QuicPaddingFrame& /*frame*/) override {
+    return true;
+  }
+
+  bool OnPingFrame(const QuicPingFrame& /*frame*/) override { return true; }
+
+  bool OnMessageFrame(const QuicMessageFrame& /*frame*/) override {
+    return true;
+  }
 
   void OnPacketComplete() override {}
 
-  bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override {
+  bool OnRstStreamFrame(const QuicRstStreamFrame& /*frame*/) override {
     return true;
   }
 
-  bool OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) override {
+  bool OnConnectionCloseFrame(
+      const QuicConnectionCloseFrame& /*frame*/) override {
     return true;
   }
 
-  bool OnStopSendingFrame(const QuicStopSendingFrame& frame) override {
+  bool OnStopSendingFrame(const QuicStopSendingFrame& /*frame*/) override {
     return true;
   }
 
-  bool OnPathChallengeFrame(const QuicPathChallengeFrame& frame) override {
+  bool OnPathChallengeFrame(const QuicPathChallengeFrame& /*frame*/) override {
     return true;
   }
-  bool OnPathResponseFrame(const QuicPathResponseFrame& frame) override {
+  bool OnPathResponseFrame(const QuicPathResponseFrame& /*frame*/) override {
     return true;
   }
 
-  bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override { return true; }
+  bool OnGoAwayFrame(const QuicGoAwayFrame& /*frame*/) override { return true; }
 
-  bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override {
+  bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& /*frame*/) override {
     return true;
   }
 
-  bool OnBlockedFrame(const QuicBlockedFrame& frame) override { return true; }
+  bool OnBlockedFrame(const QuicBlockedFrame& /*frame*/) override {
+    return true;
+  }
 
-  bool OnNewConnectionIdFrame(const QuicNewConnectionIdFrame& frame) override {
+  bool OnNewConnectionIdFrame(
+      const QuicNewConnectionIdFrame& /*frame*/) override {
     return true;
   }
 
   bool OnRetireConnectionIdFrame(
-      const QuicRetireConnectionIdFrame& frame) override {
+      const QuicRetireConnectionIdFrame& /*frame*/) override {
     return true;
   }
 
-  bool OnNewTokenFrame(const QuicNewTokenFrame& frame) override { return true; }
+  bool OnNewTokenFrame(const QuicNewTokenFrame& /*frame*/) override {
+    return true;
+  }
 
-  bool IsValidStatelessResetToken(QuicUint128 token) const override {
+  bool IsValidStatelessResetToken(QuicUint128 /*token*/) const override {
     return true;
   }
 
   void OnAuthenticatedIetfStatelessResetPacket(
-      const QuicIetfStatelessResetPacket& packet) override {}
+      const QuicIetfStatelessResetPacket& /*packet*/) 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;
   }
 };
@@ -289,7 +304,7 @@
   //   - did the things the reader read match what the writer wrote?
   // Returns true if it all worked false if not.
   bool TryAckFrame(char* packet_buffer,
-                   size_t packet_buffer_size,
+                   size_t /*packet_buffer_size*/,
                    struct ack_frame* frame) {
     QuicAckFrame transmit_frame = InitAckFrame(frame->ranges);
     if (frame->is_ack_ecn) {
diff --git a/quic/core/quic_packet_creator.h b/quic/core/quic_packet_creator.h
index e9306b3..d2c94ef 100644
--- a/quic/core/quic_packet_creator.h
+++ b/quic/core/quic_packet_creator.h
@@ -52,7 +52,7 @@
     virtual ~DebugDelegate() {}
 
     // Called when a frame has been added to the current packet.
-    virtual void OnFrameAddedToPacket(const QuicFrame& frame) {}
+    virtual void OnFrameAddedToPacket(const QuicFrame& /*frame*/) {}
   };
 
   QuicPacketCreator(QuicConnectionId server_connection_id,
diff --git a/quic/core/quic_packet_reader.cc b/quic/core/quic_packet_reader.cc
index d2dfd22..bd46c69 100644
--- a/quic/core/quic_packet_reader.cc
+++ b/quic/core/quic_packet_reader.cc
@@ -179,6 +179,11 @@
   // We may not have read all of the packets available on the socket.
   return packets_read == kNumPacketsPerReadMmsgCall;
 #else
+  (void)fd;
+  (void)port;
+  (void)clock;
+  (void)processor;
+  (void)packets_dropped;
   QUIC_LOG(FATAL) << "Unsupported";
   return false;
 #endif
diff --git a/quic/core/quic_packet_writer_wrapper.h b/quic/core/quic_packet_writer_wrapper.h
index e93bfcf..cc3dbc2 100644
--- a/quic/core/quic_packet_writer_wrapper.h
+++ b/quic/core/quic_packet_writer_wrapper.h
@@ -45,7 +45,7 @@
   // Does not take ownership of |writer|.
   void set_non_owning_writer(QuicPacketWriter* writer);
 
-  virtual void set_peer_address(const QuicSocketAddress& peer_address) {}
+  virtual void set_peer_address(const QuicSocketAddress& /*peer_address*/) {}
 
   QuicPacketWriter* writer() { return writer_; }
 
diff --git a/quic/core/quic_packets.cc b/quic/core/quic_packets.cc
index a828dcb..0b1c05d 100644
--- a/quic/core/quic_packets.cc
+++ b/quic/core/quic_packets.cc
@@ -300,7 +300,7 @@
       retry_token_length_(retry_token_length),
       length_length_(length_length) {}
 
-QuicPacket::QuicPacket(QuicTransportVersion version,
+QuicPacket::QuicPacket(QuicTransportVersion /*version*/,
                        char* buffer,
                        size_t length,
                        bool owns_buffer,
diff --git a/quic/core/quic_sent_packet_manager.h b/quic/core/quic_sent_packet_manager.h
index bba4887..8d230a2 100644
--- a/quic/core/quic_sent_packet_manager.h
+++ b/quic/core/quic_sent_packet_manager.h
@@ -54,25 +54,26 @@
 
     // Called when a spurious retransmission is detected.
     virtual void OnSpuriousPacketRetransmission(
-        TransmissionType transmission_type,
-        QuicByteCount byte_size) {}
+        TransmissionType /*transmission_type*/,
+        QuicByteCount /*byte_size*/) {}
 
-    virtual void OnIncomingAck(const QuicAckFrame& ack_frame,
-                               QuicTime ack_receive_time,
-                               QuicPacketNumber largest_observed,
-                               bool rtt_updated,
-                               QuicPacketNumber least_unacked_sent_packet) {}
+    virtual void OnIncomingAck(const QuicAckFrame& /*ack_frame*/,
+                               QuicTime /*ack_receive_time*/,
+                               QuicPacketNumber /*largest_observed*/,
+                               bool /*rtt_updated*/,
+                               QuicPacketNumber /*least_unacked_sent_packet*/) {
+    }
 
-    virtual void OnPacketLoss(QuicPacketNumber lost_packet_number,
-                              TransmissionType transmission_type,
-                              QuicTime detection_time) {}
+    virtual void OnPacketLoss(QuicPacketNumber /*lost_packet_number*/,
+                              TransmissionType /*transmission_type*/,
+                              QuicTime /*detection_time*/) {}
 
     virtual void OnApplicationLimited() {}
 
-    virtual void OnAdjustNetworkParameters(QuicBandwidth bandwidth,
-                                           QuicTime::Delta rtt,
-                                           QuicByteCount old_cwnd,
-                                           QuicByteCount new_cwnd) {}
+    virtual void OnAdjustNetworkParameters(QuicBandwidth /*bandwidth*/,
+                                           QuicTime::Delta /*rtt*/,
+                                           QuicByteCount /*old_cwnd*/,
+                                           QuicByteCount /*new_cwnd*/) {}
   };
 
   // Interface which gets callbacks from the QuicSentPacketManager when
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index 58d8b14..2fbd85f 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -161,7 +161,7 @@
     EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
   }
 
-  void ExpectUpdatedRtt(uint64_t largest_observed) {
+  void ExpectUpdatedRtt(uint64_t /*largest_observed*/) {
     EXPECT_CALL(*send_algorithm_,
                 OnCongestionEvent(true, _, _, IsEmpty(), IsEmpty()));
     EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 754a512..6849ea9 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -397,7 +397,7 @@
   stream->OnStreamReset(frame);
 }
 
-void QuicSession::OnGoAway(const QuicGoAwayFrame& frame) {
+void QuicSession::OnGoAway(const QuicGoAwayFrame& /*frame*/) {
   goaway_received_ = true;
 }
 
@@ -496,7 +496,7 @@
 }
 
 void QuicSession::OnConnectivityProbeReceived(
-    const QuicSocketAddress& self_address,
+    const QuicSocketAddress& /*self_address*/,
     const QuicSocketAddress& peer_address) {
   if (perspective() == Perspective::IS_SERVER) {
     // Server only sends back a connectivity probe after received a
@@ -1894,7 +1894,7 @@
 }
 
 void QuicSession::OnMessageAcked(QuicMessageId message_id,
-                                 QuicTime receive_timestamp) {
+                                 QuicTime /*receive_timestamp*/) {
   QUIC_DVLOG(1) << ENDPOINT << "message " << message_id << " gets acked.";
 }
 
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index a76e7df..1efde28 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -117,7 +117,7 @@
   void OnCanWrite() override;
   bool SendProbingData() override;
   void OnCongestionWindowChange(QuicTime /*now*/) override {}
-  void OnConnectionMigration(AddressChangeType type) override {}
+  void OnConnectionMigration(AddressChangeType /*type*/) override {}
   // Adds a connection level WINDOW_UPDATE frame.
   void OnAckNeedsRetransmittableFrame() override;
   void SendPing() override;
@@ -567,7 +567,9 @@
   // Processes the stream type information of |pending| depending on
   // different kinds of sessions' own rules. Returns true if the pending stream
   // is converted into a normal stream.
-  virtual bool ProcessPendingStream(PendingStream* pending) { return false; }
+  virtual bool ProcessPendingStream(PendingStream* /*pending*/) {
+    return false;
+  }
 
   bool eliminate_static_stream_map() const {
     return eliminate_static_stream_map_;
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 0d9af18..3e7159d 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -442,9 +442,9 @@
   // contains both expected path responses.
   WriteResult CheckMultiPathResponse(const char* buffer,
                                      size_t buf_len,
-                                     const QuicIpAddress& self_address,
-                                     const QuicSocketAddress& peer_address,
-                                     PerPacketOptions* options) {
+                                     const QuicIpAddress& /*self_address*/,
+                                     const QuicSocketAddress& /*peer_address*/,
+                                     PerPacketOptions* /*options*/) {
     QuicEncryptedPacket packet(buffer, buf_len);
     {
       InSequence s;
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index 6ebda29..668dbdb 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -810,7 +810,7 @@
 bool QuicStream::OnStreamFrameAcked(QuicStreamOffset offset,
                                     QuicByteCount data_length,
                                     bool fin_acked,
-                                    QuicTime::Delta ack_delay_time,
+                                    QuicTime::Delta /*ack_delay_time*/,
                                     QuicByteCount* newly_acked_length) {
   QUIC_DVLOG(1) << ENDPOINT << "stream " << id_ << " Acking "
                 << "[" << offset << ", " << offset + data_length << "]"
@@ -1129,6 +1129,6 @@
   session_->SendStopSending(code, id_);
 }
 
-void QuicStream::OnStopSending(uint16_t code) {}
+void QuicStream::OnStopSending(uint16_t /*code*/) {}
 
 }  // namespace quic
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index 5ae9d32..f247e3f 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -377,10 +377,10 @@
   // Called when data of [offset, offset + data_length] is buffered in send
   // buffer.
   virtual void OnDataBuffered(
-      QuicStreamOffset offset,
-      QuicByteCount data_length,
+      QuicStreamOffset /*offset*/,
+      QuicByteCount /*data_length*/,
       const QuicReferenceCountedPointer<QuicAckListenerInterface>&
-          ack_listener) {}
+      /*ack_listener*/) {}
 
   // True if buffered data in send buffer is below buffered_data_threshold_.
   bool CanWriteNewData() const;
diff --git a/quic/core/quic_stream_sequencer_test.cc b/quic/core/quic_stream_sequencer_test.cc
index 47b1a5c..60525f8 100644
--- a/quic/core/quic_stream_sequencer_test.cc
+++ b/quic/core/quic_stream_sequencer_test.cc
@@ -107,7 +107,7 @@
            VerifyIovecs(sequencer, iovecs, num_iovecs, expected);
   }
 
-  bool VerifyIovecs(const QuicStreamSequencer& sequencer,
+  bool VerifyIovecs(const QuicStreamSequencer& /*sequencer*/,
                     iovec* iovecs,
                     size_t num_iovecs,
                     const std::vector<std::string>& expected) {
diff --git a/quic/core/quic_time_wait_list_manager.h b/quic/core/quic_time_wait_list_manager.h
index ba0c763..2d621d9 100644
--- a/quic/core/quic_time_wait_list_manager.h
+++ b/quic/core/quic_time_wait_list_manager.h
@@ -145,7 +145,7 @@
       bool ietf_quic,
       std::unique_ptr<QuicPerPacketContext> packet_context);
 
-  virtual void GetEndpointId(std::string* endpoint_id) {}
+  virtual void GetEndpointId(std::string* /*endpoint_id*/) {}
 
   // Returns a stateless reset token which will be included in the public reset
   // packet.
diff --git a/quic/core/quic_trace_visitor.cc b/quic/core/quic_trace_visitor.cc
index 8b1b62a..f15e149 100644
--- a/quic/core/quic_trace_visitor.cc
+++ b/quic/core/quic_trace_visitor.cc
@@ -242,7 +242,7 @@
 }
 
 void QuicTraceVisitor::OnPacketLoss(QuicPacketNumber lost_packet_number,
-                                    TransmissionType transmission_type,
+                                    TransmissionType /*transmission_type*/,
                                     QuicTime detection_time) {
   quic_trace::Event* event = trace_.add_events();
   event->set_time_us(ConvertTimestampToRecordedFormat(detection_time));
@@ -279,8 +279,8 @@
 
 void QuicTraceVisitor::OnAdjustNetworkParameters(QuicBandwidth bandwidth,
                                                  QuicTime::Delta rtt,
-                                                 QuicByteCount old_cwnd,
-                                                 QuicByteCount new_cwnd) {
+                                                 QuicByteCount /*old_cwnd*/,
+                                                 QuicByteCount /*new_cwnd*/) {
   quic_trace::Event* event = trace_.add_events();
   event->set_time_us(
       ConvertTimestampToRecordedFormat(connection_->clock()->ApproximateNow()));
diff --git a/quic/core/quic_unacked_packet_map.cc b/quic/core/quic_unacked_packet_map.cc
index 5b3de44..513eb36 100644
--- a/quic/core/quic_unacked_packet_map.cc
+++ b/quic/core/quic_unacked_packet_map.cc
@@ -422,7 +422,7 @@
 }
 
 void QuicUnackedPacketMap::NotifyFramesLost(const QuicTransmissionInfo& info,
-                                            TransmissionType type) {
+                                            TransmissionType /*type*/) {
   DCHECK(session_decides_what_to_write_);
   for (const QuicFrame& frame : info.retransmittable_frames) {
     session_notifier_->OnFrameLost(frame);
diff --git a/quic/core/tls_client_handshaker.cc b/quic/core/tls_client_handshaker.cc
index d90b6f5..7024ff8 100644
--- a/quic/core/tls_client_handshaker.cc
+++ b/quic/core/tls_client_handshaker.cc
@@ -23,7 +23,7 @@
 
 void TlsClientHandshaker::ProofVerifierCallbackImpl::Run(
     bool ok,
-    const std::string& error_details,
+    const std::string& /*error_details*/,
     std::unique_ptr<ProofVerifyDetails>* details) {
   if (parent_ == nullptr) {
     return;
diff --git a/quic/core/tls_handshaker.cc b/quic/core/tls_handshaker.cc
index 3c82a49..db50f5a 100644
--- a/quic/core/tls_handshaker.cc
+++ b/quic/core/tls_handshaker.cc
@@ -15,7 +15,7 @@
 
 TlsHandshaker::TlsHandshaker(QuicCryptoStream* stream,
                              QuicSession* session,
-                             SSL_CTX* ssl_ctx)
+                             SSL_CTX* /*ssl_ctx*/)
     : stream_(stream), session_(session) {
   QUIC_BUG_IF(!GetQuicFlag(FLAGS_quic_supports_tls_handshake))
       << "Attempted to create TLS handshaker when TLS is disabled";
@@ -93,7 +93,7 @@
 
 void TlsHandshaker::FlushFlight() {}
 
-void TlsHandshaker::SendAlert(EncryptionLevel level, uint8_t desc) {
+void TlsHandshaker::SendAlert(EncryptionLevel /*level*/, uint8_t desc) {
   // TODO(nharper): Alerts should be sent on the wire as a 16-bit QUIC error
   // code computed to be 0x100 | desc (draft-ietf-quic-tls-14, section 4.8).
   // This puts it in the range reserved for CRYPTO_ERROR
diff --git a/quic/core/tls_handshaker_test.cc b/quic/core/tls_handshaker_test.cc
index cc22c59..33f3d05 100644
--- a/quic/core/tls_handshaker_test.cc
+++ b/quic/core/tls_handshaker_test.cc
@@ -86,9 +86,9 @@
   // run.
   class FailingProofVerifierCallback : public ProofVerifierCallback {
    public:
-    void Run(bool ok,
-             const std::string& error_details,
-             std::unique_ptr<ProofVerifyDetails>* details) override {
+    void Run(bool /*ok*/,
+             const std::string& /*error_details*/,
+             std::unique_ptr<ProofVerifyDetails>* /*details*/) override {
       FAIL();
     }
   };
diff --git a/quic/core/tls_server_handshaker.cc b/quic/core/tls_server_handshaker.cc
index fdda21f..02a6120 100644
--- a/quic/core/tls_server_handshaker.cc
+++ b/quic/core/tls_server_handshaker.cc
@@ -85,13 +85,13 @@
 }
 
 bool TlsServerHandshaker::GetBase64SHA256ClientChannelID(
-    std::string* output) const {
+    std::string* /*output*/) const {
   // Channel ID is not supported when TLS is used in QUIC.
   return false;
 }
 
 void TlsServerHandshaker::SendServerConfigUpdate(
-    const CachedNetworkParameters* cached_network_params) {
+    const CachedNetworkParameters* /*cached_network_params*/) {
   // SCUP messages aren't supported when using the TLS handshake.
 }
 
@@ -121,7 +121,7 @@
 }
 
 void TlsServerHandshaker::SetPreviousCachedNetworkParams(
-    CachedNetworkParameters cached_network_params) {}
+    CachedNetworkParameters /*cached_network_params*/) {}
 
 bool TlsServerHandshaker::ShouldSendExpectCTHeader() const {
   return false;
diff --git a/quic/quartc/counting_packet_filter.h b/quic/quartc/counting_packet_filter.h
index 32feffc..4c7c270 100644
--- a/quic/quartc/counting_packet_filter.h
+++ b/quic/quartc/counting_packet_filter.h
@@ -25,7 +25,7 @@
   void set_packets_to_drop(int count) { packets_to_drop_ = count; }
 
  protected:
-  bool FilterPacket(const simulator::Packet& packet) override {
+  bool FilterPacket(const simulator::Packet& /*packet*/) override {
     if (packets_to_drop_ > 0) {
       --packets_to_drop_;
       return false;
diff --git a/quic/quartc/quartc_crypto_helpers.cc b/quic/quartc/quartc_crypto_helpers.cc
index dc7b973..fd579ba 100644
--- a/quic/quartc/quartc_crypto_helpers.cc
+++ b/quic/quartc/quartc_crypto_helpers.cc
@@ -11,9 +11,9 @@
 
 void DummyProofSource::GetProof(const QuicSocketAddress& server_address,
                                 const std::string& hostname,
-                                const std::string& server_config,
-                                QuicTransportVersion transport_version,
-                                QuicStringPiece chlo_hash,
+                                const std::string& /*server_config*/,
+                                QuicTransportVersion /*transport_version*/,
+                                QuicStringPiece /*chlo_hash*/,
                                 std::unique_ptr<Callback> callback) {
   QuicReferenceCountedPointer<ProofSource::Chain> chain =
       GetCertChain(server_address, hostname);
@@ -24,8 +24,8 @@
 }
 
 QuicReferenceCountedPointer<DummyProofSource::Chain>
-DummyProofSource::GetCertChain(const QuicSocketAddress& server_address,
-                               const std::string& hostname) {
+DummyProofSource::GetCertChain(const QuicSocketAddress& /*server_address*/,
+                               const std::string& /*hostname*/) {
   std::vector<std::string> certs;
   certs.push_back(kDummyCertName);
   return QuicReferenceCountedPointer<ProofSource::Chain>(
@@ -33,39 +33,39 @@
 }
 
 void DummyProofSource::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(true, "Dummy signature");
 }
 
 QuicAsyncStatus InsecureProofVerifier::VerifyProof(
-    const std::string& hostname,
-    const uint16_t port,
-    const std::string& server_config,
-    QuicTransportVersion transport_version,
-    QuicStringPiece chlo_hash,
-    const std::vector<std::string>& certs,
-    const std::string& cert_sct,
-    const std::string& signature,
-    const ProofVerifyContext* context,
-    std::string* error_details,
-    std::unique_ptr<ProofVerifyDetails>* verify_details,
-    std::unique_ptr<ProofVerifierCallback> callback) {
+    const std::string& /*hostname*/,
+    const uint16_t /*port*/,
+    const std::string& /*server_config*/,
+    QuicTransportVersion /*transport_version*/,
+    QuicStringPiece /*chlo_hash*/,
+    const std::vector<std::string>& /*certs*/,
+    const std::string& /*cert_sct*/,
+    const std::string& /*signature*/,
+    const ProofVerifyContext* /*context*/,
+    std::string* /*error_details*/,
+    std::unique_ptr<ProofVerifyDetails>* /*verify_details*/,
+    std::unique_ptr<ProofVerifierCallback> /*callback*/) {
   return QUIC_SUCCESS;
 }
 
 QuicAsyncStatus InsecureProofVerifier::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) {
+    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*/) {
   return QUIC_SUCCESS;
 }
 
@@ -75,19 +75,19 @@
 }
 
 QuicConnectionId QuartcCryptoServerStreamHelper::GenerateConnectionIdForReject(
-    QuicTransportVersion version,
-    QuicConnectionId connection_id) const {
+    QuicTransportVersion /*version*/,
+    QuicConnectionId /*connection_id*/) const {
   // TODO(b/124399417):  Request a zero-length connection id here when the QUIC
   // server perspective supports it.
   return QuicUtils::CreateRandomConnectionId();
 }
 
 bool QuartcCryptoServerStreamHelper::CanAcceptClientHello(
-    const CryptoHandshakeMessage& message,
-    const QuicSocketAddress& client_address,
-    const QuicSocketAddress& peer_address,
-    const QuicSocketAddress& self_address,
-    std::string* error_details) const {
+    const CryptoHandshakeMessage& /*message*/,
+    const QuicSocketAddress& /*client_address*/,
+    const QuicSocketAddress& /*peer_address*/,
+    const QuicSocketAddress& /*self_address*/,
+    std::string* /*error_details*/) const {
   return true;
 }
 
diff --git a/quic/quartc/quartc_dispatcher.cc b/quic/quartc/quartc_dispatcher.cc
index 240ddc1..a9d5510 100644
--- a/quic/quartc/quartc_dispatcher.cc
+++ b/quic/quartc/quartc_dispatcher.cc
@@ -53,7 +53,7 @@
 QuartcSession* QuartcDispatcher::CreateQuicSession(
     QuicConnectionId connection_id,
     const QuicSocketAddress& client_address,
-    QuicStringPiece alpn,
+    QuicStringPiece /*alpn*/,
     const ParsedQuicVersion& version) {
   // Make our expected connection ID non-mutable since we have a connection.
   SetShouldUpdateExpectedServerConnectionIdLength(false);
diff --git a/quic/quartc/quartc_fakes.h b/quic/quartc/quartc_fakes.h
index be45400..8b86064 100644
--- a/quic/quartc/quartc_fakes.h
+++ b/quic/quartc/quartc_fakes.h
@@ -43,9 +43,9 @@
   }
 
   // Called when connection closes locally, or remotely by peer.
-  void OnConnectionClosed(QuicErrorCode error_code,
-                          const std::string& error_details,
-                          ConnectionCloseSource source) override {
+  void OnConnectionClosed(QuicErrorCode /*error_code*/,
+                          const std::string& /*error_details*/,
+                          ConnectionCloseSource /*source*/) override {
     connected_ = false;
   }
 
@@ -73,9 +73,9 @@
     lost_datagram_ids_.push_back(datagram_id);
   }
 
-  void OnCongestionControlChange(QuicBandwidth bandwidth_estimate,
-                                 QuicBandwidth pacing_rate,
-                                 QuicTime::Delta latest_rtt) override {}
+  void OnCongestionControlChange(QuicBandwidth /*bandwidth_estimate*/,
+                                 QuicBandwidth /*pacing_rate*/,
+                                 QuicTime::Delta /*latest_rtt*/) override {}
 
   QuartcSession* session() { return session_; }
 
@@ -131,7 +131,7 @@
   size_t OnReceived(QuartcStream* stream,
                     iovec* iov,
                     size_t iov_length,
-                    bool fin) override {
+                    bool /*fin*/) override {
     size_t bytes_consumed = 0;
     for (size_t i = 0; i < iov_length; ++i) {
       received_data_[stream->id()] += std::string(
@@ -145,7 +145,7 @@
     errors_[stream->id()] = stream->stream_error();
   }
 
-  void OnBufferChanged(QuartcStream* stream) override {}
+  void OnBufferChanged(QuartcStream* /*stream*/) override {}
 
   bool has_data() { return !received_data_.empty(); }
   std::map<QuicStreamId, std::string> data() { return received_data_; }
diff --git a/quic/quartc/quartc_packet_writer.cc b/quic/quartc/quartc_packet_writer.cc
index 64a72a8..223ad3d 100644
--- a/quic/quartc/quartc_packet_writer.cc
+++ b/quic/quartc/quartc_packet_writer.cc
@@ -17,8 +17,8 @@
 WriteResult QuartcPacketWriter::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(packet_transport_);
 
@@ -42,7 +42,7 @@
 }
 
 QuicByteCount QuartcPacketWriter::GetMaxPacketSize(
-    const QuicSocketAddress& peer_address) const {
+    const QuicSocketAddress& /*peer_address*/) const {
   return max_packet_size_;
 }
 
@@ -59,8 +59,8 @@
 }
 
 char* QuartcPacketWriter::GetNextWriteLocation(
-    const QuicIpAddress& self_address,
-    const QuicSocketAddress& peer_address) {
+    const QuicIpAddress& /*self_address*/,
+    const QuicSocketAddress& /*peer_address*/) {
   return nullptr;
 }
 
diff --git a/quic/quartc/quartc_session.cc b/quic/quartc/quartc_session.cc
index ac908f9..e332613 100644
--- a/quic/quartc/quartc_session.cc
+++ b/quic/quartc/quartc_session.cc
@@ -184,7 +184,7 @@
   }
 }
 
-void QuartcSession::OnCongestionWindowChange(QuicTime now) {
+void QuartcSession::OnCongestionWindowChange(QuicTime /*now*/) {
   DCHECK(session_delegate_);
   const RttStats* rtt_stats = connection_->sent_packet_manager().GetRttStats();
 
@@ -401,12 +401,12 @@
 }
 
 void QuartcClientSession::OnProofValid(
-    const QuicCryptoClientConfig::CachedState& cached) {
+    const QuicCryptoClientConfig::CachedState& /*cached*/) {
   // TODO(zhihuang): Handle the proof verification.
 }
 
 void QuartcClientSession::OnProofVerifyDetailsAvailable(
-    const ProofVerifyDetails& verify_details) {
+    const ProofVerifyDetails& /*verify_details*/) {
   // TODO(zhihuang): Handle the proof verification.
 }
 
diff --git a/quic/quartc/quartc_session_test.cc b/quic/quartc/quartc_session_test.cc
index 1bd0828..8bb9ad1 100644
--- a/quic/quartc/quartc_session_test.cc
+++ b/quic/quartc/quartc_session_test.cc
@@ -90,8 +90,9 @@
 
   // Note that input session config will apply to both server and client.
   // Perspective and packet_transport will be overwritten.
-  void CreateClientAndServerSessions(const QuartcSessionConfig& session_config,
-                                     bool init = true) {
+  void CreateClientAndServerSessions(
+      const QuartcSessionConfig& /*session_config*/,
+      bool init = true) {
     if (init) {
       Init();
     }
diff --git a/quic/quartc/quartc_stream.cc b/quic/quartc/quartc_stream.cc
index 80bc3fc..1250185 100644
--- a/quic/quartc/quartc_stream.cc
+++ b/quic/quartc/quartc_stream.cc
@@ -66,9 +66,10 @@
 }
 
 void QuartcStream::OnDataBuffered(
-    QuicStreamOffset offset,
-    QuicByteCount data_length,
-    const QuicReferenceCountedPointer<QuicAckListenerInterface>& ack_listener) {
+    QuicStreamOffset /*offset*/,
+    QuicByteCount /*data_length*/,
+    const QuicReferenceCountedPointer<
+        QuicAckListenerInterface>& /*ack_listener*/) {
   DCHECK(delegate_);
   delegate_->OnBufferChanged(this);
 }
diff --git a/quic/quartc/quartc_stream_test.cc b/quic/quartc/quartc_stream_test.cc
index 5ee2d6f..be23b75 100644
--- a/quic/quartc/quartc_stream_test.cc
+++ b/quic/quartc/quartc_stream_test.cc
@@ -62,7 +62,7 @@
 
   // Writes outgoing data from QuicStream to a string.
   QuicConsumedData WritevData(QuicStream* stream,
-                              QuicStreamId id,
+                              QuicStreamId /*id*/,
                               size_t write_length,
                               QuicStreamOffset offset,
                               StreamSendingState state) override {
@@ -82,11 +82,11 @@
     return QuicConsumedData(write_length, state != StreamSendingState::NO_FIN);
   }
 
-  QuartcStream* CreateIncomingStream(QuicStreamId id) override {
+  QuartcStream* CreateIncomingStream(QuicStreamId /*id*/) override {
     return nullptr;
   }
 
-  QuartcStream* CreateIncomingStream(PendingStream* pending) override {
+  QuartcStream* CreateIncomingStream(PendingStream* /*pending*/) override {
     return nullptr;
   }
 
@@ -97,9 +97,9 @@
   }
 
   // Called by QuicStream when they want to close stream.
-  void SendRstStream(QuicStreamId id,
-                     QuicRstStreamErrorCode error,
-                     QuicStreamOffset bytes_written) override {}
+  void SendRstStream(QuicStreamId /*id*/,
+                     QuicRstStreamErrorCode /*error*/,
+                     QuicStreamOffset /*bytes_written*/) override {}
 
   // Sets whether data is written to buffer, or else if this is write blocked.
   void set_writable(bool writable) { writable_ = writable; }
@@ -131,11 +131,11 @@
   DummyPacketWriter() {}
 
   // QuicPacketWriter overrides.
-  WriteResult WritePacket(const char* buffer,
-                          size_t buf_len,
-                          const QuicIpAddress& self_address,
-                          const QuicSocketAddress& peer_address,
-                          PerPacketOptions* options) override {
+  WriteResult WritePacket(const char* /*buffer*/,
+                          size_t /*buf_len*/,
+                          const QuicIpAddress& /*self_address*/,
+                          const QuicSocketAddress& /*peer_address*/,
+                          PerPacketOptions* /*options*/) override {
     return WriteResult(WRITE_STATUS_ERROR, 0);
   }
 
@@ -144,7 +144,7 @@
   void SetWritable() override {}
 
   QuicByteCount GetMaxPacketSize(
-      const QuicSocketAddress& peer_address) const override {
+      const QuicSocketAddress& /*peer_address*/) const override {
     return 0;
   }
 
@@ -152,8 +152,9 @@
 
   bool IsBatchMode() const override { return false; }
 
-  char* GetNextWriteLocation(const QuicIpAddress& self_address,
-                             const QuicSocketAddress& peer_address) override {
+  char* GetNextWriteLocation(
+      const QuicIpAddress& /*self_address*/,
+      const QuicSocketAddress& /*peer_address*/) override {
     return nullptr;
   }
 
@@ -173,7 +174,7 @@
   size_t OnReceived(QuartcStream* stream,
                     iovec* iov,
                     size_t iov_length,
-                    bool fin) override {
+                    bool /*fin*/) override {
     EXPECT_EQ(id_, stream->id());
     EXPECT_EQ(stream->ReadOffset(), read_buffer_->size());
     size_t bytes_consumed = 0;
@@ -185,7 +186,7 @@
     return bytes_consumed;
   }
 
-  void OnClose(QuartcStream* stream) override { closed_ = true; }
+  void OnClose(QuartcStream* /*stream*/) override { closed_ = true; }
 
   bool closed() { return closed_; }
 
diff --git a/quic/quartc/test/quartc_peer.cc b/quic/quartc/test/quartc_peer.cc
index 761349e..0a24187 100644
--- a/quic/quartc/test/quartc_peer.cc
+++ b/quic/quartc/test/quartc_peer.cc
@@ -78,7 +78,7 @@
 
 void QuartcPeer::OnCongestionControlChange(QuicBandwidth bandwidth_estimate,
                                            QuicBandwidth pacing_rate,
-                                           QuicTime::Delta latest_rtt) {
+                                           QuicTime::Delta /*latest_rtt*/) {
   // Note: this is fairly crude rate adaptation and makes no effort to account
   // for overhead.  The congestion controller is assumed to account for this.
   // It may do so by detecting overuse and pushing back on its bandwidth
@@ -92,7 +92,7 @@
 
 void QuartcPeer::OnConnectionClosed(QuicErrorCode error_code,
                                     const std::string& error_details,
-                                    ConnectionCloseSource source) {
+                                    ConnectionCloseSource /*source*/) {
   QUIC_LOG(INFO) << "Connection closed, error=" << error_code
                  << ", details=" << error_details;
   SetEnabled(false);
diff --git a/quic/quartc/test/quartc_peer.h b/quic/quartc/test/quartc_peer.h
index 39dd148..2eab393 100644
--- a/quic/quartc/test/quartc_peer.h
+++ b/quic/quartc/test/quartc_peer.h
@@ -84,10 +84,10 @@
                           const std::string& error_details,
                           ConnectionCloseSource source) override;
   void OnMessageReceived(QuicStringPiece message) override;
-  void OnMessageSent(int64_t datagram_id) override {}
-  void OnMessageAcked(int64_t datagram_id,
-                      QuicTime receive_timestamp) override {}
-  void OnMessageLost(int64_t datagram_id) override {}
+  void OnMessageSent(int64_t /*datagram_id*/) override {}
+  void OnMessageAcked(int64_t /*datagram_id*/,
+                      QuicTime /*receive_timestamp*/) override {}
+  void OnMessageLost(int64_t /*datagram_id*/) override {}
 
   // QuartcDataSource::Delegate overrides.
   void OnDataProduced(const char* data, size_t length) override;
diff --git a/quic/quartc/test/random_delay_link.cc b/quic/quartc/test/random_delay_link.cc
index edd57e3..71e161c 100644
--- a/quic/quartc/test/random_delay_link.cc
+++ b/quic/quartc/test/random_delay_link.cc
@@ -31,7 +31,8 @@
 
 RandomDelayLink::~RandomDelayLink() {}
 
-QuicTime::Delta RandomDelayLink::GetRandomDelay(QuicTime::Delta transfer_time) {
+QuicTime::Delta RandomDelayLink::GetRandomDelay(
+    QuicTime::Delta /*transfer_time*/) {
   // Computes a random delay following an exponential distribution, with median
   // value |median_random_delay_|.  Choose a uniform random value between 1 and
   // kNumBuckets, convert this to an exponential, then scale it such that a
diff --git a/quic/quartc/test/random_packet_filter.cc b/quic/quartc/test/random_packet_filter.cc
index 2fb160e..a40748f 100644
--- a/quic/quartc/test/random_packet_filter.cc
+++ b/quic/quartc/test/random_packet_filter.cc
@@ -12,7 +12,7 @@
                                        Endpoint* endpoint)
     : PacketFilter(simulator, name, endpoint), simulator_(simulator) {}
 
-bool RandomPacketFilter::FilterPacket(const Packet& packet) {
+bool RandomPacketFilter::FilterPacket(const Packet& /*packet*/) {
   uint64_t random = simulator_->GetRandomGenerator()->RandUint64();
   return 100 * static_cast<double>(random) /
              std::numeric_limits<uint64_t>::max() >=
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;
diff --git a/quic/tools/quic_client_epoll_network_helper.cc b/quic/tools/quic_client_epoll_network_helper.cc
index 1175211..d16a128 100644
--- a/quic/tools/quic_client_epoll_network_helper.cc
+++ b/quic/tools/quic_client_epoll_network_helper.cc
@@ -122,12 +122,15 @@
   epoll_server_->WaitForEventsAndExecuteCallbacks();
 }
 
-void QuicClientEpollNetworkHelper::OnRegistration(QuicEpollServer* eps,
-                                                  int fd,
-                                                  int event_mask) {}
-void QuicClientEpollNetworkHelper::OnModification(int fd, int event_mask) {}
-void QuicClientEpollNetworkHelper::OnUnregistration(int fd, bool replaced) {}
-void QuicClientEpollNetworkHelper::OnShutdown(QuicEpollServer* eps, int fd) {}
+void QuicClientEpollNetworkHelper::OnRegistration(QuicEpollServer* /*eps*/,
+                                                  int /*fd*/,
+                                                  int /*event_mask*/) {}
+void QuicClientEpollNetworkHelper::OnModification(int /*fd*/,
+                                                  int /*event_mask*/) {}
+void QuicClientEpollNetworkHelper::OnUnregistration(int /*fd*/,
+                                                    bool /*replaced*/) {}
+void QuicClientEpollNetworkHelper::OnShutdown(QuicEpollServer* /*eps*/,
+                                              int /*fd*/) {}
 
 void QuicClientEpollNetworkHelper::OnEvent(int fd, QuicEpollEvent* event) {
   DCHECK_EQ(fd, GetLatestFD());
diff --git a/quic/tools/quic_memory_cache_backend.cc b/quic/tools/quic_memory_cache_backend.cc
index 96faacb..5943380 100644
--- a/quic/tools/quic_memory_cache_backend.cc
+++ b/quic/tools/quic_memory_cache_backend.cc
@@ -282,7 +282,7 @@
 
 void QuicMemoryCacheBackend::FetchResponseFromBackend(
     const SpdyHeaderBlock& request_headers,
-    const std::string& request_body,
+    const std::string& /*request_body*/,
     QuicSimpleServerBackend::RequestHandler* quic_stream) {
   const QuicBackendResponse* quic_response = nullptr;
   // Find response in cache. If not found, send error response.
@@ -303,7 +303,7 @@
 
 // The memory cache does not have a per-stream handler
 void QuicMemoryCacheBackend::CloseBackendResponseStream(
-    QuicSimpleServerBackend::RequestHandler* quic_stream) {}
+    QuicSimpleServerBackend::RequestHandler* /*quic_stream*/) {}
 
 std::list<ServerPushInfo> QuicMemoryCacheBackend::GetServerPushResources(
     std::string request_url) {
diff --git a/quic/tools/quic_packet_printer_bin.cc b/quic/tools/quic_packet_printer_bin.cc
index 80ffd4e..8b148f9 100644
--- a/quic/tools/quic_packet_printer_bin.cc
+++ b/quic/tools/quic_packet_printer_bin.cc
@@ -49,26 +49,27 @@
               << " detail: " << framer->detailed_error() << "\n";
   }
   bool OnProtocolVersionMismatch(ParsedQuicVersion received_version,
-                                 PacketHeaderFormat form) override {
+                                 PacketHeaderFormat /*form*/) override {
     framer_->set_version(received_version);
     std::cerr << "OnProtocolVersionMismatch: "
               << ParsedQuicVersionToString(received_version) << "\n";
     return true;
   }
   void OnPacket() override { std::cerr << "OnPacket\n"; }
-  void OnPublicResetPacket(const QuicPublicResetPacket& packet) override {
+  void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) override {
     std::cerr << "OnPublicResetPacket\n";
   }
   void OnVersionNegotiationPacket(
-      const QuicVersionNegotiationPacket& packet) override {
+      const QuicVersionNegotiationPacket& /*packet*/) override {
     std::cerr << "OnVersionNegotiationPacket\n";
   }
-  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 {
     std::cerr << "OnRetryPacket\n";
   }
-  bool OnUnauthenticatedPublicHeader(const QuicPacketHeader& header) override {
+  bool OnUnauthenticatedPublicHeader(
+      const QuicPacketHeader& /*header*/) override {
     std::cerr << "OnUnauthenticatedPublicHeader\n";
     return true;
   }
@@ -81,11 +82,11 @@
     DCHECK_EQ(ENCRYPTION_INITIAL, level);
     std::cerr << "OnDecryptedPacket\n";
   }
-  bool OnPacketHeader(const QuicPacketHeader& header) override {
+  bool OnPacketHeader(const QuicPacketHeader& /*header*/) override {
     std::cerr << "OnPacketHeader\n";
     return true;
   }
-  void OnCoalescedPacket(const QuicEncryptedPacket& packet) override {
+  void OnCoalescedPacket(const QuicEncryptedPacket& /*packet*/) override {
     std::cerr << "OnCoalescedPacket\n";
   }
   bool OnStreamFrame(const QuicStreamFrame& frame) override {
@@ -130,7 +131,7 @@
     return true;
   }
   bool OnPingFrame(const QuicPingFrame& frame) override {
-    std::cerr << "OnPingFrame\n";
+    std::cerr << "OnPingFrame: " << frame;
     return true;
   }
   bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override {
@@ -194,12 +195,12 @@
     return true;
   }
   void OnPacketComplete() override { std::cerr << "OnPacketComplete\n"; }
-  bool IsValidStatelessResetToken(QuicUint128 token) const override {
+  bool IsValidStatelessResetToken(QuicUint128 /*token*/) const override {
     std::cerr << "IsValidStatelessResetToken\n";
     return false;
   }
   void OnAuthenticatedIetfStatelessResetPacket(
-      const QuicIetfStatelessResetPacket& packet) override {
+      const QuicIetfStatelessResetPacket& /*packet*/) override {
     std::cerr << "OnAuthenticatedIetfStatelessResetPacket\n";
   }
 
diff --git a/quic/tools/quic_server.h b/quic/tools/quic_server.h
index 1f9c225..755e5e3 100644
--- a/quic/tools/quic_server.h
+++ b/quic/tools/quic_server.h
@@ -63,12 +63,14 @@
   virtual void Shutdown();
 
   // From EpollCallbackInterface
-  void OnRegistration(QuicEpollServer* eps, int fd, int event_mask) override {}
-  void OnModification(int fd, int event_mask) override {}
-  void OnEvent(int fd, QuicEpollEvent* event) override;
-  void OnUnregistration(int fd, bool replaced) override {}
+  void OnRegistration(QuicEpollServer* /*eps*/,
+                      int /*fd*/,
+                      int /*event_mask*/) override {}
+  void OnModification(int /*fd*/, int /*event_mask*/) override {}
+  void OnEvent(int /*fd*/, QuicEpollEvent* /*event*/) override;
+  void OnUnregistration(int /*fd*/, bool /*replaced*/) override {}
 
-  void OnShutdown(QuicEpollServer* eps, int fd) override {}
+  void OnShutdown(QuicEpollServer* /*eps*/, int /*fd*/) override {}
 
   void SetChloMultiplier(size_t multiplier) {
     crypto_config_.set_chlo_multiplier(multiplier);
diff --git a/quic/tools/quic_simple_crypto_server_stream_helper.cc b/quic/tools/quic_simple_crypto_server_stream_helper.cc
index 2bb9656..9d55600 100644
--- a/quic/tools/quic_simple_crypto_server_stream_helper.cc
+++ b/quic/tools/quic_simple_crypto_server_stream_helper.cc
@@ -23,11 +23,11 @@
 }
 
 bool QuicSimpleCryptoServerStreamHelper::CanAcceptClientHello(
-    const CryptoHandshakeMessage& message,
-    const QuicSocketAddress& client_address,
-    const QuicSocketAddress& peer_address,
-    const QuicSocketAddress& self_address,
-    std::string* error_details) const {
+    const CryptoHandshakeMessage& /*message*/,
+    const QuicSocketAddress& /*client_address*/,
+    const QuicSocketAddress& /*peer_address*/,
+    const QuicSocketAddress& /*self_address*/,
+    std::string* /*error_details*/) const {
   return true;
 }
 
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index 1304021..03fbdd3 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -124,8 +124,8 @@
                            alarm_factory,
                            perspective,
                            supported_versions) {
-    auto consume_all_data = [](QuicStreamId id, size_t write_length,
-                               QuicStreamOffset offset,
+    auto consume_all_data = [](QuicStreamId /*id*/, size_t write_length,
+                               QuicStreamOffset /*offset*/,
                                StreamSendingState state) {
       return QuicConsumedData(write_length, state != NO_FIN);
     };
diff --git a/quic/tools/quic_simple_server_stream.cc b/quic/tools/quic_simple_server_stream.cc
index e24c110..f852206 100644
--- a/quic/tools/quic_simple_server_stream.cc
+++ b/quic/tools/quic_simple_server_stream.cc
@@ -62,9 +62,9 @@
 }
 
 void QuicSimpleServerStream::OnTrailingHeadersComplete(
-    bool fin,
-    size_t frame_len,
-    const QuicHeaderList& header_list) {
+    bool /*fin*/,
+    size_t /*frame_len*/,
+    const QuicHeaderList& /*header_list*/) {
   QUIC_BUG << "Server does not support receiving Trailers.";
   SendErrorResponse();
 }
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index 7e4af32..de2968f 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -54,10 +54,10 @@
 
   MOCK_METHOD1(WriteHeadersMock, void(bool fin));
 
-  size_t WriteHeaders(spdy::SpdyHeaderBlock header_block,
+  size_t WriteHeaders(spdy::SpdyHeaderBlock /*header_block*/,
                       bool fin,
                       QuicReferenceCountedPointer<QuicAckListenerInterface>
-                          ack_listener) override {
+                      /*ack_listener*/) override {
     WriteHeadersMock(fin);
     return 0;
   }
diff --git a/quic/tools/quic_spdy_client_base.cc b/quic/tools/quic_spdy_client_base.cc
index e9e08fd..d857dec 100644
--- a/quic/tools/quic_spdy_client_base.cc
+++ b/quic/tools/quic_spdy_client_base.cc
@@ -195,9 +195,10 @@
       new ClientQuicDataToResend(std::move(new_headers), body, fin, this));
 }
 
-bool QuicSpdyClientBase::CheckVary(const SpdyHeaderBlock& client_request,
-                                   const SpdyHeaderBlock& promise_request,
-                                   const SpdyHeaderBlock& promise_response) {
+bool QuicSpdyClientBase::CheckVary(
+    const SpdyHeaderBlock& /*client_request*/,
+    const SpdyHeaderBlock& /*promise_request*/,
+    const SpdyHeaderBlock& /*promise_response*/) {
   return true;
 }