diff --git a/quiche/quic/core/chlo_extractor_test.cc b/quiche/quic/core/chlo_extractor_test.cc
index c0e391d..8a56b3a 100644
--- a/quiche/quic/core/chlo_extractor_test.cc
+++ b/quiche/quic/core/chlo_extractor_test.cc
@@ -4,6 +4,7 @@
 
 #include "quiche/quic/core/chlo_extractor.h"
 
+#include <iterator>
 #include <memory>
 #include <string>
 #include <utility>
@@ -95,7 +96,7 @@
     EXPECT_TRUE(packet != nullptr);
     size_t encrypted_length =
         framer.EncryptPayload(ENCRYPTION_INITIAL, header.packet_number, *packet,
-                              buffer_, ABSL_ARRAYSIZE(buffer_));
+                              buffer_, std::size(buffer_));
     ASSERT_NE(0u, encrypted_length);
     packet_ = std::make_unique<QuicEncryptedPacket>(buffer_, encrypted_length);
     EXPECT_TRUE(packet_ != nullptr);
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index 2639ded..73e0ca7 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <cstdint>
+#include <iterator>
 #include <memory>
 #include <optional>
 #include <string>
@@ -10689,13 +10690,13 @@
   size_t retry_packet_length;
   if (version() == ParsedQuicVersion::RFCv2()) {
     retry_packet = retry_packet_rfcv2;
-    retry_packet_length = ABSL_ARRAYSIZE(retry_packet_rfcv2);
+    retry_packet_length = std::size(retry_packet_rfcv2);
   } else if (version() == ParsedQuicVersion::RFCv1()) {
     retry_packet = retry_packet_rfcv1;
-    retry_packet_length = ABSL_ARRAYSIZE(retry_packet_rfcv1);
+    retry_packet_length = std::size(retry_packet_rfcv1);
   } else if (version() == ParsedQuicVersion::Draft29()) {
     retry_packet = retry_packet29;
-    retry_packet_length = ABSL_ARRAYSIZE(retry_packet29);
+    retry_packet_length = std::size(retry_packet29);
   } else {
     // TODO(dschinazi) generate retry packets for all versions once we have
     // server-side support for generating these programmatically.
@@ -10710,13 +10711,13 @@
 
   QuicConnectionId original_connection_id(
       reinterpret_cast<char*>(original_connection_id_bytes),
-      ABSL_ARRAYSIZE(original_connection_id_bytes));
+      std::size(original_connection_id_bytes));
   QuicConnectionId new_connection_id(
       reinterpret_cast<char*>(new_connection_id_bytes),
-      ABSL_ARRAYSIZE(new_connection_id_bytes));
+      std::size(new_connection_id_bytes));
 
   std::string retry_token(reinterpret_cast<char*>(retry_token_bytes),
-                          ABSL_ARRAYSIZE(retry_token_bytes));
+                          std::size(retry_token_bytes));
 
   if (invalid_retry_tag) {
     // Flip the last bit of the retry packet to prevent the integrity tag
diff --git a/quiche/quic/core/quic_crypto_client_stream_test.cc b/quiche/quic/core/quic_crypto_client_stream_test.cc
index 7b5ab9f..d8317bc 100644
--- a/quiche/quic/core/quic_crypto_client_stream_test.cc
+++ b/quiche/quic/core/quic_crypto_client_stream_test.cc
@@ -4,6 +4,7 @@
 
 #include "quiche/quic/core/quic_crypto_client_stream.h"
 
+#include <iterator>
 #include <memory>
 #include <string>
 #include <utility>
@@ -270,7 +271,7 @@
   const std::string& cached_scfg = state->server_config();
   quiche::test::CompareCharArraysWithHexError(
       "scfg", cached_scfg.data(), cached_scfg.length(),
-      reinterpret_cast<char*>(scfg), ABSL_ARRAYSIZE(scfg));
+      reinterpret_cast<char*>(scfg), std::size(scfg));
 
   QuicStreamSequencer* sequencer = QuicStreamPeer::sequencer(stream());
   EXPECT_FALSE(QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(sequencer));
diff --git a/quiche/quic/core/quic_data_writer_test.cc b/quiche/quic/core/quic_data_writer_test.cc
index 40262d0..836556c 100644
--- a/quiche/quic/core/quic_data_writer_test.cc
+++ b/quiche/quic/core/quic_data_writer_test.cc
@@ -6,6 +6,7 @@
 
 #include <cstdint>
 #include <cstring>
+#include <iterator>
 #include <string>
 #include <vector>
 
@@ -268,7 +269,7 @@
   char big_endian[] = {
       0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
   };
-  EXPECT_EQ(connection_id.length(), ABSL_ARRAYSIZE(big_endian));
+  EXPECT_EQ(connection_id.length(), std::size(big_endian));
   ASSERT_LE(connection_id.length(), 255);
   char buffer[255];
   QuicDataWriter writer(connection_id.length(), buffer, GetParam().endianness);
@@ -280,7 +281,7 @@
   QuicConnectionId read_connection_id;
   QuicDataReader reader(buffer, connection_id.length(), GetParam().endianness);
   EXPECT_TRUE(
-      reader.ReadConnectionId(&read_connection_id, ABSL_ARRAYSIZE(big_endian)));
+      reader.ReadConnectionId(&read_connection_id, std::size(big_endian)));
   EXPECT_EQ(connection_id, read_connection_id);
 }
 
@@ -290,35 +291,33 @@
   char length_prefixed_connection_id[] = {
       0x08, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
   };
-  EXPECT_EQ(ABSL_ARRAYSIZE(length_prefixed_connection_id),
+  EXPECT_EQ(std::size(length_prefixed_connection_id),
             kConnectionIdLengthSize + connection_id.length());
   char buffer[kConnectionIdLengthSize + 255] = {};
-  QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer);
+  QuicDataWriter writer(std::size(buffer), buffer);
   EXPECT_TRUE(writer.WriteLengthPrefixedConnectionId(connection_id));
   quiche::test::CompareCharArraysWithHexError(
       "WriteLengthPrefixedConnectionId", buffer, writer.length(),
-      length_prefixed_connection_id,
-      ABSL_ARRAYSIZE(length_prefixed_connection_id));
+      length_prefixed_connection_id, std::size(length_prefixed_connection_id));
 
   // Verify that writing length then connection ID produces the same output.
-  memset(buffer, 0, ABSL_ARRAYSIZE(buffer));
-  QuicDataWriter writer2(ABSL_ARRAYSIZE(buffer), buffer);
+  memset(buffer, 0, std::size(buffer));
+  QuicDataWriter writer2(std::size(buffer), buffer);
   EXPECT_TRUE(writer2.WriteUInt8(connection_id.length()));
   EXPECT_TRUE(writer2.WriteConnectionId(connection_id));
   quiche::test::CompareCharArraysWithHexError(
       "Write length then ConnectionId", buffer, writer2.length(),
-      length_prefixed_connection_id,
-      ABSL_ARRAYSIZE(length_prefixed_connection_id));
+      length_prefixed_connection_id, std::size(length_prefixed_connection_id));
 
   QuicConnectionId read_connection_id;
-  QuicDataReader reader(buffer, ABSL_ARRAYSIZE(buffer));
+  QuicDataReader reader(buffer, std::size(buffer));
   EXPECT_TRUE(reader.ReadLengthPrefixedConnectionId(&read_connection_id));
   EXPECT_EQ(connection_id, read_connection_id);
 
   // Verify that reading length then connection ID produces the same output.
   uint8_t read_connection_id_length2 = 33;
   QuicConnectionId read_connection_id2;
-  QuicDataReader reader2(buffer, ABSL_ARRAYSIZE(buffer));
+  QuicDataReader reader2(buffer, std::size(buffer));
   ASSERT_TRUE(reader2.ReadUInt8(&read_connection_id_length2));
   EXPECT_EQ(connection_id.length(), read_connection_id_length2);
   EXPECT_TRUE(reader2.ReadConnectionId(&read_connection_id2,
@@ -329,7 +328,7 @@
 TEST_P(QuicDataWriterTest, EmptyConnectionIds) {
   QuicConnectionId empty_connection_id = EmptyQuicConnectionId();
   char buffer[2];
-  QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer, GetParam().endianness);
+  QuicDataWriter writer(std::size(buffer), buffer, GetParam().endianness);
   EXPECT_TRUE(writer.WriteConnectionId(empty_connection_id));
   EXPECT_TRUE(writer.WriteUInt8(1));
   EXPECT_TRUE(writer.WriteConnectionId(empty_connection_id));
@@ -342,7 +341,7 @@
 
   QuicConnectionId read_connection_id = TestConnectionId();
   uint8_t read_byte;
-  QuicDataReader reader(buffer, ABSL_ARRAYSIZE(buffer), GetParam().endianness);
+  QuicDataReader reader(buffer, std::size(buffer), GetParam().endianness);
   EXPECT_TRUE(reader.ReadConnectionId(&read_connection_id, 0));
   EXPECT_EQ(read_connection_id, empty_connection_id);
   EXPECT_TRUE(reader.ReadUInt8(&read_byte));
@@ -660,10 +659,10 @@
 
 TEST_P(QuicDataWriterTest, WriteBytes) {
   char bytes[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
-  char buf[ABSL_ARRAYSIZE(bytes)];
-  QuicDataWriter writer(ABSL_ARRAYSIZE(buf), buf, GetParam().endianness);
-  EXPECT_TRUE(writer.WriteBytes(bytes, ABSL_ARRAYSIZE(bytes)));
-  for (unsigned int i = 0; i < ABSL_ARRAYSIZE(bytes); ++i) {
+  char buf[std::size(bytes)];
+  QuicDataWriter writer(std::size(buf), buf, GetParam().endianness);
+  EXPECT_TRUE(writer.WriteBytes(bytes, std::size(bytes)));
+  for (unsigned int i = 0; i < std::size(bytes); ++i) {
     EXPECT_EQ(bytes[i], buf[i]);
   }
 }
@@ -786,13 +785,13 @@
 
 TEST_P(QuicDataWriterTest, Seek) {
   char buffer[3] = {};
-  QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer, GetParam().endianness);
+  QuicDataWriter writer(std::size(buffer), buffer, GetParam().endianness);
   EXPECT_TRUE(writer.WriteUInt8(42));
   EXPECT_TRUE(writer.Seek(1));
   EXPECT_TRUE(writer.WriteUInt8(3));
 
   char expected[] = {42, 0, 3};
-  for (size_t i = 0; i < ABSL_ARRAYSIZE(expected); ++i) {
+  for (size_t i = 0; i < std::size(expected); ++i) {
     EXPECT_EQ(buffer[i], expected[i]);
   }
 }
@@ -802,23 +801,20 @@
 
   // Check that one can seek to the end of the writer, but not past.
   {
-    QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer,
-                          GetParam().endianness);
+    QuicDataWriter writer(std::size(buffer), buffer, GetParam().endianness);
     EXPECT_TRUE(writer.Seek(20));
     EXPECT_FALSE(writer.Seek(1));
   }
 
   // Seeking several bytes past the end fails.
   {
-    QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer,
-                          GetParam().endianness);
+    QuicDataWriter writer(std::size(buffer), buffer, GetParam().endianness);
     EXPECT_FALSE(writer.Seek(100));
   }
 
   // Seeking so far that arithmetic overflow could occur also fails.
   {
-    QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer,
-                          GetParam().endianness);
+    QuicDataWriter writer(std::size(buffer), buffer, GetParam().endianness);
     EXPECT_TRUE(writer.Seek(10));
     EXPECT_FALSE(writer.Seek(std::numeric_limits<size_t>::max()));
   }
diff --git a/quiche/quic/core/quic_dispatcher_test.cc b/quiche/quic/core/quic_dispatcher_test.cc
index 859408f..9e83738 100644
--- a/quiche/quic/core/quic_dispatcher_test.cc
+++ b/quiche/quic/core/quic_dispatcher_test.cc
@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
+#include <iterator>
 #include <list>
 #include <map>
 #include <memory>
@@ -1519,7 +1520,7 @@
   uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
       0xC0, 0xFF, 0x00, 0x00, 28, /*destination connection ID length*/ 0x08};
   QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
