diff --git a/quiche/quic/core/http/http_decoder_test.cc b/quiche/quic/core/http/http_decoder_test.cc
index 79e2e9a..edd2341 100644
--- a/quiche/quic/core/http/http_decoder_test.cc
+++ b/quiche/quic/core/http/http_decoder_test.cc
@@ -4,6 +4,7 @@
 
 #include "quiche/quic/core/http/http_decoder.h"
 
+#include <iterator>
 #include <memory>
 #include <string>
 #include <utility>
@@ -676,7 +677,7 @@
 
   writer.WriteStringPiece("Malformed payload");
   EXPECT_CALL(visitor_, OnError(&decoder_));
-  EXPECT_EQ(5u, decoder_.ProcessInput(input, ABSL_ARRAYSIZE(input)));
+  EXPECT_EQ(5u, decoder_.ProcessInput(input, std::size(input)));
   EXPECT_THAT(decoder_.error(), IsError(QUIC_HTTP_FRAME_TOO_LARGE));
   EXPECT_EQ("Frame is too large.", decoder_.error_detail());
 }
diff --git a/quiche/quic/core/http/http_encoder_test.cc b/quiche/quic/core/http/http_encoder_test.cc
index 958e3f9..6d5823b 100644
--- a/quiche/quic/core/http/http_encoder_test.cc
+++ b/quiche/quic/core/http/http_encoder_test.cc
@@ -4,6 +4,7 @@
 
 #include "quiche/quic/core/http/http_encoder.h"
 
+#include <iterator>
 #include <string>
 
 #include "absl/base/macros.h"
@@ -21,9 +22,9 @@
       /* payload_length = */ 5, quiche::SimpleBufferAllocator::Get());
   char output[] = {0x00,   // type (DATA)
                    0x05};  // length
-  EXPECT_EQ(ABSL_ARRAYSIZE(output), buffer.size());
+  EXPECT_EQ(std::size(output), buffer.size());
   quiche::test::CompareCharArraysWithHexError(
-      "DATA", buffer.data(), buffer.size(), output, ABSL_ARRAYSIZE(output));
+      "DATA", buffer.data(), buffer.size(), output, std::size(output));
 }
 
 TEST(HttpEncoderTest, SerializeHeadersFrameHeader) {
@@ -31,9 +32,8 @@
       HttpEncoder::SerializeHeadersFrameHeader(/* payload_length = */ 7);
   char output[] = {0x01,   // type (HEADERS)
                    0x07};  // length
-  quiche::test::CompareCharArraysWithHexError("HEADERS", header.data(),
-                                              header.length(), output,
-                                              ABSL_ARRAYSIZE(output));
+  quiche::test::CompareCharArraysWithHexError(
+      "HEADERS", header.data(), header.length(), output, std::size(output));
 }
 
 TEST(HttpEncoderTest, SerializeSettingsFrame) {
@@ -51,7 +51,7 @@
                    0x04};       // content
   std::string frame = HttpEncoder::SerializeSettingsFrame(settings);
   quiche::test::CompareCharArraysWithHexError(
-      "SETTINGS", frame.data(), frame.length(), output, ABSL_ARRAYSIZE(output));
+      "SETTINGS", frame.data(), frame.length(), output, std::size(output));
 }
 
 TEST(HttpEncoderTest, SerializeGoAwayFrame) {
@@ -62,7 +62,7 @@
                    0x01};  // ID
   std::string frame = HttpEncoder::SerializeGoAwayFrame(goaway);
   quiche::test::CompareCharArraysWithHexError(
-      "GOAWAY", frame.data(), frame.length(), output, ABSL_ARRAYSIZE(output));
+      "GOAWAY", frame.data(), frame.length(), output, std::size(output));
 }
 
 TEST(HttpEncoderTest, SerializePriorityUpdateFrame) {
@@ -76,7 +76,7 @@
       HttpEncoder::SerializePriorityUpdateFrame(priority_update1);
   quiche::test::CompareCharArraysWithHexError(
       "PRIORITY_UPDATE", frame1.data(), frame1.length(),
-      reinterpret_cast<char*>(output1), ABSL_ARRAYSIZE(output1));
+      reinterpret_cast<char*>(output1), std::size(output1));
 
   PriorityUpdateFrame priority_update2;
   priority_update2.prioritized_element_id = 0x05;
