diff --git a/quic/core/batch_writer/quic_batch_writer_base.h b/quic/core/batch_writer/quic_batch_writer_base.h
index 0ba8113..2723f55 100644
--- a/quic/core/batch_writer/quic_batch_writer_base.h
+++ b/quic/core/batch_writer/quic_batch_writer_base.h
@@ -39,17 +39,17 @@
   void SetWritable() final { write_blocked_ = false; }
 
   QuicByteCount GetMaxPacketSize(
-      const QuicSocketAddress& peer_address) const final {
+      const QuicSocketAddress& /*peer_address*/) const final {
     return kMaxOutgoingPacketSize;
   }
 
-  bool SupportsReleaseTime() const { return false; }
+  bool SupportsReleaseTime() const override { return false; }
 
   bool IsBatchMode() const final { return true; }
 
   QuicPacketBuffer GetNextWriteLocation(
-      const QuicIpAddress& self_address,
-      const QuicSocketAddress& peer_address) final {
+      const QuicIpAddress& /*self_address*/,
+      const QuicSocketAddress& /*peer_address*/) final {
     // No need to explicitly delete QuicBatchWriterBuffer.
     return {batch_buffer_->GetNextWriteLocation(), nullptr};
   }
diff --git a/quic/core/batch_writer/quic_batch_writer_buffer.cc b/quic/core/batch_writer/quic_batch_writer_buffer.cc
index 6226139..893b501 100644
--- a/quic/core/batch_writer/quic_batch_writer_buffer.cc
+++ b/quic/core/batch_writer/quic_batch_writer_buffer.cc
@@ -39,7 +39,7 @@
     next_buffer += iter->buf_len;
   }
 
-  return (next_buffer - buffer_) == SizeInUse();
+  return static_cast<size_t>(next_buffer - buffer_) == SizeInUse();
 }
 
 char* QuicBatchWriterBuffer::GetNextWriteLocation() const {
@@ -47,7 +47,7 @@
       buffered_writes_.empty()
           ? buffer_
           : buffered_writes_.back().buffer + buffered_writes_.back().buf_len;
-  if (buffer_end() - next_loc < kMaxOutgoingPacketSize) {
+  if (static_cast<size_t>(buffer_end() - next_loc) < kMaxOutgoingPacketSize) {
     return nullptr;
   }
   return const_cast<char*>(next_loc);
@@ -107,7 +107,7 @@
     int32_t num_buffered_writes) {
   DCHECK(Invariants());
   DCHECK_GE(num_buffered_writes, 0);
-  DCHECK_LE(num_buffered_writes, buffered_writes_.size());
+  DCHECK_LE(static_cast<size_t>(num_buffered_writes), buffered_writes_.size());
 
   PopResult result = {/*num_buffers_popped=*/0,
                       /*moved_remaining_buffers=*/false};
diff --git a/quic/core/batch_writer/quic_batch_writer_buffer.h b/quic/core/batch_writer/quic_batch_writer_buffer.h
index a441ec3..b55e63c 100644
--- a/quic/core/batch_writer/quic_batch_writer_buffer.h
+++ b/quic/core/batch_writer/quic_batch_writer_buffer.h
@@ -85,7 +85,7 @@
  protected:
   // Whether the invariants of the buffer are upheld. For debug & test only.
   bool Invariants() const;
-  const char* const buffer_end() const { return buffer_ + sizeof(buffer_); }
+  const char* buffer_end() const { return buffer_ + sizeof(buffer_); }
   QUIC_CACHELINE_ALIGNED char buffer_[kBufferSize];
   QuicCircularDeque<BufferedWrite> buffered_writes_;
 };
diff --git a/quic/core/batch_writer/quic_batch_writer_buffer_test.cc b/quic/core/batch_writer/quic_batch_writer_buffer_test.cc
index 4cdb747..4d9a46b 100644
--- a/quic/core/batch_writer/quic_batch_writer_buffer_test.cc
+++ b/quic/core/batch_writer/quic_batch_writer_buffer_test.cc
@@ -207,10 +207,11 @@
                                         release_time_)
                     .succeeded);
   }