-                                     ABSL_ARRAYSIZE(packet), QuicTime::Zero());
+                                     std::size(packet), QuicTime::Zero());
   EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _, _)).Times(0);
   EXPECT_CALL(*time_wait_list_manager_,
               SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
@@ -1535,7 +1536,7 @@
   uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
       0xC0, 0xFF, 0x00, 0x00, 27, /*destination connection ID length*/ 0x08};
   QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
-                                     ABSL_ARRAYSIZE(packet), QuicTime::Zero());
+                                     std::size(packet), QuicTime::Zero());
   EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _, _)).Times(0);
   EXPECT_CALL(*time_wait_list_manager_,
               SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
@@ -1551,7 +1552,7 @@
   uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
       0xC0, 0xFF, 0x00, 0x00, 25, /*destination connection ID length*/ 0x08};
   QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
-                                     ABSL_ARRAYSIZE(packet), QuicTime::Zero());
+                                     std::size(packet), QuicTime::Zero());
   EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _, _)).Times(0);
   EXPECT_CALL(*time_wait_list_manager_,
               SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
@@ -1567,7 +1568,7 @@
   uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
       0xC0, 'T', '0', '5', '0', /*destination connection ID length*/ 0x08};
   QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
-                                     ABSL_ARRAYSIZE(packet), QuicTime::Zero());
+                                     std::size(packet), QuicTime::Zero());
   EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _, _)).Times(0);
   EXPECT_CALL(*time_wait_list_manager_,
               SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
@@ -1583,7 +1584,7 @@
   uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
       0xC0, 'Q', '0', '4', '9', /*destination connection ID length*/ 0x08};
   QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
-                                     ABSL_ARRAYSIZE(packet), QuicTime::Zero());
+                                     std::size(packet), QuicTime::Zero());
   EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _, _)).Times(0);
   EXPECT_CALL(*time_wait_list_manager_,
               SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
@@ -1599,7 +1600,7 @@
   uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
       0xC0, 'Q', '0', '4', '8', /*connection ID length byte*/ 0x50};
   QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
-                                     ABSL_ARRAYSIZE(packet), QuicTime::Zero());
+                                     std::size(packet), QuicTime::Zero());
   EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _, _)).Times(0);
   EXPECT_CALL(
       *time_wait_list_manager_,
@@ -1616,7 +1617,7 @@
   uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
       0xC0, 'Q', '0', '4', '7', /*connection ID length byte*/ 0x50};
   QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
-                                     ABSL_ARRAYSIZE(packet), QuicTime::Zero());
+                                     std::size(packet), QuicTime::Zero());
   EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _, _)).Times(0);
   EXPECT_CALL(
       *time_wait_list_manager_,
@@ -1633,7 +1634,7 @@
   uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
       0xC0, 'Q', '0', '4', '5', /*connection ID length byte*/ 0x50};
   QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
-                                     ABSL_ARRAYSIZE(packet), QuicTime::Zero());
+                                     std::size(packet), QuicTime::Zero());
   EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _, _)).Times(0);
   EXPECT_CALL(
       *time_wait_list_manager_,
diff --git a/quiche/quic/core/quic_framer_test.cc b/quiche/quic/core/quic_framer_test.cc
index cb94335..0ceec4e 100644
--- a/quiche/quic/core/quic_framer_test.cc
+++ b/quiche/quic/core/quic_framer_test.cc
@@ -6,6 +6,7 @@
 
 #include <cstdint>
 #include <cstring>
+#include <iterator>
 #include <limits>
 #include <memory>
 #include <optional>
@@ -1151,7 +1152,7 @@
 
   memset(packet + header_size, 0, kMaxIncomingPacketSize - header_size);
 
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 
   ASSERT_TRUE(visitor_.header_.get());
@@ -1274,11 +1275,11 @@
   // clang-format on
 
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     ReviseFirstByteByVersion(packet49);
     p = packet49;
-    p_length = ABSL_ARRAYSIZE(packet49);
+    p_length = std::size(packet49);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -1309,7 +1310,7 @@
 
 TEST_P(QuicFramerTest, AllZeroPacketParsingFails) {
   unsigned char packet[1200] = {};
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   PacketHeaderFormat format = GOOGLE_QUIC_Q043_PACKET;
   QuicLongHeaderType long_packet_type = INVALID_PACKET_TYPE;
   bool version_flag = false;
@@ -1368,11 +1369,11 @@
   };
   // clang-format on
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     ReviseFirstByteByVersion(packet49);
     p = packet49;
-    p_length = ABSL_ARRAYSIZE(packet49);
+    p_length = std::size(packet49);
   }
 
   uint8_t first_byte = 0x33;
@@ -1436,7 +1437,7 @@
   };
   // clang-format on
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
 
   uint8_t first_byte = 0x33;
   PacketHeaderFormat format = GOOGLE_QUIC_Q043_PACKET;
@@ -1689,7 +1690,7 @@
     0x00,
   };
   // clang-format on
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_THAT(framer_.error(), IsQuicNoError());
   EXPECT_EQ("", framer_.detailed_error());
@@ -1720,7 +1721,7 @@
     0x00,
   };
   // clang-format on
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_THAT(framer_.error(), IsQuicNoError());
   EXPECT_EQ("", framer_.detailed_error());
@@ -2116,10 +2117,10 @@
   }
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     p = packet49;
-    p_size = ABSL_ARRAYSIZE(packet49);
+    p_size = std::size(packet49);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -2204,16 +2205,16 @@
   switch (framer_.transport_version()) {
     case QUIC_VERSION_46:
       p = old_packet;
-      p_size = ABSL_ARRAYSIZE(old_packet);
+      p_size = std::size(old_packet);
       break;
     case QUIC_VERSION_IETF_DRAFT_29:
     case QUIC_VERSION_IETF_RFC_V1:
       p = packetv2;
-      p_size = ABSL_ARRAYSIZE(packetv2);
+      p_size = std::size(packetv2);
       break;
     case QUIC_VERSION_IETF_RFC_V2:
       p = packetv1;
-      p_size = ABSL_ARRAYSIZE(packetv1);
+      p_size = std::size(packetv1);
       break;
     default:
       p = packetv2;  // To silence warnings.
@@ -2307,10 +2308,10 @@
   // clang-format on
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -2530,10 +2531,10 @@
   // clang-format on
 
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     p = packet49;
-    p_length = ABSL_ARRAYSIZE(packet49);
+    p_length = std::size(packet49);
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
@@ -2913,7 +2914,7 @@
   };
   // clang-format on
 
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -2940,7 +2941,7 @@
   };
   // clang-format on
 
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -4141,7 +4142,7 @@
     // ACK Timestamp is not a feature of IETF QUIC.
     return;
   }
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_TRUE(absl::StartsWith(framer_.detailed_error(),
                                "delta_from_largest_observed too high"));
@@ -4183,7 +4184,7 @@
     // ACK Timestamp is not a feature of IETF QUIC.
     return;
   }
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_TRUE(absl::StartsWith(framer_.detailed_error(),
                                "delta_from_largest_observed too high"));
@@ -4254,7 +4255,7 @@
   };
   // clang-format on
 
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_STOP_WAITING_DATA));
   EXPECT_EQ("Invalid unacked delta.", framer_.detailed_error());
@@ -5098,9 +5099,8 @@
   QuicEncryptedPacket encrypted(
       AsChars(VersionIsIetfQuic(framer_.transport_version()) ? packet_ietf
                                                              : packet),
-      VersionIsIetfQuic(framer_.transport_version())
-          ? ABSL_ARRAYSIZE(packet_ietf)
-          : ABSL_ARRAYSIZE(packet),
+      VersionIsIetfQuic(framer_.transport_version()) ? std::size(packet_ietf)
+                                                     : std::size(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
@@ -5135,7 +5135,7 @@
     return;
   }
 
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -5175,7 +5175,7 @@
     return;
   }
 
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -5212,7 +5212,7 @@
     return;
   }
 
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -5253,7 +5253,7 @@
   }
   framer_.set_process_reset_stream_at(true);
 
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -5299,7 +5299,7 @@
   }
   framer_.set_process_reset_stream_at(true);
 
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(framer_.error(), QUIC_INVALID_FRAME_DATA);
   EXPECT_EQ(visitor_.reset_stream_at_frames_.size(), 0);
@@ -5417,7 +5417,7 @@
         ENCRYPTION_ZERO_RTT, std::unique_ptr<QuicDecrypter>(decrypter_), false);
   }
   // This packet cannot be decrypted because diversification nonce is missing.
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   ASSERT_THAT(framer_.error(), IsQuicNoError());
 }