@@ -91,7 +91,7 @@
       HttpEncoder::SerializePriorityUpdateFrame(priority_update2);
   quiche::test::CompareCharArraysWithHexError(
       "PRIORITY_UPDATE", frame2.data(), frame2.length(),
-      reinterpret_cast<char*>(output2), ABSL_ARRAYSIZE(output2));
+      reinterpret_cast<char*>(output2), std::size(output2));
 }
 
 TEST(HttpEncoderTest, SerializeEmptyOriginFrame) {
@@ -102,7 +102,7 @@
   std::string output = HttpEncoder::SerializeOriginFrame(frame);
   quiche::test::CompareCharArraysWithHexError(
       "ORIGIN", output.data(), output.length(),
-      reinterpret_cast<char*>(expected), ABSL_ARRAYSIZE(expected));
+      reinterpret_cast<char*>(expected), std::size(expected));
 }
 
 TEST(HttpEncoderTest, SerializeOriginFrame) {
@@ -118,7 +118,7 @@
   std::string output = HttpEncoder::SerializeOriginFrame(frame);
   quiche::test::CompareCharArraysWithHexError(
       "ORIGIN", output.data(), output.length(),
-      reinterpret_cast<char*>(expected), ABSL_ARRAYSIZE(expected));
+      reinterpret_cast<char*>(expected), std::size(expected));
 }
 
 TEST(HttpEncoderTest, SerializeAcceptChFrame) {
@@ -129,7 +129,7 @@
   std::string frame1 = HttpEncoder::SerializeAcceptChFrame(accept_ch);
   quiche::test::CompareCharArraysWithHexError(
       "ACCEPT_CH", frame1.data(), frame1.length(),
-      reinterpret_cast<char*>(output1), ABSL_ARRAYSIZE(output1));
+      reinterpret_cast<char*>(output1), std::size(output1));
 
   accept_ch.entries.push_back({"foo", "bar"});
   uint8_t output2[] = {0x40, 0x89,               // type (ACCEPT_CH)
@@ -140,7 +140,7 @@
   std::string frame2 = HttpEncoder::SerializeAcceptChFrame(accept_ch);
   quiche::test::CompareCharArraysWithHexError(
       "ACCEPT_CH", frame2.data(), frame2.length(),
-      reinterpret_cast<char*>(output2), ABSL_ARRAYSIZE(output2));
+      reinterpret_cast<char*>(output2), std::size(output2));
 }
 
 TEST(HttpEncoderTest, SerializeWebTransportStreamFrameHeader) {
@@ -161,7 +161,7 @@
   char output[] = {0x40, 0x4d,  // type (METADATA, 0x4d, varint encoded)
                    0x07};       // length
   quiche::test::CompareCharArraysWithHexError(
-      "METADATA", frame.data(), frame.length(), output, ABSL_ARRAYSIZE(output));
+      "METADATA", frame.data(), frame.length(), output, std::size(output));
 }
 
 }  // namespace test
diff --git a/quiche/quic/core/http/quic_spdy_client_session_test.cc b/quiche/quic/core/http/quic_spdy_client_session_test.cc
index d95a068..d031542 100644
--- a/quiche/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quiche/quic/core/http/quic_spdy_client_session_test.cc
@@ -4,6 +4,7 @@
 
 #include "quiche/quic/core/http/quic_spdy_client_session.h"
 
+#include <iterator>
 #include <memory>
 #include <string>
 #include <utility>
@@ -252,7 +253,7 @@
   // Verify that no data may be send on existing streams.
   char data[] = "hello world";
   QuicConsumedData consumed =