-  EXPECT_EQ(kNumBufferedWrites, batch_buffer_->buffered_writes().size());
+  EXPECT_EQ(kNumBufferedWrites,
+            static_cast<int>(batch_buffer_->buffered_writes().size()));
 
   auto pop_result = batch_buffer_->PopBufferedWrite(kNumBufferedWrites);
-  EXPECT_EQ(0, batch_buffer_->buffered_writes().size());
+  EXPECT_EQ(0u, batch_buffer_->buffered_writes().size());
   EXPECT_EQ(kNumBufferedWrites, pop_result.num_buffers_popped);
   EXPECT_FALSE(pop_result.moved_remaining_buffers);
 }
@@ -225,7 +226,7 @@
                     .succeeded);
   }
 
-  for (int i = 0;
+  for (size_t i = 0;
        i < kNumBufferedWrites && !batch_buffer_->buffered_writes().empty();
        ++i) {
     const size_t size_before_pop = batch_buffer_->buffered_writes().size();
@@ -237,7 +238,7 @@
         'A' + kNumBufferedWrites - expect_size_after_pop;
     const size_t first_write_len =
         kDefaultMaxPacketSize - kNumBufferedWrites + expect_size_after_pop;
-    for (int j = 0; j < expect_size_after_pop; ++j) {
+    for (size_t j = 0; j < expect_size_after_pop; ++j) {
       CheckBufferedWriteContent(j, first_write_content + j, first_write_len - j,
                                 self_addr_, peer_addr_, nullptr);
     }
diff --git a/quic/core/batch_writer/quic_batch_writer_test.h b/quic/core/batch_writer/quic_batch_writer_test.h
index b4f36b9..adbcdc2 100644
--- a/quic/core/batch_writer/quic_batch_writer_test.h
+++ b/quic/core/batch_writer/quic_batch_writer_test.h
@@ -8,6 +8,7 @@
 #include <sys/socket.h>
 #include <sys/types.h>
 
+#include <cstddef>
 #include <iostream>
 #include <utility>
 
@@ -76,7 +77,7 @@
  public:
   virtual ~QuicUdpBatchWriterIOTestDelegate() {}
 
-  virtual bool ShouldSkip(const QuicUdpBatchWriterIOTestParams& params) {
+  virtual bool ShouldSkip(const QuicUdpBatchWriterIOTestParams& /*params*/) {
     return false;
   }
 
@@ -184,10 +185,10 @@
     char this_packet_content = '\0';
     int this_packet_size;
     int num_writes = 0;
-    int bytes_flushed = 0;
+    size_t bytes_flushed = 0;
     WriteResult result;
 
-    for (int bytes_sent = 0; bytes_sent < data_size_;
+    for (size_t bytes_sent = 0; bytes_sent < data_size_;
          bytes_sent += this_packet_size, ++this_packet_content) {
       this_packet_size = std::min(packet_size_, data_size_ - bytes_sent);
       memset(&packet_buffer_[0], this_packet_content, this_packet_size);
@@ -220,7 +221,7 @@
     char this_packet_content = '\0';
     int this_packet_size;
     int packets_received = 0;
-    for (int bytes_received = 0; bytes_received < data_size_;
+    for (size_t bytes_received = 0; bytes_received < data_size_;
          bytes_received += this_packet_size, ++this_packet_content) {
       this_packet_size = std::min(packet_size_, data_size_ - bytes_received);
       SCOPED_TRACE(testing::Message()
@@ -261,8 +262,8 @@
   char packet_buffer_[1500];
   char control_buffer_[kDefaultUdpPacketControlBufferSize];
   int address_family_;
-  const int data_size_;
-  const int packet_size_;
+  const size_t data_size_;
+  const size_t packet_size_;
   int self_socket_;
   int peer_socket_;
 };
diff --git a/quic/core/batch_writer/quic_gso_batch_writer.cc b/quic/core/batch_writer/quic_gso_batch_writer.cc
index fd023ae..95db178 100644
--- a/quic/core/batch_writer/quic_gso_batch_writer.cc
+++ b/quic/core/batch_writer/quic_gso_batch_writer.cc
@@ -38,7 +38,7 @@
     std::unique_ptr<QuicBatchWriterBuffer> batch_buffer,
     int fd,
     clockid_t clockid_for_release_time,
-    ReleaseTimeForceEnabler enabler)
+    ReleaseTimeForceEnabler /*enabler*/)
     : QuicUdpBatchWriter(std::move(batch_buffer), fd),
       clockid_for_release_time_(clockid_for_release_time),
       supports_release_time_(true) {
@@ -46,7 +46,7 @@
 }
 
 QuicGsoBatchWriter::CanBatchResult QuicGsoBatchWriter::CanBatch(
-    const char* buffer,
+    const char* /*buffer*/,
     size_t buf_len,
     const QuicIpAddress& self_address,
     const QuicSocketAddress& peer_address,
diff --git a/quic/core/batch_writer/quic_gso_batch_writer_test.cc b/quic/core/batch_writer/quic_gso_batch_writer_test.cc
index d202c67..bc075b2 100644
--- a/quic/core/batch_writer/quic_gso_batch_writer_test.cc
+++ b/quic/core/batch_writer/quic_gso_batch_writer_test.cc
@@ -199,7 +199,7 @@
   const QuicSocketAddress peer_addr;
   std::vector<BatchCriteriaTestData> test_data_table;
   size_t max_segments = TestQuicGsoBatchWriter::MaxSegments(gso_size);
-  for (int i = 0; i < max_segments; ++i) {
+  for (size_t i = 0; i < max_segments; ++i) {
     bool is_last_in_batch = (i + 1 == max_segments);
     test_data_table.push_back({gso_size, self_addr, peer_addr,
                                /*release_time=*/0, true, is_last_in_batch});
@@ -282,7 +282,7 @@
   ASSERT_EQ(WriteResult(WRITE_STATUS_OK, 0), WritePacket(&writer, 1000));
 
   EXPECT_CALL(mock_syscalls_, Sendmsg(_, _, _))
-      .WillOnce(Invoke([](int sockfd, const msghdr* msg, int flags) {
+      .WillOnce(Invoke([](int /*sockfd*/, const msghdr* msg, int /*flags*/) {
         EXPECT_EQ(1100u, PacketLength(msg));
         return 1100;
       }));
@@ -299,7 +299,7 @@
   ASSERT_EQ(WriteResult(WRITE_STATUS_OK, 0), WritePacket(&writer, 100));
 
   EXPECT_CALL(mock_syscalls_, Sendmsg(_, _, _))
-      .WillOnce(Invoke([](int sockfd, const msghdr* msg, int flags) {
+      .WillOnce(Invoke([](int /*sockfd*/, const msghdr* msg, int /*flags*/) {
         EXPECT_EQ(200u, PacketLength(msg));
         errno = EWOULDBLOCK;
         return -1;
@@ -318,7 +318,7 @@
   ASSERT_EQ(WriteResult(WRITE_STATUS_OK, 0), WritePacket(&writer, 100));
 
   EXPECT_CALL(mock_syscalls_, Sendmsg(_, _, _))
-      .WillOnce(Invoke([](int sockfd, const msghdr* msg, int flags) {
+      .WillOnce(Invoke([](int /*sockfd*/, const msghdr* msg, int /*flags*/) {
         EXPECT_EQ(250u, PacketLength(msg));
         errno = EWOULDBLOCK;
         return -1;
@@ -337,7 +337,7 @@
   ASSERT_EQ(WriteResult(WRITE_STATUS_OK, 0), WritePacket(&writer, 100));
 
   EXPECT_CALL(mock_syscalls_, Sendmsg(_, _, _))
-      .WillOnce(Invoke([](int sockfd, const msghdr* msg, int flags) {
+      .WillOnce(Invoke([](int /*sockfd*/, const msghdr* msg, int /*flags*/) {
         EXPECT_EQ(200u, PacketLength(msg));
         errno = EPERM;
         return -1;
@@ -358,7 +358,7 @@
   ASSERT_EQ(WriteResult(WRITE_STATUS_OK, 0), WritePacket(&writer, 100));
 
   EXPECT_CALL(mock_syscalls_, Sendmsg(_, _, _))
-      .WillOnce(Invoke([](int sockfd, const msghdr* msg, int flags) {
+      .WillOnce(Invoke([](int /*sockfd*/, const msghdr* msg, int /*flags*/) {
         EXPECT_EQ(250u, PacketLength(msg));
         errno = EPERM;
         return -1;
@@ -379,7 +379,7 @@
   ASSERT_EQ(WriteResult(WRITE_STATUS_OK, 0), WritePacket(&writer, 100));
 
   EXPECT_CALL(mock_syscalls_, Sendmsg(_, _, _))
-      .WillOnce(Invoke([](int sockfd, const msghdr* msg, int flags) {
+      .WillOnce(Invoke([](int /*sockfd*/, const msghdr* msg, int /*flags*/) {
         EXPECT_EQ(200u, PacketLength(msg));
         errno = EINVAL;
         return -1;
@@ -394,7 +394,7 @@
 
 TEST_F(QuicGsoBatchWriterTest, ReleaseTimeNullOptions) {
   auto writer = TestQuicGsoBatchWriter::NewInstanceWithReleaseTimeSupport();
-  EXPECT_EQ(0, writer->GetReleaseTime(nullptr).actual_release_time);
+  EXPECT_EQ(0u, writer->GetReleaseTime(nullptr).actual_release_time);
 }
 
 TEST_F(QuicGsoBatchWriterTest, ReleaseTime) {
@@ -425,7 +425,7 @@
   // The 3rd packet has more delay and does not allow burst.
   // The first 2 packets are flushed due to different release time.
   EXPECT_CALL(mock_syscalls_, Sendmsg(_, _, _))
-      .WillOnce(Invoke([](int sockfd, const msghdr* msg, int flags) {
+      .WillOnce(Invoke([](int /*sockfd*/, const msghdr* msg, int /*flags*/) {
         EXPECT_EQ(2700u, PacketLength(msg));
         errno = 0;
         return 0;
@@ -447,7 +447,7 @@
   // The 5th packet has same delay, allows burst, but is shorter.
   // Packets 3,4 and 5 are flushed.
   EXPECT_CALL(mock_syscalls_, Sendmsg(_, _, _))
-      .WillOnce(Invoke([](int sockfd, const msghdr* msg, int flags) {
+      .WillOnce(Invoke([](int /*sockfd*/, const msghdr* msg, int /*flags*/) {
         EXPECT_EQ(3000u, PacketLength(msg));
         errno = 0;
         return 0;
diff --git a/quic/core/batch_writer/quic_sendmmsg_batch_writer.cc b/quic/core/batch_writer/quic_sendmmsg_batch_writer.cc
index efd2179..c0909a6 100644
--- a/quic/core/batch_writer/quic_sendmmsg_batch_writer.cc
+++ b/quic/core/batch_writer/quic_sendmmsg_batch_writer.cc
@@ -12,12 +12,12 @@
     : QuicUdpBatchWriter(std::move(batch_buffer), fd) {}
 
 QuicSendmmsgBatchWriter::CanBatchResult QuicSendmmsgBatchWriter::CanBatch(
-    const char* buffer,
-    size_t buf_len,
-    const QuicIpAddress& self_address,
-    const QuicSocketAddress& peer_address,
-    const PerPacketOptions* options,
-    uint64_t release_time) const {
+    const char* /*buffer*/,
+    size_t /*buf_len*/,
+    const QuicIpAddress& /*self_address*/,
+    const QuicSocketAddress& /*peer_address*/,
+    const PerPacketOptions* /*options*/,
+    uint64_t /*release_time*/) const {
   return CanBatchResult(/*can_batch=*/true, /*must_flush=*/false);
 }