@@ -5452,7 +5452,7 @@
         ENCRYPTION_ZERO_RTT, std::unique_ptr<QuicDecrypter>(decrypter_), false);
   }
   // This packet cannot be decrypted because diversification nonce is missing.
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_THAT(framer_.error(), IsError(QUIC_DECRYPTION_FAILURE));
 }
@@ -5552,10 +5552,10 @@
   };
   // clang-format on
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     p = packet2;
-    p_length = ABSL_ARRAYSIZE(packet2);
+    p_length = std::size(packet2);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -5629,14 +5629,14 @@
   // clang-format on
 
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     ReviseFirstByteByVersion(packet_with_tag);
     p = packet_with_tag;
-    p_length = ABSL_ARRAYSIZE(packet_with_tag);
+    p_length = std::size(packet_with_tag);
   } else if (framer_.version().IsIetfQuic()) {
     p = packet49;
-    p_length = ABSL_ARRAYSIZE(packet49);
+    p_length = std::size(packet49);
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -5658,7 +5658,7 @@
         "retry integrity tag", visitor_.retry_token_integrity_tag_->data(),
         visitor_.retry_token_integrity_tag_->length(),
         reinterpret_cast<const char*>(expected_integrity_tag),
-        ABSL_ARRAYSIZE(expected_integrity_tag));
+        std::size(expected_integrity_tag));
     ASSERT_TRUE(visitor_.retry_without_tag_.get());
     quiche::test::CompareCharArraysWithHexError(
         "retry without tag", visitor_.retry_without_tag_->data(),
@@ -5750,9 +5750,9 @@
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
-  quiche::test::CompareCharArraysWithHexError(
-      "constructed packet", data->data(), data->length(), AsChars(p),
-      ABSL_ARRAYSIZE(packet));
+  quiche::test::CompareCharArraysWithHexError("constructed packet",
+                                              data->data(), data->length(),
+                                              AsChars(p), std::size(packet));
 }
 
 TEST_P(QuicFramerTest, BuildStreamFramePacketWithNewPaddingFrame) {
@@ -5828,10 +5828,10 @@
   ASSERT_TRUE(data != nullptr);
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
 
@@ -5893,9 +5893,9 @@
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
-  quiche::test::CompareCharArraysWithHexError(
-      "constructed packet", data->data(), data->length(), AsChars(p),
-      ABSL_ARRAYSIZE(packet));
+  quiche::test::CompareCharArraysWithHexError("constructed packet",
+                                              data->data(), data->length(),
+                                              AsChars(p), std::size(packet));
 }
 
 TEST_P(QuicFramerTest, Build2ByteSequenceNumberPaddingFramePacket) {
@@ -5952,9 +5952,9 @@
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
-  quiche::test::CompareCharArraysWithHexError(
-      "constructed packet", data->data(), data->length(), AsChars(p),
-      ABSL_ARRAYSIZE(packet));
+  quiche::test::CompareCharArraysWithHexError("constructed packet",
+                                              data->data(), data->length(),
+                                              AsChars(p), std::size(packet));
 }
 
 TEST_P(QuicFramerTest, Build1ByteSequenceNumberPaddingFramePacket) {
@@ -6011,9 +6011,9 @@
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
-  quiche::test::CompareCharArraysWithHexError(
-      "constructed packet", data->data(), data->length(), AsChars(p),
-      ABSL_ARRAYSIZE(packet));
+  quiche::test::CompareCharArraysWithHexError("constructed packet",
+                                              data->data(), data->length(),
+                                              AsChars(p), std::size(packet));
 }
 
 TEST_P(QuicFramerTest, BuildStreamFramePacket) {
@@ -6080,10 +6080,10 @@
   ASSERT_TRUE(data != nullptr);
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p), p_size);
@@ -6185,14 +6185,14 @@
   ASSERT_TRUE(data != nullptr);
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     ReviseFirstByteByVersion(packet_ietf);
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   } else if (framer_.version().IsIetfQuic()) {
     p = packet49;
-    p_size = ABSL_ARRAYSIZE(packet49);
+    p_size = std::size(packet49);
   }
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p), p_size);
@@ -6265,10 +6265,10 @@
   // clang-format on
 
   unsigned char* packet = packet48;
-  size_t packet_size = ABSL_ARRAYSIZE(packet48);
+  size_t packet_size = std::size(packet48);
   if (framer_.version().IsIetfQuic()) {
     packet = packet_ietf;
-    packet_size = ABSL_ARRAYSIZE(packet_ietf);
+    packet_size = std::size(packet_ietf);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -6382,7 +6382,7 @@
           SupportedVersions(GetParam())));
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet),
-      ABSL_ARRAYSIZE(packet));
+      std::size(packet));
 }
 
 TEST_P(QuicFramerTest, BuildVersionNegotiationPacket) {
@@ -6418,10 +6418,10 @@
   };
   // clang-format on
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     p = packet49;
-    p_size = ABSL_ARRAYSIZE(packet49);
+    p_size = std::size(packet49);
   }
 
   QuicConnectionId connection_id = FramerTestConnectionId();
@@ -6466,7 +6466,7 @@
           SupportedVersions(GetParam())));
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet),
-      ABSL_ARRAYSIZE(packet));
+      std::size(packet));
 }
 
 TEST_P(QuicFramerTest, BuildAckFramePacketOneAckBlock) {
@@ -6526,10 +6526,10 @@
   };
   // clang-format on
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -6647,7 +6647,7 @@
   ASSERT_TRUE(data != nullptr);
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, BuildAckReceiveTimestampsFramePacketOutOfOrder) {
@@ -6748,7 +6748,7 @@
   ASSERT_TRUE(data != nullptr);
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, BuildAckReceiveTimestampsAndEcnFrame) {
@@ -6841,7 +6841,7 @@
   ASSERT_TRUE(data != nullptr);
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, BuildAckReceiveTimestampsFrameExceedsMaxTimestamps) {
@@ -6942,7 +6942,7 @@
   ASSERT_TRUE(data != nullptr);
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, BuildAckReceiveTimestampsFrameWithExponentEncoding) {
@@ -7050,7 +7050,7 @@
   ASSERT_TRUE(data != nullptr);
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, BuildAndProcessAckReceiveTimestampsWithMultipleRanges) {
@@ -7723,10 +7723,10 @@
   };
   // clang-format on
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -7829,10 +7829,10 @@
   };
   // clang-format on
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8042,10 +8042,10 @@
   };
   // clang-format on
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8117,10 +8117,10 @@
   ASSERT_TRUE(data != nullptr);
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
 
@@ -8188,10 +8188,10 @@
   // clang-format on
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8269,10 +8269,10 @@
   // clang-format on
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8398,10 +8398,10 @@
   // clang-format on
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8459,7 +8459,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, BuildTruncatedApplicationCloseFramePacket) {
@@ -8540,7 +8540,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, BuildGoAwayPacket) {
@@ -8592,7 +8592,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet),
-      ABSL_ARRAYSIZE(packet));
+      std::size(packet));
 }
 
 TEST_P(QuicFramerTest, BuildTruncatedGoAwayPacket) {
@@ -8672,7 +8672,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet),
-      ABSL_ARRAYSIZE(packet));
+      std::size(packet));
 }
 
 TEST_P(QuicFramerTest, BuildWindowUpdatePacket) {
@@ -8729,10 +8729,10 @@
   ASSERT_TRUE(data != nullptr);
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
 
   quiche::test::CompareCharArraysWithHexError(
@@ -8781,7 +8781,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, BuildMaxDataPacket) {
@@ -8825,7 +8825,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, BuildBlockedPacket) {
@@ -8884,10 +8884,10 @@
   ASSERT_TRUE(data != nullptr);
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
 
   quiche::test::CompareCharArraysWithHexError(
@@ -8938,9 +8938,9 @@
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
-  quiche::test::CompareCharArraysWithHexError(
-      "constructed packet", data->data(), data->length(), AsChars(p),
-      ABSL_ARRAYSIZE(packet));
+  quiche::test::CompareCharArraysWithHexError("constructed packet",
+                                              data->data(), data->length(),
+                                              AsChars(p), std::size(packet));
 }
 
 TEST_P(QuicFramerTest, BuildHandshakeDonePacket) {
@@ -8974,7 +8974,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet),
-      ABSL_ARRAYSIZE(packet));
+      std::size(packet));
 }
 
 TEST_P(QuicFramerTest, BuildAckFrequencyPacket) {
@@ -9022,7 +9022,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet),
-      ABSL_ARRAYSIZE(packet));
+      std::size(packet));
 }
 
 TEST_P(QuicFramerTest, BuildImmediateAckPacket) {
@@ -9057,7 +9057,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet),
-      ABSL_ARRAYSIZE(packet));
+      std::size(packet));
 }
 
 TEST_P(QuicFramerTest, BuildResetStreamAtPacket) {
@@ -9106,7 +9106,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet),
-      ABSL_ARRAYSIZE(packet));
+      std::size(packet));
 }
 
 TEST_P(QuicFramerTest, BuildDatagramPacket) {
@@ -9171,9 +9171,9 @@
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
-  quiche::test::CompareCharArraysWithHexError(
-      "constructed packet", data->data(), data->length(), AsChars(p),
-      ABSL_ARRAYSIZE(packet));
+  quiche::test::CompareCharArraysWithHexError("constructed packet",
+                                              data->data(), data->length(),
+                                              AsChars(p), std::size(packet));
 }
 
 // Test that the MTU discovery packet is serialized correctly as a PING packet.
@@ -9221,9 +9221,9 @@
     p = packet_ietf;
   }
 