-      session_->WritevData(stream->id(), ABSL_ARRAYSIZE(data), 0, NO_FIN,
+      session_->WritevData(stream->id(), std::size(data), 0, NO_FIN,
                            NOT_RETRANSMISSION, ENCRYPTION_INITIAL);
   EXPECT_EQ(0u, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
diff --git a/quiche/quic/core/http/quic_spdy_session_test.cc b/quiche/quic/core/http/quic_spdy_session_test.cc
index 964dc4d..286cff2 100644
--- a/quiche/quic/core/http/quic_spdy_session_test.cc
+++ b/quiche/quic/core/http/quic_spdy_session_test.cc
@@ -5,6 +5,7 @@
 #include "quiche/quic/core/http/quic_spdy_session.h"
 
 #include <cstdint>
+#include <iterator>
 #include <limits>
 #include <memory>
 #include <optional>
@@ -2495,7 +2496,7 @@
   CompleteHandshake();
   char input[] = {0x04,            // type
                   'a', 'b', 'c'};  // data
-  absl::string_view payload(input, ABSL_ARRAYSIZE(input));
+  absl::string_view payload(input, std::size(input));
 
   // This is a server test with a client-initiated unidirectional stream.
   QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
@@ -2543,7 +2544,7 @@
   CompleteHandshake();
   char input[] = {0x04,            // type
                   'a', 'b', 'c'};  // data
-  absl::string_view payload(input, ABSL_ARRAYSIZE(input));
+  absl::string_view payload(input, std::size(input));
 
   // This is a server test with a client-initiated unidirectional stream.
   QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
@@ -2585,7 +2586,7 @@
   CompleteHandshake();
   char input[] = {0x41, 0x00,      // type (256)
                   'a', 'b', 'c'};  // data
-  absl::string_view payload(input, ABSL_ARRAYSIZE(input));
+  absl::string_view payload(input, std::size(input));
 
   // This is a server test with a client-initiated unidirectional stream.
   QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
@@ -3276,7 +3277,7 @@
       {kQpackEncoderStream, "RESET_STREAM received for QPACK receive stream"},
       {kQpackDecoderStream, "RESET_STREAM received for QPACK receive stream"},
   };
-  for (size_t i = 0; i < ABSL_ARRAYSIZE(kTestData); ++i) {
+  for (size_t i = 0; i < std::size(kTestData); ++i) {
     QuicStreamId stream_id =
         GetNthClientInitiatedUnidirectionalStreamId(transport_version(), i + 1);
     const QuicByteCount data_length = 1;
diff --git a/quiche/quic/core/http/quic_spdy_stream_body_manager_test.cc b/quiche/quic/core/http/quic_spdy_stream_body_manager_test.cc
index 51c458c..82a6932 100644
--- a/quiche/quic/core/http/quic_spdy_stream_body_manager_test.cc
+++ b/quiche/quic/core/http/quic_spdy_stream_body_manager_test.cc
@@ -5,6 +5,7 @@
 #include "quiche/quic/core/http/quic_spdy_stream_body_manager.h"
 
 #include <algorithm>
+#include <iterator>
 #include <numeric>
 #include <string>
 #include <vector>
@@ -79,7 +80,7 @@
   };
 
   for (size_t test_case_index = 0;
-       test_case_index < ABSL_ARRAYSIZE(kOnBodyConsumedTestData);
+       test_case_index < std::size(kOnBodyConsumedTestData);
        ++test_case_index) {
     const std::vector<QuicByteCount>& frame_header_lengths =
         kOnBodyConsumedTestData[test_case_index].frame_header_lengths;
@@ -132,7 +133,7 @@
   };
 
   for (size_t test_case_index = 0;
-       test_case_index < ABSL_ARRAYSIZE(kPeekBodyTestData); ++test_case_index) {
+       test_case_index < std::size(kPeekBodyTestData); ++test_case_index) {
     const std::vector<QuicByteCount>& frame_header_lengths =
         kPeekBodyTestData[test_case_index].frame_header_lengths;
     const std::vector<const char*>& frame_payloads =
@@ -225,7 +226,7 @@
   };
 
   for (size_t test_case_index = 0;
-       test_case_index < ABSL_ARRAYSIZE(kReadBodyTestData); ++test_case_index) {
+       test_case_index < std::size(kReadBodyTestData); ++test_case_index) {
     const std::vector<QuicByteCount>& frame_header_lengths =
         kReadBodyTestData[test_case_index].frame_header_lengths;
     const std::vector<const char*>& frame_payloads =
diff --git a/quiche/quic/core/http/quic_spdy_stream_test.cc b/quiche/quic/core/http/quic_spdy_stream_test.cc
index 85eb62a..6b15642 100644
--- a/quiche/quic/core/http/quic_spdy_stream_test.cc
+++ b/quiche/quic/core/http/quic_spdy_stream_test.cc
@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <array>
 #include <cstring>
+#include <iterator>
 #include <memory>
 #include <string>
 #include <utility>
@@ -257,7 +258,7 @@
       char buffer[2048];
       struct iovec vec;
       vec.iov_base = buffer;
-      vec.iov_len = ABSL_ARRAYSIZE(buffer);
+      vec.iov_len = std::size(buffer);
       size_t bytes_read = Readv(&vec, 1);
       data_ += std::string(buffer, bytes_read);
     }
@@ -871,10 +872,10 @@
   stream_->ConsumeHeaderList();
 
   char buffer[2048];
-  ASSERT_LT(data.length(), ABSL_ARRAYSIZE(buffer));
+  ASSERT_LT(data.length(), std::size(buffer));
   struct iovec vec;
   vec.iov_base = buffer;
-  vec.iov_len = ABSL_ARRAYSIZE(buffer);
+  vec.iov_len = std::size(buffer);
 
   size_t bytes_read = stream_->Readv(&vec, 1);
   QuicStreamPeer::CloseReadSide(stream_);
@@ -896,9 +897,9 @@
   char buffer2[2048];
   struct iovec vec[2];
   vec[0].iov_base = buffer;
-  vec[0].iov_len = ABSL_ARRAYSIZE(buffer);
+  vec[0].iov_len = std::size(buffer);
   vec[1].iov_base = buffer2;
-  vec[1].iov_len = ABSL_ARRAYSIZE(buffer2);
+  vec[1].iov_len = std::size(buffer2);
   size_t bytes_read = stream_->Readv(vec, 2);
   EXPECT_EQ(2048u * 2, bytes_read);
   EXPECT_EQ(body.substr(0, 2048), std::string(buffer, 2048));
@@ -963,7 +964,7 @@
   char buffer[1];
   struct iovec vec;
   vec.iov_base = buffer;
-  vec.iov_len = ABSL_ARRAYSIZE(buffer);
+  vec.iov_len = std::size(buffer);
 
   for (size_t i = 0; i < body.length(); ++i) {
     size_t bytes_read = stream_->Readv(&vec, 1);
@@ -988,9 +989,9 @@
   char buffer2[1];
   struct iovec vec[2];
   vec[0].iov_base = buffer1;
-  vec[0].iov_len = ABSL_ARRAYSIZE(buffer1);
+  vec[0].iov_len = std::size(buffer1);
   vec[1].iov_base = buffer2;
-  vec[1].iov_len = ABSL_ARRAYSIZE(buffer2);
+  vec[1].iov_len = std::size(buffer2);
 
   for (size_t i = 0; i < body.length(); i += 2) {
     size_t bytes_read = stream_->Readv(vec, 2);
@@ -2225,7 +2226,7 @@
   char buffer[2048];
   struct iovec vec;
   vec.iov_base = buffer;
-  vec.iov_len = ABSL_ARRAYSIZE(buffer);
+  vec.iov_len = std::size(buffer);
   size_t bytes_read = stream_->Readv(&vec, 1);
   EXPECT_EQ(kDataFramePayload, absl::string_view(buffer, bytes_read));
 
@@ -3790,7 +3791,7 @@
   char buffer[100];
   struct iovec vec;
   vec.iov_base = buffer;
-  vec.iov_len = ABSL_ARRAYSIZE(buffer);
+  vec.iov_len = std::size(buffer);
 
   size_t bytes_read = stream_->Readv(&vec, 1);
   EXPECT_EQ(0u, bytes_read);