-  quiche::test::CompareCharArraysWithHexError(
-      "constructed packet", data->data(), data->length(), AsChars(p),
-      ABSL_ARRAYSIZE(packet));
+  quiche::test::CompareCharArraysWithHexError("constructed packet",
+                                              data->data(), data->length(),
+                                              AsChars(p), std::size(packet));
 }
 
 TEST_P(QuicFramerTest, BuildPublicResetPacket) {
@@ -9256,7 +9256,7 @@
   ASSERT_TRUE(data != nullptr);
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet),
-      ABSL_ARRAYSIZE(packet));
+      std::size(packet));
 }
 
 TEST_P(QuicFramerTest, BuildPublicResetPacketWithClientAddress) {
@@ -9301,7 +9301,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet),
-      ABSL_ARRAYSIZE(packet));
+      std::size(packet));
 }
 
 TEST_P(QuicFramerTest, BuildPublicResetPacketWithEndpointId) {
@@ -9371,11 +9371,11 @@
   if ('d' == data->data()[data->length() - 1]) {
     quiche::test::CompareCharArraysWithHexError(
         "constructed packet", data->data(), data->length(),
-        AsChars(packet_variant1), ABSL_ARRAYSIZE(packet_variant1));
+        AsChars(packet_variant1), std::size(packet_variant1));
   } else {
     quiche::test::CompareCharArraysWithHexError(
         "constructed packet", data->data(), data->length(),
-        AsChars(packet_variant2), ABSL_ARRAYSIZE(packet_variant2));
+        AsChars(packet_variant2), std::size(packet_variant2));
   }
 }
 
@@ -9408,7 +9408,7 @@
       "constructed packet",
       data->data() + data->length() - kStatelessResetTokenLength,
       kStatelessResetTokenLength,
-      AsChars(packet) + ABSL_ARRAYSIZE(packet) - kStatelessResetTokenLength,
+      AsChars(packet) + std::size(packet) - kStatelessResetTokenLength,
       kStatelessResetTokenLength);
 
   // Packets with length <= minimal stateless reset does not trigger stateless
@@ -9464,7 +9464,7 @@
   // Verify the entire packet.
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet),
-      ABSL_ARRAYSIZE(packet));
+      std::size(packet));
 }
 
 TEST_P(QuicFramerTest, EncryptPacket) {
@@ -9503,10 +9503,10 @@
   // clang-format on
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     p = packet50;
-    p_size = ABSL_ARRAYSIZE(packet50);
+    p_size = std::size(packet50);
   }
 
   std::unique_ptr<QuicPacket> raw(new QuicPacket(
@@ -9590,11 +9590,11 @@
   // clang-format on
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   // TODO(ianswett): see todo in previous test.
   if (framer_.version().IsIetfQuic()) {
     p = packet50;
-    p_size = ABSL_ARRAYSIZE(packet50);
+    p_size = std::size(packet50);
   }
 
   std::unique_ptr<QuicPacket> raw(new QuicPacket(
@@ -9880,10 +9880,10 @@
   EXPECT_CALL(visitor, OnDecryptedPacket(_, _));
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -10064,7 +10064,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, IetfStreamBlockedFrame) {
@@ -10152,7 +10152,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, BiDiMaxStreamsFrame) {
@@ -10352,8 +10352,8 @@
   };
   // clang-format on
 
-  QuicEncryptedPacket encrypted(AsChars(packet_ietf),
-                                ABSL_ARRAYSIZE(packet_ietf), false);
+  QuicEncryptedPacket encrypted(AsChars(packet_ietf), std::size(packet_ietf),
+                                false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
@@ -10389,8 +10389,8 @@
   };
   // clang-format on
 
-  QuicEncryptedPacket encrypted(AsChars(packet_ietf),
-                                ABSL_ARRAYSIZE(packet_ietf), false);
+  QuicEncryptedPacket encrypted(AsChars(packet_ietf), std::size(packet_ietf),
+                                false);
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
@@ -10429,8 +10429,8 @@
   };
   // clang-format on
 
-  QuicEncryptedPacket encrypted(AsChars(packet_ietf),
-                                ABSL_ARRAYSIZE(packet_ietf), false);
+  QuicEncryptedPacket encrypted(AsChars(packet_ietf), std::size(packet_ietf),
+                                false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -10467,8 +10467,8 @@
   };
   // clang-format on
 
-  QuicEncryptedPacket encrypted(AsChars(packet_ietf),
-                                ABSL_ARRAYSIZE(packet_ietf), false);
+  QuicEncryptedPacket encrypted(AsChars(packet_ietf), std::size(packet_ietf),
+                                false);
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
@@ -10505,8 +10505,8 @@
   };
   // clang-format on
 
-  QuicEncryptedPacket encrypted(AsChars(packet_ietf),
-                                ABSL_ARRAYSIZE(packet_ietf), false);
+  QuicEncryptedPacket encrypted(AsChars(packet_ietf), std::size(packet_ietf),
+                                false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 }
 
@@ -10710,8 +10710,8 @@
   };
   // clang-format on
 
-  QuicEncryptedPacket encrypted(AsChars(packet_ietf),
-                                ABSL_ARRAYSIZE(packet_ietf), false);
+  QuicEncryptedPacket encrypted(AsChars(packet_ietf), std::size(packet_ietf),
+                                false);
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 
@@ -10805,7 +10805,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, BuildUniStreamsBlockedPacket) {
@@ -10847,7 +10847,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, BuildBiDiMaxStreamsPacket) {
@@ -10889,7 +10889,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, BuildUniDiMaxStreamsPacket) {
@@ -10934,7 +10934,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, NewConnectionIdFrame) {
@@ -11245,7 +11245,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, NewTokenFrame) {
@@ -11340,7 +11340,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet),
-      ABSL_ARRAYSIZE(packet));
+      std::size(packet));
 }
 
 TEST_P(QuicFramerTest, IetfStopSendingFrame) {
@@ -11433,7 +11433,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, IetfPathChallengeFrame) {
@@ -11516,7 +11516,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, IetfPathResponseFrame) {
@@ -11599,7 +11599,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, GetRetransmittableControlFrameSize) {
@@ -12405,7 +12405,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(packet_ietf),
-      ABSL_ARRAYSIZE(packet_ietf));
+      std::size(packet_ietf));
 }
 
 TEST_P(QuicFramerTest, AckFrameWithInvalidLargestObserved) {
@@ -12453,10 +12453,10 @@
   // clang-format on
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -12509,10 +12509,10 @@
   // clang-format on
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -12584,10 +12584,10 @@
   // clang-format on
 
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
   if (VersionIsIetfQuic(framer_.transport_version())) {
     p = packet_ietf;
-    p_size = ABSL_ARRAYSIZE(packet_ietf);
+    p_size = std::size(packet_ietf);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -12732,12 +12732,12 @@
   EXPECT_EQ(packet_ietf[first_packet_ietf_size], 0xD3);
 
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     ReviseFirstByteByVersion(packet_ietf);
     ReviseFirstByteByVersion(&packet_ietf[first_packet_ietf_size]);
     p = packet_ietf;
-    p_length = ABSL_ARRAYSIZE(packet_ietf);
+    p_length = std::size(packet_ietf);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -12853,11 +12853,11 @@
   // clang-format on
 
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     ReviseFirstByteByVersion(packet_ietf);
     p = packet_ietf;
-    p_length = ABSL_ARRAYSIZE(packet_ietf);
+    p_length = std::size(packet_ietf);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -13074,20 +13074,20 @@
   switch (framer_.version().transport_version) {
     case QUIC_VERSION_46:
       p = packet;
-      p_length = ABSL_ARRAYSIZE(packet);
+      p_length = std::size(packet);
       break;
     case QUIC_VERSION_IETF_DRAFT_29:
     case QUIC_VERSION_IETF_RFC_V1:
       p = packet_v1;
-      p_length = ABSL_ARRAYSIZE(packet_v1);
+      p_length = std::size(packet_v1);
       break;
     case QUIC_VERSION_IETF_RFC_V2:
       p = packet_v2;
-      p_length = ABSL_ARRAYSIZE(packet_v2);
+      p_length = std::size(packet_v2);
       break;
     default:
       p = packet_v2;  // To silence warnings.
-      p_length = ABSL_ARRAYSIZE(packet_v2);
+      p_length = std::size(packet_v2);
       QUICHE_NOTREACHED();
       break;
   }
@@ -13249,12 +13249,12 @@
   EXPECT_EQ(packet_ietf[first_packet_ietf_size], 0xD3);
 
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     ReviseFirstByteByVersion(packet_ietf);
     ReviseFirstByteByVersion(&packet_ietf[first_packet_ietf_size]);
     p = packet_ietf;
-    p_length = ABSL_ARRAYSIZE(packet_ietf);
+    p_length = std::size(packet_ietf);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -13344,11 +13344,11 @@
   };
   // clang-format on
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     ReviseFirstByteByVersion(packet49);
     p = packet49;
-    p_length = ABSL_ARRAYSIZE(packet49);
+    p_length = std::size(packet49);
   }
   // First attempt decryption without the handshake crypter.
   EXPECT_FALSE(
@@ -13430,11 +13430,11 @@
   };
   // clang-format on
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     ReviseFirstByteByVersion(packet49);
     p = packet49;
-    p_length = ABSL_ARRAYSIZE(packet49);
+    p_length = std::size(packet49);
   }
 
   EXPECT_FALSE(
@@ -13595,12 +13595,12 @@
   EXPECT_EQ(packet_ietf[length_of_first_coalesced_packet], 0xD3);
 
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     ReviseFirstByteByVersion(packet_ietf);
     ReviseFirstByteByVersion(&packet_ietf[length_of_first_coalesced_packet]);
     p = packet_ietf;
-    p_length = ABSL_ARRAYSIZE(packet_ietf);
+    p_length = std::size(packet_ietf);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -13768,12 +13768,12 @@
   EXPECT_EQ(packet_ietf[length_of_first_coalesced_packet], 0xD3);
 
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     ReviseFirstByteByVersion(packet_ietf);
     ReviseFirstByteByVersion(&packet_ietf[length_of_first_coalesced_packet]);
     p = packet_ietf;
-    p_length = ABSL_ARRAYSIZE(packet_ietf);
+    p_length = std::size(packet_ietf);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -13879,12 +13879,12 @@
   EXPECT_EQ(packet_ietf[length_of_first_coalesced_packet], 0xD3);
 
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     ReviseFirstByteByVersion(packet_ietf);
     ReviseFirstByteByVersion(&packet_ietf[length_of_first_coalesced_packet]);
     p = packet_ietf;
-    p_length = ABSL_ARRAYSIZE(packet_ietf);
+    p_length = std::size(packet_ietf);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -13943,7 +13943,7 @@
   unsigned char packet[kMaxOutgoingPacketSize] = {};
   size_t encrypted_length =
       framer_.EncryptPayload(ENCRYPTION_INITIAL, header.packet_number, *data,
-                             AsChars(packet), ABSL_ARRAYSIZE(packet));
+                             AsChars(packet), std::size(packet));
   ASSERT_NE(0u, encrypted_length);
 
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_SERVER);
@@ -13955,7 +13955,7 @@
                            std::move(server_crypters.decrypter));
 
   // Make sure the first long header initial packet parses correctly.
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
 
   // Make sure we discard the subsequent zeroes.
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -14010,10 +14010,10 @@
   // clang-format on
 
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
   if (framer_.version() == ParsedQuicVersion::RFCv1()) {
     p = packetv2;
-    p_length = ABSL_ARRAYSIZE(packetv2);
+    p_length = std::size(packetv2);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -14049,7 +14049,7 @@
   };
   // clang-format on
 
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 
   EXPECT_THAT(framer_.error(), IsError(QUIC_PACKET_WRONG_VERSION));
@@ -14167,14 +14167,13 @@
                          std::make_unique<TestDecrypter>());
   }
   if (!VersionIsIetfQuic(framer_.transport_version())) {
-    EXPECT_TRUE(framer_.ProcessPacket(
-        QuicEncryptedPacket(AsChars(long_header_packet),
-                            ABSL_ARRAYSIZE(long_header_packet), false)));
+    EXPECT_TRUE(framer_.ProcessPacket(QuicEncryptedPacket(
+        AsChars(long_header_packet), std::size(long_header_packet), false)));
   } else {
     ReviseFirstByteByVersion(long_header_packet_ietf);
     EXPECT_TRUE(framer_.ProcessPacket(
         QuicEncryptedPacket(AsChars(long_header_packet_ietf),
-                            ABSL_ARRAYSIZE(long_header_packet_ietf), false)));
+                            std::size(long_header_packet_ietf), false)));
   }
 
   EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -14201,7 +14200,7 @@
   // clang-format on
 
   QuicEncryptedPacket short_header_encrypted(
-      AsChars(short_header_packet), ABSL_ARRAYSIZE(short_header_packet), false);
+      AsChars(short_header_packet), std::size(short_header_packet), false);
   if (framer_.version().IsIetfQuic()) {
     framer_.InstallDecrypter(ENCRYPTION_FORWARD_SECURE,
                              std::make_unique<TestDecrypter>());
@@ -14630,7 +14629,7 @@
   ReviseFirstByteByVersion(packet);
   ReviseFirstByteByVersion(&packet[first_packet_size]);
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
 
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
   PacketHeaderFormat format;
@@ -14789,11 +14788,11 @@
   // clang-format on
 
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     ReviseFirstByteByVersion(packet49);
     p = packet49;
-    p_length = ABSL_ARRAYSIZE(packet49);
+    p_length = std::size(packet49);
   }
   const bool parse_success =
       framer_.ProcessPacket(QuicEncryptedPacket(AsChars(p), p_length, false));
@@ -14851,11 +14850,11 @@
   };
   // clang-format on
   unsigned char* p = packet;
-  size_t p_length = ABSL_ARRAYSIZE(packet);
+  size_t p_length = std::size(packet);
   if (framer_.version().IsIetfQuic()) {
     ReviseFirstByteByVersion(packet49);
     p = packet49;
-    p_length = ABSL_ARRAYSIZE(packet49);
+    p_length = std::size(packet49);
   }
   const bool parse_success =
       framer_.ProcessPacket(QuicEncryptedPacket(AsChars(p), p_length, false));
@@ -15065,8 +15064,8 @@
   };
   // clang-format on
 
-  framer_.ProcessPacket(QuicEncryptedPacket(
-      AsChars(packet_ietf), ABSL_ARRAYSIZE(packet_ietf), false));
+  framer_.ProcessPacket(
+      QuicEncryptedPacket(AsChars(packet_ietf), std::size(packet_ietf), false));
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
   // Verify ack_delay_time is set correctly.
   EXPECT_EQ(QuicTime::Delta::Infinite(),
@@ -15690,7 +15689,7 @@
   // clang-format on
 
   ReviseFirstByteByVersion(packet);
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
 
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 
@@ -15719,7 +15718,7 @@
   MockConnectionIdGenerator generator;
   ON_CALL(generator, ConnectionIdLength(0x28)).WillByDefault(Return(9));
   unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
+  size_t p_size = std::size(packet);
 
   const size_t header_size = GetPacketHeaderSize(
       framer_.transport_version(), kPacket8ByteConnectionId + 1,
@@ -15836,7 +15835,7 @@
   };
   // clang-format on
 
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
diff --git a/quiche/quic/core/quic_packet_creator_test.cc b/quiche/quic/core/quic_packet_creator_test.cc
index fca1f41..8338cf0 100644
--- a/quiche/quic/core/quic_packet_creator_test.cc
+++ b/quiche/quic/core/quic_packet_creator_test.cc
@@ -6,6 +6,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <iterator>
 #include <limits>
 #include <memory>
 #include <string>
@@ -778,9 +779,8 @@
   std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
 
   size_t length = creator_.BuildPaddedPathChallengePacket(
-      header, buffer.get(), ABSL_ARRAYSIZE(packet), payload,
-      ENCRYPTION_INITIAL);
-  EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
+      header, buffer.get(), std::size(packet), payload, ENCRYPTION_INITIAL);
+  EXPECT_EQ(length, std::size(packet));
 
   // Payload has the random bytes that were generated. Copy them into packet,
   // above, before checking that the generated packet is correct.
@@ -791,7 +791,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data.data(), data.length(),
-      reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
+      reinterpret_cast<char*>(packet), std::size(packet));
 }
 
 TEST_P(QuicPacketCreatorTest, BuildConnectivityProbingPacket) {
@@ -834,10 +834,10 @@
   // clang-format on
 
   unsigned char* p = packet;
-  size_t packet_size = ABSL_ARRAYSIZE(packet);
+  size_t packet_size = std::size(packet);
   if (creator_.version().IsIetfQuic()) {
     p = packet99;
-    packet_size = ABSL_ARRAYSIZE(packet99);
+    packet_size = std::size(packet99);
   }
 
   std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
@@ -892,15 +892,15 @@
   quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
   payloads.push_back(payload0);
   size_t length = creator_.BuildPathResponsePacket(
-      header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
+      header, buffer.get(), std::size(packet), payloads,
       /*is_padded=*/false, ENCRYPTION_INITIAL);
-  EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
+  EXPECT_EQ(length, std::size(packet));
   QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
                   header);
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data.data(), data.length(),
-      reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
+      reinterpret_cast<char*>(packet), std::size(packet));
 }
 
 TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket1ResponsePadded) {
@@ -939,15 +939,15 @@
   quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
   payloads.push_back(payload0);
   size_t length = creator_.BuildPathResponsePacket(
-      header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
+      header, buffer.get(), std::size(packet), payloads,
       /*is_padded=*/true, ENCRYPTION_INITIAL);
-  EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
+  EXPECT_EQ(length, std::size(packet));
   QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
                   header);
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data.data(), data.length(),
-      reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
+      reinterpret_cast<char*>(packet), std::size(packet));
 }
 
 TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket3ResponsesUnpadded) {
@@ -991,15 +991,15 @@
   payloads.push_back(payload1);
   payloads.push_back(payload2);
   size_t length = creator_.BuildPathResponsePacket(
-      header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
+      header, buffer.get(), std::size(packet), payloads,
       /*is_padded=*/false, ENCRYPTION_INITIAL);
-  EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
+  EXPECT_EQ(length, std::size(packet));
   QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
                   header);
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data.data(), data.length(),
-      reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
+      reinterpret_cast<char*>(packet), std::size(packet));
 }
 
 TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket3ResponsesPadded) {
@@ -1045,15 +1045,15 @@
   payloads.push_back(payload1);
   payloads.push_back(payload2);
   size_t length = creator_.BuildPathResponsePacket(
-      header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
+      header, buffer.get(), std::size(packet), payloads,
       /*is_padded=*/true, ENCRYPTION_INITIAL);
-  EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
+  EXPECT_EQ(length, std::size(packet));
   QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
                   header);
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data.data(), data.length(),
-      reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
+      reinterpret_cast<char*>(packet), std::size(packet));
 }
 
 TEST_P(QuicPacketCreatorTest, SerializeConnectivityProbingPacket) {
diff --git a/quiche/quic/core/quic_sent_packet_manager_test.cc b/quiche/quic/core/quic_sent_packet_manager_test.cc
index a5792ed..ede33a9 100644
--- a/quiche/quic/core/quic_sent_packet_manager_test.cc
+++ b/quiche/quic/core/quic_sent_packet_manager_test.cc
@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
+#include <iterator>
 #include <memory>
 #include <optional>
 #include <string>
@@ -367,10 +368,9 @@
   SendDataPacket(1);
 
   uint64_t unacked[] = {1};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
   uint64_t retransmittable[] = {1};
-  VerifyRetransmittablePackets(retransmittable,
-                               ABSL_ARRAYSIZE(retransmittable));
+  VerifyRetransmittablePackets(retransmittable, std::size(retransmittable));
 }
 
 TEST_F(QuicSentPacketManagerTest, IsUnAckedRetransmit) {
@@ -379,7 +379,7 @@
 
   EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(&manager_, 2));
   uint64_t unacked[] = {1, 2};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
   std::vector<uint64_t> retransmittable = {1, 2};
   VerifyRetransmittablePackets(&retransmittable[0], retransmittable.size());
 }
@@ -399,7 +399,7 @@
   EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
   // Packet 1 is unacked, pending, but not retransmittable.
   uint64_t unacked[] = {1};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
   EXPECT_TRUE(manager_.HasInFlightPackets());
   VerifyRetransmittablePackets(nullptr, 0);
 }
@@ -423,7 +423,7 @@
 
   EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
   uint64_t unacked[] = {2};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
   // We do not know packet 2 is a spurious retransmission until it gets acked.
   VerifyRetransmittablePackets(nullptr, 0);
   EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted);
@@ -438,7 +438,7 @@
   EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
 
   uint64_t unacked[] = {1};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
   VerifyRetransmittablePackets(nullptr, 0);
   EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted);
 }
@@ -460,7 +460,7 @@
   EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
   // 2 remains unacked, but no packets have retransmittable data.
   uint64_t unacked[] = {2};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
   EXPECT_TRUE(manager_.HasInFlightPackets());
   VerifyRetransmittablePackets(nullptr, 0);
   // Ack 2 causes 2 be considered as spurious retransmission.
@@ -527,7 +527,7 @@
                                    ENCRYPTION_INITIAL, kEmptyCounts));
 
   uint64_t unacked[] = {2};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
   EXPECT_FALSE(manager_.HasInFlightPackets());
   VerifyRetransmittablePackets(nullptr, 0);
 
@@ -559,7 +559,7 @@
 
   // Since 2 was marked for retransmit, when 1 is acked, 2 is kept for RTT.
   uint64_t unacked[] = {2};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
   EXPECT_FALSE(manager_.HasInFlightPackets());
   VerifyRetransmittablePackets(nullptr, 0);
 
@@ -597,7 +597,7 @@
 
   // 2 and 3 remain unacked, but no packets have retransmittable data.
   uint64_t unacked[] = {2, 3};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
   EXPECT_TRUE(manager_.HasInFlightPackets());
   VerifyRetransmittablePackets(nullptr, 0);
 
@@ -608,7 +608,7 @@
       .WillOnce(Return(false))
       .WillRepeatedly(Return(true));
   uint64_t acked[] = {3, 4};
-  ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+  ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
   manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
                            clock_.Now());
   manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(5));
@@ -619,7 +619,7 @@
                                    ENCRYPTION_INITIAL, kEmptyCounts));
 
   uint64_t unacked2[] = {2};
-  VerifyUnackedPackets(unacked2, ABSL_ARRAYSIZE(unacked2));
+  VerifyUnackedPackets(unacked2, std::size(unacked2));
   EXPECT_TRUE(manager_.HasInFlightPackets());
 
   SendDataPacket(5);
@@ -641,7 +641,7 @@
                                    ENCRYPTION_INITIAL, kEmptyCounts));
 
   uint64_t unacked3[] = {2};
-  VerifyUnackedPackets(unacked3, ABSL_ARRAYSIZE(unacked3));
+  VerifyUnackedPackets(unacked3, std::size(unacked3));
   EXPECT_FALSE(manager_.HasInFlightPackets());
   // Spurious retransmission is detected when packet 3 gets acked. We cannot
   // know packet 2 is a spurious until it gets acked.
@@ -690,7 +690,7 @@
   // Ack 3, which causes SpuriousRetransmitDetected to be called.
   {
     uint64_t acked[] = {3};
-    ExpectAcksAndLosses(false, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+    ExpectAcksAndLosses(false, acked, std::size(acked), nullptr, 0);
     EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
     EXPECT_CALL(*loss_algorithm,
                 SpuriousLossDetected(_, _, _, QuicPacketNumber(3),
@@ -737,7 +737,7 @@
 
   // Now ack the ack and expect an RTT update.
   uint64_t acked[] = {1, 2};
-  ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+  ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
   manager_.OnAckFrameStart(QuicPacketNumber(2),
                            QuicTime::Delta::FromMilliseconds(5), clock_.Now());
   manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
@@ -751,7 +751,7 @@
 
   // Now ack the ack and expect only an RTT update.
   uint64_t acked2[] = {3};
-  ExpectAcksAndLosses(true, acked2, ABSL_ARRAYSIZE(acked2), nullptr, 0);
+  ExpectAcksAndLosses(true, acked2, std::size(acked2), nullptr, 0);
   manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
                            clock_.Now());
   manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(4));
@@ -911,8 +911,7 @@
   // Crypto packets remain in flight, so any that aren't acked will be lost.
   uint64_t acked[] = {3, 4, 5, 8, 9};
   uint64_t lost[] = {1, 2, 6};
-  ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), lost,
-                      ABSL_ARRAYSIZE(lost));
+  ExpectAcksAndLosses(true, acked, std::size(acked), lost, std::size(lost));
   EXPECT_CALL(notifier_, OnFrameLost(_)).Times(3);
   EXPECT_CALL(notifier_, HasUnackedCryptoData()).WillRepeatedly(Return(false));
   manager_.OnAckFrameStart(QuicPacketNumber(9), QuicTime::Delta::Infinite(),
@@ -946,7 +945,7 @@
   // Now ack the second crypto packet, and ensure the first gets removed, but
   // the third does not.
   uint64_t acked[] = {2};
-  ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+  ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
   EXPECT_CALL(notifier_, HasUnackedCryptoData()).WillRepeatedly(Return(false));
   EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
   manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
@@ -958,7 +957,7 @@
 
   EXPECT_FALSE(manager_.HasUnackedCryptoPackets());
   uint64_t unacked[] = {1, 3};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
 }
 
 TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeoutUnsentDataPacket) {
@@ -1009,14 +1008,14 @@
   manager_.NeuterUnencryptedPackets();
   EXPECT_FALSE(manager_.HasUnackedCryptoPackets());
   uint64_t unacked[] = {1, 2, 3};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
   VerifyRetransmittablePackets(nullptr, 0);
   EXPECT_FALSE(manager_.HasUnackedCryptoPackets());
   EXPECT_FALSE(manager_.HasInFlightPackets());
 
   // Ensure both packets get discarded when packet 2 is acked.
   uint64_t acked[] = {3};
-  ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+  ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
   manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
                            clock_.Now());
   manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(4));
@@ -1750,8 +1749,7 @@
   // Ack [5, 7), [10, 12), [15, 17).
   uint64_t acked1[] = {5, 6, 10, 11, 15, 16};
   uint64_t lost1[] = {1, 2, 3, 4, 7, 8, 9, 12, 13};
-  ExpectAcksAndLosses(true, acked1, ABSL_ARRAYSIZE(acked1), lost1,
-                      ABSL_ARRAYSIZE(lost1));
+  ExpectAcksAndLosses(true, acked1, std::size(acked1), lost1, std::size(lost1));
   EXPECT_CALL(notifier_, OnFrameLost(_)).Times(AnyNumber());
   manager_.OnAckFrameStart(QuicPacketNumber(16), QuicTime::Delta::Infinite(),
                            clock_.Now());
@@ -1766,7 +1764,7 @@
 
   // Ack [4, 8), [9, 13), [14, 21).
   uint64_t acked2[] = {4, 7, 9, 12, 14, 17, 18, 19, 20};
-  ExpectAcksAndLosses(true, acked2, ABSL_ARRAYSIZE(acked2), nullptr, 0);
+  ExpectAcksAndLosses(true, acked2, std::size(acked2), nullptr, 0);
   manager_.OnAckFrameStart(QuicPacketNumber(20), QuicTime::Delta::Infinite(),
                            clock_.Now());
   manager_.OnAckRange(QuicPacketNumber(14), QuicPacketNumber(21));
@@ -1785,8 +1783,7 @@
   // Ack [5, 7), [10, 12), [15, 17).
   uint64_t acked1[] = {5, 6, 10, 11, 15, 16};
   uint64_t lost1[] = {1, 2, 3, 4, 7, 8, 9, 12, 13};
-  ExpectAcksAndLosses(true, acked1, ABSL_ARRAYSIZE(acked1), lost1,
-                      ABSL_ARRAYSIZE(lost1));
+  ExpectAcksAndLosses(true, acked1, std::size(acked1), lost1, std::size(lost1));
   EXPECT_CALL(notifier_, OnFrameLost(_)).Times(AnyNumber());
   manager_.OnAckFrameStart(QuicPacketNumber(16), QuicTime::Delta::Infinite(),
                            clock_.Now());
@@ -1799,7 +1796,7 @@
 
   // Making sure reneged ACK does not harm. Ack [4, 8), [9, 13).
   uint64_t acked2[] = {4, 7, 9, 12};
-  ExpectAcksAndLosses(true, acked2, ABSL_ARRAYSIZE(acked2), nullptr, 0);
+  ExpectAcksAndLosses(true, acked2, std::size(acked2), nullptr, 0);
   manager_.OnAckFrameStart(QuicPacketNumber(12), QuicTime::Delta::Infinite(),
                            clock_.Now());
   manager_.OnAckRange(QuicPacketNumber(9), QuicPacketNumber(13));
@@ -1920,7 +1917,7 @@
                 APPLICATION_DATA));
   // Ack all packets.
   uint64_t acked[] = {4, 6, 7, 8};
-  ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+  ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
   manager_.OnAckFrameStart(QuicPacketNumber(8), QuicTime::Delta::Infinite(),
                            clock_.Now());
   manager_.OnAckRange(QuicPacketNumber(4), QuicPacketNumber(9));
@@ -1990,7 +1987,7 @@
   // Packet 1 gets acked in the wrong packet number space. Since packet 1 has
   // been acked in the correct packet number space, tolerate it.
   uint64_t acked[] = {2, 3};
-  ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+  ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
   manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
                            clock_.Now());
   manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(4));
@@ -2044,7 +2041,7 @@
 
   // Received ACK for packets 1 and 2.
   uint64_t acked[] = {1, 2};
-  ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+  ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
   manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
                            clock_.Now());
   manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
@@ -2397,7 +2394,7 @@
 
   // Received ACK for packets 1 and 2.
   uint64_t acked[] = {1, 2};
-  ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+  ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
   manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
                            clock_.Now());
   manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
@@ -2467,7 +2464,7 @@
 
   // Received ACK for packets 1 and 2.
   uint64_t acked[] = {1, 2};
-  ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+  ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
   manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
                            clock_.Now());
   manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
@@ -2712,8 +2709,8 @@
   EXPECT_NE(QuicTime::Zero(), manager_.GetRetransmissionTime());
 
   uint64_t acked[] = {1};
-  ExpectAcksAndLosses(/*rtt_updated=*/false, acked, ABSL_ARRAYSIZE(acked),
-                      nullptr, 0);
+  ExpectAcksAndLosses(/*rtt_updated=*/false, acked, std::size(acked), nullptr,
+                      0);
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(90));
   manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
                            clock_.Now());
diff --git a/quiche/quic/core/quic_socket_address_coder_test.cc b/quiche/quic/core/quic_socket_address_coder_test.cc
index 32f3570..cdedf63 100644
--- a/quiche/quic/core/quic_socket_address_coder_test.cc
+++ b/quiche/quic/core/quic_socket_address_coder_test.cc
@@ -4,6 +4,7 @@
 
 #include "quiche/quic/core/quic_socket_address_coder.h"
 
+#include <iterator>
 #include <string>
 
 #include "absl/base/macros.h"
@@ -113,7 +114,7 @@
       {"::1", 65534},
   };
 
-  for (size_t i = 0; i < ABSL_ARRAYSIZE(test_case); i++) {
+  for (size_t i = 0; i < std::size(test_case); i++) {
     QuicIpAddress ip;
     ASSERT_TRUE(ip.FromString(test_case[i].ip_literal));
     QuicSocketAddressCoder encoder(QuicSocketAddress(ip, test_case[i].port));
diff --git a/quiche/quic/core/quic_stream_sequencer_test.cc b/quiche/quic/core/quic_stream_sequencer_test.cc
index dc73a37..0b4d30e 100644
--- a/quiche/quic/core/quic_stream_sequencer_test.cc
+++ b/quiche/quic/core/quic_stream_sequencer_test.cc
@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <cstdint>
+#include <iterator>
 #include <memory>
 #include <string>
 #include <utility>
@@ -57,7 +58,7 @@
  public:
   void ConsumeData(size_t num_bytes) {
     char buffer[1024];
-    ASSERT_GT(ABSL_ARRAYSIZE(buffer), num_bytes);
+    ASSERT_GT(std::size(buffer), num_bytes);
     struct iovec iov;
     iov.iov_base = buffer;
     iov.iov_len = num_bytes;
@@ -99,8 +100,7 @@
   bool VerifyReadableRegions(const QuicStreamSequencer& sequencer,
                              const std::vector<std::string>& expected) {
     iovec iovecs[5];
-    size_t num_iovecs =
-        sequencer.GetReadableRegions(iovecs, ABSL_ARRAYSIZE(iovecs));
+    size_t num_iovecs = sequencer.GetReadableRegions(iovecs, std::size(iovecs));
     return VerifyReadableRegion(sequencer, expected) &&
            VerifyIovecs(sequencer, iovecs, num_iovecs, expected);
   }
@@ -390,7 +390,7 @@
   using FrameList = std::vector<Frame>;
 
   void CreateFrames() {
-    int payload_size = ABSL_ARRAYSIZE(kPayload) - 1;
+    int payload_size = std::size(kPayload) - 1;
     int remaining_payload = payload_size;
     while (remaining_payload != 0) {
       int size = std::min(OneToN(6), remaining_payload);
@@ -413,10 +413,10 @@
 
   void ReadAvailableData() {
     // Read all available data
-    char output[ABSL_ARRAYSIZE(kPayload) + 1];
+    char output[std::size(kPayload) + 1];
     iovec iov;
     iov.iov_base = output;
-    iov.iov_len = ABSL_ARRAYSIZE(output);
+    iov.iov_len = std::size(output);
     int bytes_read = sequencer_->Readv(&iov, 1);
     EXPECT_NE(0, bytes_read);
     output_.append(output, bytes_read);
@@ -451,9 +451,9 @@
     list_.erase(list_.begin() + index);
   }
 
-  ASSERT_EQ(ABSL_ARRAYSIZE(kPayload) - 1, output_.size());
+  ASSERT_EQ(std::size(kPayload) - 1, output_.size());
   EXPECT_EQ(kPayload, output_);
-  EXPECT_EQ(ABSL_ARRAYSIZE(kPayload) - 1, total_bytes_consumed);
+  EXPECT_EQ(std::size(kPayload) - 1, total_bytes_consumed);
 }
 
 TEST_F(QuicSequencerRandomTest, RandomFramesNoDroppingBackup) {
@@ -472,7 +472,7 @@
         total_bytes_consumed += bytes;
       });
 
-  while (output_.size() != ABSL_ARRAYSIZE(kPayload) - 1) {
+  while (output_.size() != std::size(kPayload) - 1) {
     if (!list_.empty() && OneToN(2) == 1) {  // Send data
       int index = OneToN(list_.size()) - 1;
       OnFrame(list_[index].first, list_[index].second.data());
@@ -488,7 +488,7 @@
         ASSERT_EQ(0, iovs_peeked);
         ASSERT_FALSE(sequencer_->GetReadableRegion(peek_iov));
       }
-      int total_bytes_to_peek = ABSL_ARRAYSIZE(buffer);
+      int total_bytes_to_peek = std::size(buffer);
       for (int i = 0; i < iovs_peeked; ++i) {
         int bytes_to_peek =
             std::min<int>(peek_iov[i].iov_len, total_bytes_to_peek);
@@ -505,7 +505,7 @@
   }
   EXPECT_EQ(std::string(kPayload), output_);
   EXPECT_EQ(std::string(kPayload), peeked_);
-  EXPECT_EQ(ABSL_ARRAYSIZE(kPayload) - 1, total_bytes_consumed);
+  EXPECT_EQ(std::size(kPayload) - 1, total_bytes_consumed);
 }
 
 // Same as above, just using a different method for reading.
diff --git a/quiche/quic/core/quic_stream_test.cc b/quiche/quic/core/quic_stream_test.cc
index fc216c8..380d8b6 100644
--- a/quiche/quic/core/quic_stream_test.cc
+++ b/quiche/quic/core/quic_stream_test.cc
@@ -6,6 +6,7 @@
 
 #include <cmath>
 #include <cstddef>
+#include <iterator>
 #include <memory>
 #include <optional>
 #include <string>
@@ -86,7 +87,7 @@
 
   void ConsumeData(size_t num_bytes) {
     char buffer[1024];
-    ASSERT_GT(ABSL_ARRAYSIZE(buffer), num_bytes);
+    ASSERT_GT(std::size(buffer), num_bytes);
     struct iovec iov;
     iov.iov_base = buffer;
     iov.iov_len = num_bytes;
diff --git a/quiche/quic/core/quic_unacked_packet_map_test.cc b/quiche/quic/core/quic_unacked_packet_map_test.cc
index a94e006..bbcf9b8 100644
--- a/quiche/quic/core/quic_unacked_packet_map_test.cc
+++ b/quiche/quic/core/quic_unacked_packet_map_test.cc
@@ -8,6 +8,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <iterator>
 #include <limits>
 #include <vector>
 
@@ -195,7 +196,7 @@
                                  ECN_NOT_ECT);
 
   uint64_t unacked[] = {1};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
   VerifyInFlightPackets(nullptr, 0);
   VerifyRetransmittablePackets(nullptr, 0);
 
@@ -212,18 +213,18 @@
                                  ECN_NOT_ECT);
 
   uint64_t unacked[] = {1};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
-  VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
-  VerifyRetransmittablePackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
+  VerifyInFlightPackets(unacked, std::size(unacked));
+  VerifyRetransmittablePackets(unacked, std::size(unacked));
 
   unacked_packets_.RemoveRetransmittability(QuicPacketNumber(1));
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
-  VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
+  VerifyInFlightPackets(unacked, std::size(unacked));
   VerifyRetransmittablePackets(nullptr, 0);
 
   unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(1));
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
-  VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
+  VerifyInFlightPackets(unacked, std::size(unacked));
   VerifyRetransmittablePackets(nullptr, 0);
 
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(1));
@@ -239,15 +240,14 @@
                                  ECN_NOT_ECT);
 
   uint64_t unacked[] = {1};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
-  VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
+  VerifyInFlightPackets(unacked, std::size(unacked));
   uint64_t retransmittable[] = {1};
-  VerifyRetransmittablePackets(retransmittable,
-                               ABSL_ARRAYSIZE(retransmittable));
+  VerifyRetransmittablePackets(retransmittable, std::size(retransmittable));
 
   EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
-  VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
+  VerifyInFlightPackets(unacked, std::size(unacked));
   VerifyRetransmittablePackets(nullptr, 0);
 }
 
@@ -258,16 +258,14 @@
                                  ECN_NOT_ECT);
 
   uint64_t unacked[] = {1};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
-  VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
+  VerifyInFlightPackets(unacked, std::size(unacked));
   uint64_t retransmittable[] = {1};
-  VerifyRetransmittablePackets(retransmittable,
-                               ABSL_ARRAYSIZE(retransmittable));
+  VerifyRetransmittablePackets(retransmittable, std::size(retransmittable));
 
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
-  VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
-  VerifyRetransmittablePackets(retransmittable,
-                               ABSL_ARRAYSIZE(retransmittable));
+  VerifyUnackedPackets(unacked, std::size(unacked));
+  VerifyInFlightPackets(unacked, std::size(unacked));
+  VerifyRetransmittablePackets(retransmittable, std::size(retransmittable));
 }
 
 TEST_P(QuicUnackedPacketMapTest, StopRetransmissionAfterRetransmission) {
@@ -278,14 +276,14 @@
   RetransmitAndSendPacket(1, 2, LOSS_RETRANSMISSION);
 
   uint64_t unacked[] = {1, 2};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
-  VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
+  VerifyInFlightPackets(unacked, std::size(unacked));
   std::vector<uint64_t> retransmittable = {1, 2};
   VerifyRetransmittablePackets(&retransmittable[0], retransmittable.size());
 
   EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
-  VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
+  VerifyInFlightPackets(unacked, std::size(unacked));
   VerifyRetransmittablePackets(nullptr, 0);
 }
 
@@ -298,26 +296,26 @@
   RetransmitAndSendPacket(1, 2, LOSS_RETRANSMISSION);
 
   uint64_t unacked[] = {1, 2};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
-  VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
+  VerifyInFlightPackets(unacked, std::size(unacked));
   std::vector<uint64_t> retransmittable = {1, 2};
   VerifyRetransmittablePackets(&retransmittable[0], retransmittable.size());
 
   EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
   unacked_packets_.RemoveRetransmittability(QuicPacketNumber(1));
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
-  VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
+  VerifyInFlightPackets(unacked, std::size(unacked));
   VerifyRetransmittablePackets(nullptr, 0);
 
   unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
-  VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
+  VerifyInFlightPackets(unacked, std::size(unacked));
   VerifyRetransmittablePackets(nullptr, 0);
 
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
   uint64_t unacked2[] = {1};
-  VerifyUnackedPackets(unacked2, ABSL_ARRAYSIZE(unacked2));
-  VerifyInFlightPackets(unacked2, ABSL_ARRAYSIZE(unacked2));
+  VerifyUnackedPackets(unacked2, std::size(unacked2));
+  VerifyInFlightPackets(unacked2, std::size(unacked2));
   VerifyRetransmittablePackets(nullptr, 0);
 
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(1));
@@ -336,11 +334,10 @@
                                  ECN_NOT_ECT);
 
   uint64_t unacked[] = {1, 2};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
-  VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
+  VerifyInFlightPackets(unacked, std::size(unacked));
   uint64_t retransmittable[] = {1, 2};
-  VerifyRetransmittablePackets(retransmittable,
-                               ABSL_ARRAYSIZE(retransmittable));
+  VerifyRetransmittablePackets(retransmittable, std::size(retransmittable));
 
   // Early retransmit 1 as 3 and send new data as 4.
   unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
@@ -353,9 +350,9 @@
                                  ECN_NOT_ECT);
 
   uint64_t unacked2[] = {1, 3, 4};
-  VerifyUnackedPackets(unacked2, ABSL_ARRAYSIZE(unacked2));
+  VerifyUnackedPackets(unacked2, std::size(unacked2));
   uint64_t pending2[] = {3, 4};
-  VerifyInFlightPackets(pending2, ABSL_ARRAYSIZE(pending2));
+  VerifyInFlightPackets(pending2, std::size(pending2));
   std::vector<uint64_t> retransmittable2 = {1, 3, 4};
   VerifyRetransmittablePackets(&retransmittable2[0], retransmittable2.size());
 
@@ -373,7 +370,7 @@
   VerifyUnackedPackets(&unacked3[0], unacked3.size());
   VerifyRetransmittablePackets(&retransmittable3[0], retransmittable3.size());
   uint64_t pending3[] = {3, 5, 6};
-  VerifyInFlightPackets(pending3, ABSL_ARRAYSIZE(pending3));
+  VerifyInFlightPackets(pending3, std::size(pending3));
 
   // Early retransmit 5 as 7 and ensure in flight packet 3 is not removed.
   unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(6));
@@ -386,13 +383,13 @@
   VerifyUnackedPackets(&unacked4[0], unacked4.size());
   VerifyRetransmittablePackets(&retransmittable4[0], retransmittable4.size());
   uint64_t pending4[] = {3, 5, 7};
-  VerifyInFlightPackets(pending4, ABSL_ARRAYSIZE(pending4));
+  VerifyInFlightPackets(pending4, std::size(pending4));
 
   // Remove the older two transmissions from in flight.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(3));
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(5));
   uint64_t pending5[] = {7};
-  VerifyInFlightPackets(pending5, ABSL_ARRAYSIZE(pending5));
+  VerifyInFlightPackets(pending5, std::size(pending5));
 }
 
 TEST_P(QuicUnackedPacketMapTest, RetransmitFourTimes) {
@@ -405,11 +402,10 @@
                                  ECN_NOT_ECT);
 
   uint64_t unacked[] = {1, 2};
-  VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
-  VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+  VerifyUnackedPackets(unacked, std::size(unacked));
+  VerifyInFlightPackets(unacked, std::size(unacked));
   uint64_t retransmittable[] = {1, 2};
-  VerifyRetransmittablePackets(retransmittable,
-                               ABSL_ARRAYSIZE(retransmittable));
+  VerifyRetransmittablePackets(retransmittable, std::size(retransmittable));
 
   // Early retransmit 1 as 3.
   unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
@@ -419,9 +415,9 @@
   RetransmitAndSendPacket(1, 3, LOSS_RETRANSMISSION);
 
   uint64_t unacked2[] = {1, 3};
-  VerifyUnackedPackets(unacked2, ABSL_ARRAYSIZE(unacked2));
+  VerifyUnackedPackets(unacked2, std::size(unacked2));
   uint64_t pending2[] = {3};
-  VerifyInFlightPackets(pending2, ABSL_ARRAYSIZE(pending2));
+  VerifyInFlightPackets(pending2, std::size(pending2));
   std::vector<uint64_t> retransmittable2 = {1, 3};
   VerifyRetransmittablePackets(&retransmittable2[0], retransmittable2.size());
 
@@ -432,9 +428,9 @@
                                  ECN_NOT_ECT);
 
   uint64_t unacked3[] = {1, 3, 4, 5};
-  VerifyUnackedPackets(unacked3, ABSL_ARRAYSIZE(unacked3));
+  VerifyUnackedPackets(unacked3, std::size(unacked3));
   uint64_t pending3[] = {3, 4, 5};
-  VerifyInFlightPackets(pending3, ABSL_ARRAYSIZE(pending3));
+  VerifyInFlightPackets(pending3, std::size(pending3));
   std::vector<uint64_t> retransmittable3 = {1, 3, 4, 5};
   VerifyRetransmittablePackets(&retransmittable3[0], retransmittable3.size());
 
@@ -449,7 +445,7 @@
   std::vector<uint64_t> unacked4 = {4, 6};
   VerifyUnackedPackets(&unacked4[0], unacked4.size());
   uint64_t pending4[] = {6};
-  VerifyInFlightPackets(pending4, ABSL_ARRAYSIZE(pending4));
+  VerifyInFlightPackets(pending4, std::size(pending4));
   std::vector<uint64_t> retransmittable4 = {4, 6};
   VerifyRetransmittablePackets(&retransmittable4[0], retransmittable4.size());
 }
diff --git a/quiche/quic/core/quic_utils_test.cc b/quiche/quic/core/quic_utils_test.cc
index 65e98b2..54a798c 100644
--- a/quiche/quic/core/quic_utils_test.cc
+++ b/quiche/quic/core/quic_utils_test.cc
@@ -4,6 +4,7 @@
 
 #include "quiche/quic/core/quic_utils.h"
 
+#include <iterator>
 #include <string>
 #include <vector>
 
@@ -172,10 +173,10 @@
   QuicConnectionId connection_id = QuicUtils::CreateRandomConnectionId(&random);
   EXPECT_EQ(connection_id.length(), sizeof(uint64_t));
   char connection_id_bytes[sizeof(uint64_t)];
-  random.RandBytes(connection_id_bytes, ABSL_ARRAYSIZE(connection_id_bytes));
+  random.RandBytes(connection_id_bytes, std::size(connection_id_bytes));
   EXPECT_EQ(connection_id,
             QuicConnectionId(static_cast<char*>(connection_id_bytes),
-                             ABSL_ARRAYSIZE(connection_id_bytes)));
+                             std::size(connection_id_bytes)));
   EXPECT_NE(connection_id, EmptyQuicConnectionId());
   EXPECT_NE(connection_id, TestConnectionId());
   EXPECT_NE(connection_id, TestConnectionId(1));
@@ -191,10 +192,10 @@
       QuicUtils::CreateRandomConnectionId(connection_id_length, &random);
   EXPECT_EQ(connection_id.length(), connection_id_length);
   char connection_id_bytes[connection_id_length];
-  random.RandBytes(connection_id_bytes, ABSL_ARRAYSIZE(connection_id_bytes));
+  random.RandBytes(connection_id_bytes, std::size(connection_id_bytes));
   EXPECT_EQ(connection_id,
             QuicConnectionId(static_cast<char*>(connection_id_bytes),
-                             ABSL_ARRAYSIZE(connection_id_bytes)));
+                             std::size(connection_id_bytes)));
   EXPECT_NE(connection_id, EmptyQuicConnectionId());
   EXPECT_NE(connection_id, TestConnectionId());
   EXPECT_NE(connection_id, TestConnectionId(1));
diff --git a/quiche/quic/core/quic_versions_test.cc b/quiche/quic/core/quic_versions_test.cc
index 0d4af51..46f0f59 100644
--- a/quiche/quic/core/quic_versions_test.cc
+++ b/quiche/quic/core/quic_versions_test.cc
@@ -5,6 +5,7 @@
 #include "quiche/quic/core/quic_versions.h"
 
 #include <cstddef>
+#include <iterator>
 #include <sstream>
 #include <string>
 
@@ -256,7 +257,7 @@
 
   QuicTransportVersion single_version[] = {QUIC_VERSION_46};
   QuicTransportVersionVector versions_vector;
-  for (size_t i = 0; i < ABSL_ARRAYSIZE(single_version); ++i) {
+  for (size_t i = 0; i < std::size(single_version); ++i) {
     versions_vector.push_back(single_version[i]);
   }
   EXPECT_EQ("QUIC_VERSION_46",
@@ -265,7 +266,7 @@
   QuicTransportVersion multiple_versions[] = {QUIC_VERSION_UNSUPPORTED,
                                               QUIC_VERSION_46};
   versions_vector.clear();
-  for (size_t i = 0; i < ABSL_ARRAYSIZE(multiple_versions); ++i) {
+  for (size_t i = 0; i < std::size(multiple_versions); ++i) {
     versions_vector.push_back(multiple_versions[i]);
   }
   EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_46",
diff --git a/quiche/quic/core/tls_client_handshaker_test.cc b/quiche/quic/core/tls_client_handshaker_test.cc
index 251183b..7c63be1 100644
--- a/quiche/quic/core/tls_client_handshaker_test.cc
+++ b/quiche/quic/core/tls_client_handshaker_test.cc
@@ -5,6 +5,7 @@
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
+#include <iterator>
 #include <memory>
 #include <optional>
 #include <string>
@@ -381,7 +382,7 @@
   };
   stream()->crypto_message_parser()->ProcessInput(
       absl::string_view(bogus_handshake_message,
-                        ABSL_ARRAYSIZE(bogus_handshake_message)),
+                        std::size(bogus_handshake_message)),
       ENCRYPTION_INITIAL);
 
   EXPECT_FALSE(stream()->one_rtt_keys_available());
diff --git a/quiche/quic/core/tls_server_handshaker_test.cc b/quiche/quic/core/tls_server_handshaker_test.cc
index cfd9a00..5abadfc 100644
--- a/quiche/quic/core/tls_server_handshaker_test.cc
+++ b/quiche/quic/core/tls_server_handshaker_test.cc
@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
+#include <iterator>
 #include <memory>
 #include <optional>
 #include <string>
@@ -1044,7 +1045,7 @@
   QuicConnection::ScopedPacketFlusher flusher(server_connection_);
   server_stream()->crypto_message_parser()->ProcessInput(
       absl::string_view(bogus_handshake_message,
-                        ABSL_ARRAYSIZE(bogus_handshake_message)),
+                        std::size(bogus_handshake_message)),
       ENCRYPTION_INITIAL);
 
   EXPECT_FALSE(server_stream()->one_rtt_keys_available());
@@ -1646,7 +1647,7 @@
       {true},
       {false},
   };
-  for (size_t i = 0; i < ABSL_ARRAYSIZE(tests); i++) {
+  for (size_t i = 0; i < std::size(tests); i++) {
     SCOPED_TRACE(absl::StrCat("Test #", i));
     const auto& test = tests[i];
     client_crypto_config_->set_alps_use_new_codepoint(