Replace QUICHE_ARRAYSIZE with ABSL_ARRAYSIZE.
PiperOrigin-RevId: 338050307
Change-Id: Ic474ed375a3439cd5c4184b766b541e81a0e4806
diff --git a/quic/core/chlo_extractor_test.cc b/quic/core/chlo_extractor_test.cc
index 3c968be..f051b9a 100644
--- a/quic/core/chlo_extractor_test.cc
+++ b/quic/core/chlo_extractor_test.cc
@@ -8,6 +8,7 @@
#include <string>
#include <utility>
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_framer.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
@@ -15,7 +16,6 @@
#include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/first_flight.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
namespace quic {
namespace test {
@@ -95,7 +95,7 @@
EXPECT_TRUE(packet != nullptr);
size_t encrypted_length =
framer.EncryptPayload(ENCRYPTION_INITIAL, header.packet_number, *packet,
- buffer_, QUICHE_ARRAYSIZE(buffer_));
+ buffer_, ABSL_ARRAYSIZE(buffer_));
ASSERT_NE(0u, encrypted_length);
packet_ = std::make_unique<QuicEncryptedPacket>(buffer_, encrypted_length);
EXPECT_TRUE(packet_ != nullptr);
diff --git a/quic/core/quic_connection_id_test.cc b/quic/core/quic_connection_id_test.cc
index 3fa7c02..84d3090 100644
--- a/quic/core/quic_connection_id_test.cc
+++ b/quic/core/quic_connection_id_test.cc
@@ -8,10 +8,10 @@
#include <cstring>
#include <string>
+#include "absl/base/macros.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
namespace quic {
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 0ccfefe..433ba74 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -11,6 +11,7 @@
#include <string>
#include <utility>
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/congestion_control/loss_detection_interface.h"
#include "net/third_party/quiche/src/quic/core/congestion_control/send_algorithm_interface.h"
@@ -43,7 +44,6 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/simple_data_producer.h"
#include "net/third_party/quiche/src/quic/test_tools/simple_session_notifier.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
using testing::_;
@@ -9988,10 +9988,10 @@
size_t retry_packet_length;
if (version() == ParsedQuicVersion::Draft29()) {
retry_packet = retry_packet29;
- retry_packet_length = QUICHE_ARRAYSIZE(retry_packet29);
+ retry_packet_length = ABSL_ARRAYSIZE(retry_packet29);
} else if (version() == ParsedQuicVersion::Draft27()) {
retry_packet = retry_packet27;
- retry_packet_length = QUICHE_ARRAYSIZE(retry_packet27);
+ retry_packet_length = ABSL_ARRAYSIZE(retry_packet27);
} else {
// TODO(dschinazi) generate retry packets for all versions once we have
// server-side support for generating these programmatically.
@@ -10006,12 +10006,11 @@
QuicConnectionId original_connection_id(
original_connection_id_bytes,
- QUICHE_ARRAYSIZE(original_connection_id_bytes));
+ ABSL_ARRAYSIZE(original_connection_id_bytes));
QuicConnectionId new_connection_id(new_connection_id_bytes,
- QUICHE_ARRAYSIZE(new_connection_id_bytes));
+ ABSL_ARRAYSIZE(new_connection_id_bytes));
- std::string retry_token(retry_token_bytes,
- QUICHE_ARRAYSIZE(retry_token_bytes));
+ std::string retry_token(retry_token_bytes, ABSL_ARRAYSIZE(retry_token_bytes));
if (invalid_retry_tag) {
// Flip the last bit of the retry packet to prevent the integrity tag
diff --git a/quic/core/quic_crypto_client_stream_test.cc b/quic/core/quic_crypto_client_stream_test.cc
index 52791b3..eef6b49 100644
--- a/quic/core/quic_crypto_client_stream_test.cc
+++ b/quic/core/quic_crypto_client_stream_test.cc
@@ -8,6 +8,7 @@
#include <string>
#include <utility>
+#include "absl/base/macros.h"
#include "net/third_party/quiche/src/quic/core/crypto/aes_128_gcm_12_encrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h"
@@ -22,7 +23,6 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/simple_quic_framer.h"
#include "net/third_party/quiche/src/quic/test_tools/simple_session_cache.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h"
using testing::_;
@@ -265,7 +265,7 @@
const std::string& cached_scfg = state->server_config();
quiche::test::CompareCharArraysWithHexError(
"scfg", cached_scfg.data(), cached_scfg.length(),
- reinterpret_cast<char*>(scfg), QUICHE_ARRAYSIZE(scfg));
+ reinterpret_cast<char*>(scfg), ABSL_ARRAYSIZE(scfg));
QuicStreamSequencer* sequencer = QuicStreamPeer::sequencer(stream());
EXPECT_FALSE(QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(sequencer));
diff --git a/quic/core/quic_crypto_server_stream.cc b/quic/core/quic_crypto_server_stream.cc
index 9d7597c..4c21e55 100644
--- a/quic/core/quic_crypto_server_stream.cc
+++ b/quic/core/quic_crypto_server_stream.cc
@@ -7,10 +7,10 @@
#include <memory>
#include <string>
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "third_party/boringssl/src/include/openssl/sha.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
namespace quic {
@@ -355,8 +355,7 @@
SHA256(reinterpret_cast<const uint8_t*>(channel_id.data()), channel_id.size(),
digest);
- quiche::QuicheTextUtils::Base64Encode(digest, QUICHE_ARRAYSIZE(digest),
- output);
+ quiche::QuicheTextUtils::Base64Encode(digest, ABSL_ARRAYSIZE(digest), output);
return true;
}
diff --git a/quic/core/quic_data_writer_test.cc b/quic/core/quic_data_writer_test.cc
index 28203d6..ef83ac8 100644
--- a/quic/core/quic_data_writer_test.cc
+++ b/quic/core/quic_data_writer_test.cc
@@ -7,6 +7,7 @@
#include <cstdint>
#include <cstring>
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
#include "net/third_party/quiche/src/quic/core/quic_data_reader.h"
@@ -16,7 +17,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
#include "net/third_party/quiche/src/common/quiche_endian.h"
#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h"
@@ -269,7 +269,7 @@
char big_endian[] = {
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
};
- EXPECT_EQ(connection_id.length(), QUICHE_ARRAYSIZE(big_endian));
+ EXPECT_EQ(connection_id.length(), ABSL_ARRAYSIZE(big_endian));
ASSERT_LE(connection_id.length(), 255);
char buffer[255];
QuicDataWriter writer(connection_id.length(), buffer, GetParam().endianness);
@@ -280,8 +280,8 @@
QuicConnectionId read_connection_id;
QuicDataReader reader(buffer, connection_id.length(), GetParam().endianness);
- EXPECT_TRUE(reader.ReadConnectionId(&read_connection_id,
- QUICHE_ARRAYSIZE(big_endian)));
+ EXPECT_TRUE(
+ reader.ReadConnectionId(&read_connection_id, ABSL_ARRAYSIZE(big_endian)));
EXPECT_EQ(connection_id, read_connection_id);
}
@@ -291,35 +291,35 @@
char length_prefixed_connection_id[] = {
0x08, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
};
- EXPECT_EQ(QUICHE_ARRAYSIZE(length_prefixed_connection_id),
+ EXPECT_EQ(ABSL_ARRAYSIZE(length_prefixed_connection_id),
kConnectionIdLengthSize + connection_id.length());
char buffer[kConnectionIdLengthSize + 255] = {};
- QuicDataWriter writer(QUICHE_ARRAYSIZE(buffer), buffer);
+ QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer);
EXPECT_TRUE(writer.WriteLengthPrefixedConnectionId(connection_id));
quiche::test::CompareCharArraysWithHexError(
"WriteLengthPrefixedConnectionId", buffer, writer.length(),
length_prefixed_connection_id,
- QUICHE_ARRAYSIZE(length_prefixed_connection_id));
+ ABSL_ARRAYSIZE(length_prefixed_connection_id));
// Verify that writing length then connection ID produces the same output.
- memset(buffer, 0, QUICHE_ARRAYSIZE(buffer));
- QuicDataWriter writer2(QUICHE_ARRAYSIZE(buffer), buffer);
+ memset(buffer, 0, ABSL_ARRAYSIZE(buffer));
+ QuicDataWriter writer2(ABSL_ARRAYSIZE(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,
- QUICHE_ARRAYSIZE(length_prefixed_connection_id));
+ ABSL_ARRAYSIZE(length_prefixed_connection_id));
QuicConnectionId read_connection_id;
- QuicDataReader reader(buffer, QUICHE_ARRAYSIZE(buffer));
+ QuicDataReader reader(buffer, ABSL_ARRAYSIZE(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, QUICHE_ARRAYSIZE(buffer));
+ QuicDataReader reader2(buffer, ABSL_ARRAYSIZE(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,
@@ -330,8 +330,7 @@
TEST_P(QuicDataWriterTest, EmptyConnectionIds) {
QuicConnectionId empty_connection_id = EmptyQuicConnectionId();
char buffer[2];
- QuicDataWriter writer(QUICHE_ARRAYSIZE(buffer), buffer,
- GetParam().endianness);
+ QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer, GetParam().endianness);
EXPECT_TRUE(writer.WriteConnectionId(empty_connection_id));
EXPECT_TRUE(writer.WriteUInt8(1));
EXPECT_TRUE(writer.WriteConnectionId(empty_connection_id));
@@ -344,8 +343,7 @@
QuicConnectionId read_connection_id = TestConnectionId();
uint8_t read_byte;
- QuicDataReader reader(buffer, QUICHE_ARRAYSIZE(buffer),
- GetParam().endianness);
+ QuicDataReader reader(buffer, ABSL_ARRAYSIZE(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));
@@ -663,10 +661,10 @@
TEST_P(QuicDataWriterTest, WriteBytes) {
char bytes[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
- char buf[QUICHE_ARRAYSIZE(bytes)];
- QuicDataWriter writer(QUICHE_ARRAYSIZE(buf), buf, GetParam().endianness);
- EXPECT_TRUE(writer.WriteBytes(bytes, QUICHE_ARRAYSIZE(bytes)));
- for (unsigned int i = 0; i < QUICHE_ARRAYSIZE(bytes); ++i) {
+ 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) {
EXPECT_EQ(bytes[i], buf[i]);
}
}
@@ -1178,14 +1176,13 @@
TEST_P(QuicDataWriterTest, Seek) {
char buffer[3] = {};
- QuicDataWriter writer(QUICHE_ARRAYSIZE(buffer), buffer,
- GetParam().endianness);
+ QuicDataWriter writer(ABSL_ARRAYSIZE(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 < QUICHE_ARRAYSIZE(expected); ++i) {
+ for (size_t i = 0; i < ABSL_ARRAYSIZE(expected); ++i) {
EXPECT_EQ(buffer[i], expected[i]);
}
}
@@ -1195,7 +1192,7 @@
// Check that one can seek to the end of the writer, but not past.
{
- QuicDataWriter writer(QUICHE_ARRAYSIZE(buffer), buffer,
+ QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer,
GetParam().endianness);
EXPECT_TRUE(writer.Seek(20));
EXPECT_FALSE(writer.Seek(1));
@@ -1203,14 +1200,14 @@
// Seeking several bytes past the end fails.
{
- QuicDataWriter writer(QUICHE_ARRAYSIZE(buffer), buffer,
+ QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer,
GetParam().endianness);
EXPECT_FALSE(writer.Seek(100));
}
// Seeking so far that arithmetic overflow could occur also fails.
{
- QuicDataWriter writer(QUICHE_ARRAYSIZE(buffer), buffer,
+ QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer,
GetParam().endianness);
EXPECT_TRUE(writer.Seek(10));
EXPECT_FALSE(writer.Seek(std::numeric_limits<size_t>::max()));
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index bfeb0d4..a88eadb 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -9,6 +9,7 @@
#include <string>
#include <utility>
+#include "absl/base/macros.h"
#include "net/third_party/quiche/src/quic/core/chlo_extractor.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
@@ -36,7 +37,6 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_time_wait_list_manager_peer.h"
#include "net/third_party/quiche/src/quic/tools/quic_simple_crypto_server_stream_helper.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h"
@@ -1088,7 +1088,7 @@
CreateTimeWaitListManager();
char packet[kMinPacketSizeForVersionNegotiation] = {
0xC0, 0xFF, 0x00, 0x00, 28, /*destination connection ID length*/ 0x08};
- QuicReceivedPacket received_packet(packet, QUICHE_ARRAYSIZE(packet),
+ QuicReceivedPacket received_packet(packet, ABSL_ARRAYSIZE(packet),
QuicTime::Zero());
EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
EXPECT_CALL(
@@ -1105,7 +1105,7 @@
CreateTimeWaitListManager();
char packet[kMinPacketSizeForVersionNegotiation] = {
0xC0, 0xFF, 0x00, 0x00, 25, /*destination connection ID length*/ 0x08};
- QuicReceivedPacket received_packet(packet, QUICHE_ARRAYSIZE(packet),
+ QuicReceivedPacket received_packet(packet, ABSL_ARRAYSIZE(packet),
QuicTime::Zero());
EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
EXPECT_CALL(
@@ -1122,7 +1122,7 @@
CreateTimeWaitListManager();
char packet[kMinPacketSizeForVersionNegotiation] = {
0xC0, 'Q', '0', '4', '9', /*destination connection ID length*/ 0x08};
- QuicReceivedPacket received_packet(packet, QUICHE_ARRAYSIZE(packet),
+ QuicReceivedPacket received_packet(packet, ABSL_ARRAYSIZE(packet),
QuicTime::Zero());
EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
EXPECT_CALL(
@@ -1139,7 +1139,7 @@
CreateTimeWaitListManager();
char packet[kMinPacketSizeForVersionNegotiation] = {
0xC0, 'Q', '0', '4', '8', /*connection ID length byte*/ 0x50};
- QuicReceivedPacket received_packet(packet, QUICHE_ARRAYSIZE(packet),
+ QuicReceivedPacket received_packet(packet, ABSL_ARRAYSIZE(packet),
QuicTime::Zero());
EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
EXPECT_CALL(
@@ -1156,7 +1156,7 @@
CreateTimeWaitListManager();
char packet[kMinPacketSizeForVersionNegotiation] = {
0xC0, 'Q', '0', '4', '7', /*connection ID length byte*/ 0x50};
- QuicReceivedPacket received_packet(packet, QUICHE_ARRAYSIZE(packet),
+ QuicReceivedPacket received_packet(packet, ABSL_ARRAYSIZE(packet),
QuicTime::Zero());
EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
EXPECT_CALL(
@@ -1173,7 +1173,7 @@
CreateTimeWaitListManager();
char packet[kMinPacketSizeForVersionNegotiation] = {
0xC0, 'Q', '0', '4', '5', /*connection ID length byte*/ 0x50};
- QuicReceivedPacket received_packet(packet, QUICHE_ARRAYSIZE(packet),
+ QuicReceivedPacket received_packet(packet, ABSL_ARRAYSIZE(packet),
QuicTime::Zero());
EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _)).Times(0);
EXPECT_CALL(
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 884f7eb..19b0cd5 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -11,6 +11,7 @@
#include <string>
#include <utility>
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
@@ -44,7 +45,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_stack_trace.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
@@ -1492,10 +1492,10 @@
QUIC_CACHELINE_ALIGNED char buffer[kMaxIncomingPacketSize];
if (packet_has_ietf_packet_header) {
rv = ProcessIetfDataPacket(&reader, &header, packet, buffer,
- QUICHE_ARRAYSIZE(buffer));
+ ABSL_ARRAYSIZE(buffer));
} else {
rv = ProcessDataPacket(&reader, &header, packet, buffer,
- QUICHE_ARRAYSIZE(buffer));
+ ABSL_ARRAYSIZE(buffer));
}
} else {
std::unique_ptr<char[]> large_buffer(new char[packet.length()]);
@@ -4512,7 +4512,7 @@
static_cast<QuicPacketNumberLength>((header->type_byte & 0x03) + 1);
char pn_buffer[IETF_MAX_PACKET_NUMBER_LENGTH] = {};
- QuicDataWriter pn_writer(QUICHE_ARRAYSIZE(pn_buffer), pn_buffer);
+ QuicDataWriter pn_writer(ABSL_ARRAYSIZE(pn_buffer), pn_buffer);
// Read the (protected) packet number from the reader and unmask the packet
// number.
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index f0f2de0..ab61814 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -12,6 +12,7 @@
#include <utility>
#include <vector>
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/null_decrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
@@ -31,7 +32,6 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_framer_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/simple_data_producer.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h"
@@ -1053,10 +1053,10 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
const size_t header_size = GetPacketHeaderSize(
@@ -1252,10 +1252,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_length = QUICHE_ARRAYSIZE(packet);
+ size_t p_length = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
- p_length = QUICHE_ARRAYSIZE(packet49);
+ p_length = ABSL_ARRAYSIZE(packet49);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -1337,13 +1337,13 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_length = QUICHE_ARRAYSIZE(packet);
+ size_t p_length = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
- p_length = QUICHE_ARRAYSIZE(packet49);
+ p_length = ABSL_ARRAYSIZE(packet49);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_length = QUICHE_ARRAYSIZE(packet46);
+ p_length = ABSL_ARRAYSIZE(packet46);
}
uint8_t first_byte = 0x33;
@@ -1414,7 +1414,7 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_length = QUICHE_ARRAYSIZE(packet);
+ size_t p_length = ABSL_ARRAYSIZE(packet);
uint8_t first_byte = 0x33;
PacketHeaderFormat format = GOOGLE_QUIC_PACKET;
@@ -1471,8 +1471,7 @@
0x00,
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet), QUICHE_ARRAYSIZE(packet),
- false);
+ QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
EXPECT_EQ("", framer_.detailed_error());
@@ -1506,8 +1505,7 @@
0x00,
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet), QUICHE_ARRAYSIZE(packet),
- false);
+ QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
EXPECT_EQ("", framer_.detailed_error());
@@ -1995,13 +1993,13 @@
}
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
- p_size = QUICHE_ARRAYSIZE(packet49);
+ p_size = ABSL_ARRAYSIZE(packet49);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -2070,13 +2068,13 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
- p_size = QUICHE_ARRAYSIZE(packet49);
+ p_size = ABSL_ARRAYSIZE(packet49);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -2173,13 +2171,13 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -2442,13 +2440,13 @@
// clang-format on
unsigned char* p = packet;
- size_t p_length = QUICHE_ARRAYSIZE(packet);
+ size_t p_length = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
- p_length = QUICHE_ARRAYSIZE(packet49);
+ p_length = ABSL_ARRAYSIZE(packet49);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_length = QUICHE_ARRAYSIZE(packet46);
+ p_length = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
@@ -3025,8 +3023,8 @@
}
QuicEncryptedPacket encrypted(AsChars(p),
framer_.version().HasIetfInvariantHeader()
- ? QUICHE_ARRAYSIZE(packet46)
- : QUICHE_ARRAYSIZE(packet),
+ ? ABSL_ARRAYSIZE(packet46)
+ : ABSL_ARRAYSIZE(packet),
false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -3064,8 +3062,8 @@
QuicEncryptedPacket encrypted(
framer_.version().HasIetfInvariantHeader() ? AsChars(packet46)
: AsChars(packet),
- framer_.version().HasIetfInvariantHeader() ? QUICHE_ARRAYSIZE(packet46)
- : QUICHE_ARRAYSIZE(packet),
+ framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
+ : ABSL_ARRAYSIZE(packet),
false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -4080,7 +4078,7 @@
}
QuicEncryptedPacket encrypted(
AsChars(framer_.version().HasIetfInvariantHeader() ? packet46 : packet),
- QUICHE_ARRAYSIZE(packet), false);
+ ABSL_ARRAYSIZE(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
EXPECT_TRUE(quiche::QuicheTextUtils::StartsWith(
framer_.detailed_error(), "delta_from_largest_observed too high"));
@@ -4153,7 +4151,7 @@
}
QuicEncryptedPacket encrypted(
AsChars(framer_.version().HasIetfInvariantHeader() ? packet46 : packet),
- QUICHE_ARRAYSIZE(packet), false);
+ ABSL_ARRAYSIZE(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
EXPECT_TRUE(quiche::QuicheTextUtils::StartsWith(
framer_.detailed_error(), "delta_from_largest_observed too high"));
@@ -4262,8 +4260,8 @@
QuicEncryptedPacket encrypted(
AsChars(framer_.version().HasIetfInvariantHeader() ? packet46 : packet),
- framer_.version().HasIetfInvariantHeader() ? QUICHE_ARRAYSIZE(packet46)
- : QUICHE_ARRAYSIZE(packet),
+ framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
+ : ABSL_ARRAYSIZE(packet),
false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_STOP_WAITING_DATA));
@@ -5364,10 +5362,10 @@
: (framer_.version().HasIetfInvariantHeader() ? packet46
: packet)),
VersionHasIetfQuicFrames(framer_.transport_version())
- ? QUICHE_ARRAYSIZE(packet99)
+ ? ABSL_ARRAYSIZE(packet99)
: (framer_.version().HasIetfInvariantHeader()
- ? QUICHE_ARRAYSIZE(packet46)
- : QUICHE_ARRAYSIZE(packet)),
+ ? ABSL_ARRAYSIZE(packet46)
+ : ABSL_ARRAYSIZE(packet)),
false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -5402,8 +5400,7 @@
return;
}
- QuicEncryptedPacket encrypted(AsChars(packet), QUICHE_ARRAYSIZE(packet),
- false);
+ QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -5443,8 +5440,7 @@
return;
}
- QuicEncryptedPacket encrypted(AsChars(packet), QUICHE_ARRAYSIZE(packet),
- false);
+ QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -5686,8 +5682,7 @@
return;
}
- QuicEncryptedPacket encrypted(AsChars(packet), QUICHE_ARRAYSIZE(packet),
- false);
+ QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
ASSERT_THAT(framer_.error(), IsError(QUIC_INVALID_PUBLIC_RST_PACKET));
EXPECT_EQ("Unable to read reset message.", framer_.detailed_error());
@@ -5788,8 +5783,7 @@
ENCRYPTION_ZERO_RTT, std::unique_ptr<QuicDecrypter>(decrypter_), false);
}
// This packet cannot be decrypted because diversification nonce is missing.
- QuicEncryptedPacket encrypted(AsChars(packet), QUICHE_ARRAYSIZE(packet),
- false);
+ QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
ASSERT_THAT(framer_.error(), IsQuicNoError());
ASSERT_TRUE(visitor_.stateless_reset_packet_.get());
@@ -5832,8 +5826,7 @@
ENCRYPTION_ZERO_RTT, std::unique_ptr<QuicDecrypter>(decrypter_), false);
}
// This packet cannot be decrypted because diversification nonce is missing.
- QuicEncryptedPacket encrypted(AsChars(packet), QUICHE_ARRAYSIZE(packet),
- false);
+ QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsError(QUIC_DECRYPTION_FAILURE));
ASSERT_FALSE(visitor_.stateless_reset_packet_);
@@ -5953,10 +5946,10 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_length = QUICHE_ARRAYSIZE(packet);
+ size_t p_length = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasLengthPrefixedConnectionIds()) {
p = packet2;
- p_length = QUICHE_ARRAYSIZE(packet2);
+ p_length = ABSL_ARRAYSIZE(packet2);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -6069,13 +6062,13 @@
// clang-format on
unsigned char* p = packet;
- size_t p_length = QUICHE_ARRAYSIZE(packet);
+ size_t p_length = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasRetryIntegrityTag()) {
p = packet_with_tag;
- p_length = QUICHE_ARRAYSIZE(packet_with_tag);
+ p_length = ABSL_ARRAYSIZE(packet_with_tag);
} else if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
- p_length = QUICHE_ARRAYSIZE(packet49);
+ p_length = ABSL_ARRAYSIZE(packet49);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -6097,7 +6090,7 @@
"retry integrity tag", visitor_.retry_token_integrity_tag_->data(),
visitor_.retry_token_integrity_tag_->length(),
reinterpret_cast<const char*>(expected_integrity_tag),
- QUICHE_ARRAYSIZE(expected_integrity_tag));
+ ABSL_ARRAYSIZE(expected_integrity_tag));
ASSERT_TRUE(visitor_.retry_without_tag_.get());
quiche::test::CompareCharArraysWithHexError(
"retry without tag", visitor_.retry_without_tag_->data(),
@@ -6206,8 +6199,8 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p),
- framer_.version().HasIetfInvariantHeader() ? QUICHE_ARRAYSIZE(packet46)
- : QUICHE_ARRAYSIZE(packet));
+ framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
+ : ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, BuildStreamFramePacketWithNewPaddingFrame) {
@@ -6310,13 +6303,13 @@
ASSERT_TRUE(data != nullptr);
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -6395,8 +6388,8 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p),
- framer_.version().HasIetfInvariantHeader() ? QUICHE_ARRAYSIZE(packet46)
- : QUICHE_ARRAYSIZE(packet));
+ framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
+ : ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, Build2ByteSequenceNumberPaddingFramePacket) {
@@ -6470,8 +6463,8 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p),
- framer_.version().HasIetfInvariantHeader() ? QUICHE_ARRAYSIZE(packet46)
- : QUICHE_ARRAYSIZE(packet));
+ framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
+ : ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, Build1ByteSequenceNumberPaddingFramePacket) {
@@ -6545,8 +6538,8 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p),
- framer_.version().HasIetfInvariantHeader() ? QUICHE_ARRAYSIZE(packet46)
- : QUICHE_ARRAYSIZE(packet));
+ framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
+ : ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, BuildStreamFramePacket) {
@@ -6634,13 +6627,13 @@
ASSERT_TRUE(data != nullptr);
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p), p_size);
@@ -6764,16 +6757,16 @@
ASSERT_TRUE(data != nullptr);
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
- p_size = QUICHE_ARRAYSIZE(packet49);
+ p_size = ABSL_ARRAYSIZE(packet49);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p), p_size);
@@ -6846,10 +6839,10 @@
// clang-format on
unsigned char* packet = packet48;
- size_t packet_size = QUICHE_ARRAYSIZE(packet48);
+ size_t packet_size = ABSL_ARRAYSIZE(packet48);
if (framer_.version().HasIetfQuicFrames()) {
packet = packet99;
- packet_size = QUICHE_ARRAYSIZE(packet99);
+ packet_size = ABSL_ARRAYSIZE(packet99);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -6985,13 +6978,13 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
- p_size = QUICHE_ARRAYSIZE(packet49);
+ p_size = ABSL_ARRAYSIZE(packet49);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
QuicConnectionId connection_id = FramerTestConnectionId();
@@ -7038,7 +7031,7 @@
SupportedVersions(GetParam())));
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- QUICHE_ARRAYSIZE(packet));
+ ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, BuildAckFramePacketOneAckBlock) {
@@ -7119,13 +7112,13 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -7212,13 +7205,13 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -7360,13 +7353,13 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -7669,13 +7662,13 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -7723,7 +7716,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- QUICHE_ARRAYSIZE(packet));
+ ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, BuildRstFramePacketQuic) {
@@ -7807,13 +7800,13 @@
ASSERT_TRUE(data != nullptr);
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -7901,13 +7894,13 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8007,13 +8000,13 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8188,13 +8181,13 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8252,7 +8245,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet99),
- QUICHE_ARRAYSIZE(packet99));
+ ABSL_ARRAYSIZE(packet99));
}
TEST_P(QuicFramerTest, BuildTruncatedApplicationCloseFramePacket) {
@@ -8333,7 +8326,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet99),
- QUICHE_ARRAYSIZE(packet99));
+ ABSL_ARRAYSIZE(packet99));
}
TEST_P(QuicFramerTest, BuildGoAwayPacket) {
@@ -8405,10 +8398,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8542,10 +8535,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8626,13 +8619,13 @@
ASSERT_TRUE(data != nullptr);
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
quiche::test::CompareCharArraysWithHexError(
@@ -8681,7 +8674,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet99),
- QUICHE_ARRAYSIZE(packet99));
+ ABSL_ARRAYSIZE(packet99));
}
TEST_P(QuicFramerTest, BuildMaxDataPacket) {
@@ -8725,7 +8718,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet99),
- QUICHE_ARRAYSIZE(packet99));
+ ABSL_ARRAYSIZE(packet99));
}
TEST_P(QuicFramerTest, BuildBlockedPacket) {
@@ -8798,13 +8791,13 @@
ASSERT_TRUE(data != nullptr);
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
quiche::test::CompareCharArraysWithHexError(
@@ -8871,8 +8864,8 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p),
- framer_.version().HasIetfInvariantHeader() ? QUICHE_ARRAYSIZE(packet46)
- : QUICHE_ARRAYSIZE(packet));
+ framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
+ : ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, BuildHandshakeDonePacket) {
@@ -8906,7 +8899,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- QUICHE_ARRAYSIZE(packet));
+ ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, BuildAckFrequencyPacket) {
@@ -8953,7 +8946,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- QUICHE_ARRAYSIZE(packet));
+ ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, BuildMessagePacket) {
@@ -9024,7 +9017,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p),
- QUICHE_ARRAYSIZE(packet46));
+ ABSL_ARRAYSIZE(packet46));
}
// Test that the MTU discovery packet is serialized correctly as a PING packet.
@@ -9088,8 +9081,8 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p),
- framer_.version().HasIetfInvariantHeader() ? QUICHE_ARRAYSIZE(packet46)
- : QUICHE_ARRAYSIZE(packet));
+ framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
+ : ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, BuildPublicResetPacket) {
@@ -9126,7 +9119,7 @@
ASSERT_TRUE(data != nullptr);
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- QUICHE_ARRAYSIZE(packet));
+ ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, BuildPublicResetPacketWithClientAddress) {
@@ -9175,7 +9168,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- QUICHE_ARRAYSIZE(packet));
+ ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, BuildPublicResetPacketWithEndpointId) {
@@ -9249,11 +9242,11 @@
if ('d' == data->data()[data->length() - 1]) {
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(),
- AsChars(packet_variant1), QUICHE_ARRAYSIZE(packet_variant1));
+ AsChars(packet_variant1), ABSL_ARRAYSIZE(packet_variant1));
} else {
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(),
- AsChars(packet_variant2), QUICHE_ARRAYSIZE(packet_variant2));
+ AsChars(packet_variant2), ABSL_ARRAYSIZE(packet_variant2));
}
}
@@ -9285,7 +9278,7 @@
"constructed packet",
data->data() + data->length() - sizeof(kTestStatelessResetToken),
sizeof(kTestStatelessResetToken),
- AsChars(packet) + QUICHE_ARRAYSIZE(packet) -
+ AsChars(packet) + ABSL_ARRAYSIZE(packet) -
sizeof(kTestStatelessResetToken),
sizeof(kTestStatelessResetToken));
}
@@ -9341,10 +9334,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasHeaderProtection()) {
p = packet50;
- p_size = QUICHE_ARRAYSIZE(packet50);
+ p_size = ABSL_ARRAYSIZE(packet50);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
}
@@ -9444,14 +9437,14 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
// TODO(ianswett): see todo in previous test.
if (framer_.version().HasHeaderProtection()) {
p = packet50;
- p_size = QUICHE_ARRAYSIZE(packet50);
+ p_size = ABSL_ARRAYSIZE(packet50);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> raw(new QuicPacket(
@@ -9777,13 +9770,13 @@
EXPECT_CALL(visitor, OnDecryptedPacket(_));
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -9968,7 +9961,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet99),
- QUICHE_ARRAYSIZE(packet99));
+ ABSL_ARRAYSIZE(packet99));
}
TEST_P(QuicFramerTest, IetfStreamBlockedFrame) {
@@ -10056,7 +10049,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet99),
- QUICHE_ARRAYSIZE(packet99));
+ ABSL_ARRAYSIZE(packet99));
}
TEST_P(QuicFramerTest, BiDiMaxStreamsFrame) {
@@ -10256,7 +10249,7 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet99), QUICHE_ARRAYSIZE(packet99),
+ QuicEncryptedPacket encrypted(AsChars(packet99), ABSL_ARRAYSIZE(packet99),
false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -10293,7 +10286,7 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet99), QUICHE_ARRAYSIZE(packet99),
+ QuicEncryptedPacket encrypted(AsChars(packet99), ABSL_ARRAYSIZE(packet99),
false);
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -10333,7 +10326,7 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet99), QUICHE_ARRAYSIZE(packet99),
+ QuicEncryptedPacket encrypted(AsChars(packet99), ABSL_ARRAYSIZE(packet99),
false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -10371,7 +10364,7 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet99), QUICHE_ARRAYSIZE(packet99),
+ QuicEncryptedPacket encrypted(AsChars(packet99), ABSL_ARRAYSIZE(packet99),
false);
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -10409,7 +10402,7 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet99), QUICHE_ARRAYSIZE(packet99),
+ QuicEncryptedPacket encrypted(AsChars(packet99), ABSL_ARRAYSIZE(packet99),
false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
}
@@ -10614,7 +10607,7 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet99), QUICHE_ARRAYSIZE(packet99),
+ QuicEncryptedPacket encrypted(AsChars(packet99), ABSL_ARRAYSIZE(packet99),
false);
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
@@ -10709,7 +10702,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet99),
- QUICHE_ARRAYSIZE(packet99));
+ ABSL_ARRAYSIZE(packet99));
}
TEST_P(QuicFramerTest, BuildUniStreamsBlockedPacket) {
@@ -10751,7 +10744,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet99),
- QUICHE_ARRAYSIZE(packet99));
+ ABSL_ARRAYSIZE(packet99));
}
TEST_P(QuicFramerTest, BuildBiDiMaxStreamsPacket) {
@@ -10793,7 +10786,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet99),
- QUICHE_ARRAYSIZE(packet99));
+ ABSL_ARRAYSIZE(packet99));
}
TEST_P(QuicFramerTest, BuildUniDiMaxStreamsPacket) {
@@ -10838,7 +10831,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet99),
- QUICHE_ARRAYSIZE(packet99));
+ ABSL_ARRAYSIZE(packet99));
}
TEST_P(QuicFramerTest, NewConnectionIdFrame) {
@@ -11107,7 +11100,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet99),
- QUICHE_ARRAYSIZE(packet99));
+ ABSL_ARRAYSIZE(packet99));
}
TEST_P(QuicFramerTest, NewTokenFrame) {
@@ -11201,7 +11194,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- QUICHE_ARRAYSIZE(packet));
+ ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, IetfStopSendingFrame) {
@@ -11298,7 +11291,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet99),
- QUICHE_ARRAYSIZE(packet99));
+ ABSL_ARRAYSIZE(packet99));
}
TEST_P(QuicFramerTest, IetfPathChallengeFrame) {
@@ -11381,7 +11374,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet99),
- QUICHE_ARRAYSIZE(packet99));
+ ABSL_ARRAYSIZE(packet99));
}
TEST_P(QuicFramerTest, IetfPathResponseFrame) {
@@ -11464,7 +11457,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet99),
- QUICHE_ARRAYSIZE(packet99));
+ ABSL_ARRAYSIZE(packet99));
}
TEST_P(QuicFramerTest, GetRetransmittableControlFrameSize) {
@@ -12269,7 +12262,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet99),
- QUICHE_ARRAYSIZE(packet99));
+ ABSL_ARRAYSIZE(packet99));
}
TEST_P(QuicFramerTest, AckFrameWithInvalidLargestObserved) {
@@ -12337,10 +12330,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
}
@@ -12415,13 +12408,13 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -12523,13 +12516,13 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = QUICHE_ARRAYSIZE(packet);
+ size_t p_size = ABSL_ARRAYSIZE(packet);
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet99;
- p_size = QUICHE_ARRAYSIZE(packet99);
+ p_size = ABSL_ARRAYSIZE(packet99);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_size = QUICHE_ARRAYSIZE(packet46);
+ p_size = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -12670,10 +12663,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_length = QUICHE_ARRAYSIZE(packet);
+ size_t p_length = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasIetfQuicFrames()) {
p = packet99;
- p_length = QUICHE_ARRAYSIZE(packet99);
+ p_length = ABSL_ARRAYSIZE(packet99);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -12789,10 +12782,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_length = QUICHE_ARRAYSIZE(packet);
+ size_t p_length = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasIetfQuicFrames()) {
p = packet99;
- p_length = QUICHE_ARRAYSIZE(packet99);
+ p_length = ABSL_ARRAYSIZE(packet99);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -12940,10 +12933,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_length = QUICHE_ARRAYSIZE(packet);
+ size_t p_length = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasIetfQuicFrames()) {
p = packet99;
- p_length = QUICHE_ARRAYSIZE(packet99);
+ p_length = ABSL_ARRAYSIZE(packet99);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -13047,13 +13040,13 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_length = QUICHE_ARRAYSIZE(packet);
+ size_t p_length = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
- p_length = QUICHE_ARRAYSIZE(packet49);
+ p_length = ABSL_ARRAYSIZE(packet49);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_length = QUICHE_ARRAYSIZE(packet46);
+ p_length = ABSL_ARRAYSIZE(packet46);
}
// First attempt decryption without the handshake crypter.
EXPECT_FALSE(
@@ -13149,13 +13142,13 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_length = QUICHE_ARRAYSIZE(packet);
+ size_t p_length = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
- p_length = QUICHE_ARRAYSIZE(packet49);
+ p_length = ABSL_ARRAYSIZE(packet49);
} else if (framer_.version().HasIetfInvariantHeader()) {
p = packet46;
- p_length = QUICHE_ARRAYSIZE(packet46);
+ p_length = ABSL_ARRAYSIZE(packet46);
}
EXPECT_FALSE(
@@ -13313,10 +13306,10 @@
const size_t length_of_first_coalesced_packet = 46;
unsigned char* p = packet;
- size_t p_length = QUICHE_ARRAYSIZE(packet);
+ size_t p_length = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasIetfQuicFrames()) {
p = packet99;
- p_length = QUICHE_ARRAYSIZE(packet99);
+ p_length = ABSL_ARRAYSIZE(packet99);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -13480,10 +13473,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_length = QUICHE_ARRAYSIZE(packet);
+ size_t p_length = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasIetfQuicFrames()) {
p = packet99;
- p_length = QUICHE_ARRAYSIZE(packet99);
+ p_length = ABSL_ARRAYSIZE(packet99);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -13585,10 +13578,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_length = QUICHE_ARRAYSIZE(packet);
+ size_t p_length = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasIetfQuicFrames()) {
p = packet99;
- p_length = QUICHE_ARRAYSIZE(packet99);
+ p_length = ABSL_ARRAYSIZE(packet99);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -13647,7 +13640,7 @@
unsigned char packet[kMaxOutgoingPacketSize] = {};
size_t encrypted_length =
framer_.EncryptPayload(ENCRYPTION_INITIAL, header.packet_number, *data,
- AsChars(packet), QUICHE_ARRAYSIZE(packet));
+ AsChars(packet), ABSL_ARRAYSIZE(packet));
ASSERT_NE(0u, encrypted_length);
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_SERVER);
@@ -13659,8 +13652,7 @@
std::move(server_crypters.decrypter));
// Make sure the first long header initial packet parses correctly.
- QuicEncryptedPacket encrypted(AsChars(packet), QUICHE_ARRAYSIZE(packet),
- false);
+ QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
// Make sure we discard the subsequent zeroes.
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -13690,8 +13682,7 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet), QUICHE_ARRAYSIZE(packet),
- false);
+ QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_VERSION));
@@ -13814,11 +13805,11 @@
if (!QuicVersionHasLongHeaderLengths(framer_.transport_version())) {
EXPECT_TRUE(framer_.ProcessPacket(
QuicEncryptedPacket(AsChars(long_header_packet),
- QUICHE_ARRAYSIZE(long_header_packet), false)));
+ ABSL_ARRAYSIZE(long_header_packet), false)));
} else {
EXPECT_TRUE(framer_.ProcessPacket(
QuicEncryptedPacket(AsChars(long_header_packet99),
- QUICHE_ARRAYSIZE(long_header_packet99), false)));
+ ABSL_ARRAYSIZE(long_header_packet99), false)));
}
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -13845,8 +13836,7 @@
// clang-format on
QuicEncryptedPacket short_header_encrypted(
- AsChars(short_header_packet), QUICHE_ARRAYSIZE(short_header_packet),
- false);
+ AsChars(short_header_packet), ABSL_ARRAYSIZE(short_header_packet), false);
if (framer_.version().KnowsWhichDecrypterToUse()) {
framer_.InstallDecrypter(ENCRYPTION_FORWARD_SECURE,
std::make_unique<TestDecrypter>());
@@ -14348,10 +14338,10 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_length = QUICHE_ARRAYSIZE(packet);
+ size_t p_length = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
- p_length = QUICHE_ARRAYSIZE(packet49);
+ p_length = ABSL_ARRAYSIZE(packet49);
}
const bool parse_success =
framer_.ProcessPacket(QuicEncryptedPacket(AsChars(p), p_length, false));
@@ -14413,10 +14403,10 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_length = QUICHE_ARRAYSIZE(packet);
+ size_t p_length = ABSL_ARRAYSIZE(packet);
if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
- p_length = QUICHE_ARRAYSIZE(packet49);
+ p_length = ABSL_ARRAYSIZE(packet49);
}
const bool parse_success =
framer_.ProcessPacket(QuicEncryptedPacket(AsChars(p), p_length, false));
@@ -14628,8 +14618,8 @@
};
// clang-format on
- framer_.ProcessPacket(QuicEncryptedPacket(AsChars(packet99),
- QUICHE_ARRAYSIZE(packet99), false));
+ framer_.ProcessPacket(
+ QuicEncryptedPacket(AsChars(packet99), ABSL_ARRAYSIZE(packet99), false));
ASSERT_EQ(1u, visitor_.ack_frames_.size());
// Verify ack_delay_time is set correctly.
EXPECT_EQ(QuicTime::Delta::Infinite(),
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index 82d6fb5..6f4affb 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -11,6 +11,7 @@
#include <string>
#include <utility>
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_frame.h"
@@ -30,7 +31,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_server_stats.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index c31d3c7..ad96fcb 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -11,6 +11,7 @@
#include <string>
#include <utility>
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/null_decrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
@@ -31,7 +32,6 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/simple_data_producer.h"
#include "net/third_party/quiche/src/quic/test_tools/simple_quic_framer.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h"
@@ -639,9 +639,9 @@
MockRandom randomizer;
size_t length = creator_.BuildPaddedPathChallengePacket(
- header, buffer.get(), QUICHE_ARRAYSIZE(packet), &payload, &randomizer,
+ header, buffer.get(), ABSL_ARRAYSIZE(packet), &payload, &randomizer,
ENCRYPTION_INITIAL);
- EXPECT_EQ(length, QUICHE_ARRAYSIZE(packet));
+ EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
// Payload has the random bytes that were generated. Copy them into packet,
// above, before checking that the generated packet is correct.
@@ -652,7 +652,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data.data(), data.length(),
- reinterpret_cast<char*>(packet), QUICHE_ARRAYSIZE(packet));
+ reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicPacketCreatorTest, BuildConnectivityProbingPacket) {
@@ -710,13 +710,13 @@
// clang-format on
unsigned char* p = packet;
- size_t packet_size = QUICHE_ARRAYSIZE(packet);
+ size_t packet_size = ABSL_ARRAYSIZE(packet);
if (creator_.version().HasIetfQuicFrames()) {
p = packet99;
- packet_size = QUICHE_ARRAYSIZE(packet99);
+ packet_size = ABSL_ARRAYSIZE(packet99);
} else if (creator_.version().HasIetfInvariantHeader()) {
p = packet46;
- packet_size = QUICHE_ARRAYSIZE(packet46);
+ packet_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
@@ -771,15 +771,15 @@
QuicCircularDeque<QuicPathFrameBuffer> payloads;
payloads.push_back(payload0);
size_t length = creator_.BuildPathResponsePacket(
- header, buffer.get(), QUICHE_ARRAYSIZE(packet), payloads,
+ header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
/*is_padded=*/false, ENCRYPTION_INITIAL);
- EXPECT_EQ(length, QUICHE_ARRAYSIZE(packet));
+ EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
header);
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data.data(), data.length(),
- reinterpret_cast<char*>(packet), QUICHE_ARRAYSIZE(packet));
+ reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket1ResponsePadded) {
@@ -818,15 +818,15 @@
QuicCircularDeque<QuicPathFrameBuffer> payloads;
payloads.push_back(payload0);
size_t length = creator_.BuildPathResponsePacket(
- header, buffer.get(), QUICHE_ARRAYSIZE(packet), payloads,
+ header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
/*is_padded=*/true, ENCRYPTION_INITIAL);
- EXPECT_EQ(length, QUICHE_ARRAYSIZE(packet));
+ EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
header);
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data.data(), data.length(),
- reinterpret_cast<char*>(packet), QUICHE_ARRAYSIZE(packet));
+ reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket3ResponsesUnpadded) {
@@ -870,15 +870,15 @@
payloads.push_back(payload1);
payloads.push_back(payload2);
size_t length = creator_.BuildPathResponsePacket(
- header, buffer.get(), QUICHE_ARRAYSIZE(packet), payloads,
+ header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
/*is_padded=*/false, ENCRYPTION_INITIAL);
- EXPECT_EQ(length, QUICHE_ARRAYSIZE(packet));
+ EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
header);
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data.data(), data.length(),
- reinterpret_cast<char*>(packet), QUICHE_ARRAYSIZE(packet));
+ reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket3ResponsesPadded) {
@@ -924,15 +924,15 @@
payloads.push_back(payload1);
payloads.push_back(payload2);
size_t length = creator_.BuildPathResponsePacket(
- header, buffer.get(), QUICHE_ARRAYSIZE(packet), payloads,
+ header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
/*is_padded=*/true, ENCRYPTION_INITIAL);
- EXPECT_EQ(length, QUICHE_ARRAYSIZE(packet));
+ EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
header);
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data.data(), data.length(),
- reinterpret_cast<char*>(packet), QUICHE_ARRAYSIZE(packet));
+ reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicPacketCreatorTest, SerializeConnectivityProbingPacket) {
diff --git a/quic/core/quic_packet_reader.cc b/quic/core/quic_packet_reader.cc
index 3334042..2902f99 100644
--- a/quic/core/quic_packet_reader.cc
+++ b/quic/core/quic_packet_reader.cc
@@ -4,6 +4,7 @@
#include "net/third_party/quiche/src/quic/core/quic_packet_reader.h"
+#include "absl/base/macros.h"
#include "net/third_party/quiche/src/quic/core/quic_packets.h"
#include "net/third_party/quiche/src/quic/core/quic_process_packet_interface.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
@@ -13,7 +14,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_server_stats.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
namespace quic {
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index 0ce3b43..3975809 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -7,6 +7,7 @@
#include <memory>
#include <utility>
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_ack_frequency_frame.h"
#include "net/third_party/quiche/src/quic/core/quic_time.h"
@@ -17,7 +18,6 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_sent_packet_manager_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
using testing::_;
using testing::AnyNumber;
@@ -361,10 +361,10 @@
SendDataPacket(1);
uint64_t unacked[] = {1};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
uint64_t retransmittable[] = {1};
VerifyRetransmittablePackets(retransmittable,
- QUICHE_ARRAYSIZE(retransmittable));
+ ABSL_ARRAYSIZE(retransmittable));
}
TEST_F(QuicSentPacketManagerTest, IsUnAckedRetransmit) {
@@ -373,7 +373,7 @@
EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(&manager_, 2));
uint64_t unacked[] = {1, 2};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
std::vector<uint64_t> retransmittable = {1, 2};
VerifyRetransmittablePackets(&retransmittable[0], retransmittable.size());
}
@@ -393,7 +393,7 @@
EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
// Packet 1 is unacked, pending, but not retransmittable.
uint64_t unacked[] = {1};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
EXPECT_TRUE(manager_.HasInFlightPackets());
VerifyRetransmittablePackets(nullptr, 0);
}
@@ -416,7 +416,7 @@
EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
uint64_t unacked[] = {2};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(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);
@@ -431,7 +431,7 @@
EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
uint64_t unacked[] = {1};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
VerifyRetransmittablePackets(nullptr, 0);
EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted);
}
@@ -453,7 +453,7 @@
EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
// 2 remains unacked, but no packets have retransmittable data.
uint64_t unacked[] = {2};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
EXPECT_TRUE(manager_.HasInFlightPackets());
VerifyRetransmittablePackets(nullptr, 0);
// Ack 2 causes 2 be considered as spurious retransmission.
@@ -520,7 +520,7 @@
ENCRYPTION_INITIAL));
uint64_t unacked[] = {2};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
EXPECT_FALSE(manager_.HasInFlightPackets());
VerifyRetransmittablePackets(nullptr, 0);
@@ -552,7 +552,7 @@
// Since 2 was marked for retransmit, when 1 is acked, 2 is kept for RTT.
uint64_t unacked[] = {2};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
EXPECT_FALSE(manager_.HasInFlightPackets());
VerifyRetransmittablePackets(nullptr, 0);
@@ -589,7 +589,7 @@
// 2 and 3 remain unacked, but no packets have retransmittable data.
uint64_t unacked[] = {2, 3};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
EXPECT_TRUE(manager_.HasInFlightPackets());
VerifyRetransmittablePackets(nullptr, 0);
@@ -600,7 +600,7 @@
.WillOnce(Return(false))
.WillRepeatedly(Return(true));
uint64_t acked[] = {3, 4};
- ExpectAcksAndLosses(true, acked, QUICHE_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(5));
@@ -610,7 +610,7 @@
ENCRYPTION_INITIAL));
uint64_t unacked2[] = {2};
- VerifyUnackedPackets(unacked2, QUICHE_ARRAYSIZE(unacked2));
+ VerifyUnackedPackets(unacked2, ABSL_ARRAYSIZE(unacked2));
EXPECT_TRUE(manager_.HasInFlightPackets());
SendDataPacket(5);
@@ -631,7 +631,7 @@
ENCRYPTION_INITIAL));
uint64_t unacked3[] = {2};
- VerifyUnackedPackets(unacked3, QUICHE_ARRAYSIZE(unacked3));
+ VerifyUnackedPackets(unacked3, ABSL_ARRAYSIZE(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.
@@ -680,7 +680,7 @@
// Ack 3, which causes SpuriousRetransmitDetected to be called.
{
uint64_t acked[] = {3};
- ExpectAcksAndLosses(false, acked, QUICHE_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(false, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
EXPECT_CALL(*loss_algorithm,
SpuriousLossDetected(_, _, _, QuicPacketNumber(3),
@@ -726,7 +726,7 @@
// Now ack the ack and expect an RTT update.
uint64_t acked[] = {1, 2};
- ExpectAcksAndLosses(true, acked, QUICHE_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(2),
QuicTime::Delta::FromMilliseconds(5), clock_.Now());
manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
@@ -739,7 +739,7 @@
// Now ack the ack and expect only an RTT update.
uint64_t acked2[] = {3};
- ExpectAcksAndLosses(true, acked2, QUICHE_ARRAYSIZE(acked2), nullptr, 0);
+ ExpectAcksAndLosses(true, acked2, ABSL_ARRAYSIZE(acked2), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(4));
@@ -886,8 +886,8 @@
SendDataPacket(5);
uint64_t acked[] = {4, 5};
uint64_t lost[] = {1, 2};
- ExpectAcksAndLosses(true, acked, QUICHE_ARRAYSIZE(acked), lost,
- QUICHE_ARRAYSIZE(lost));
+ ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), lost,
+ ABSL_ARRAYSIZE(lost));
// Frames in all packets are acked.
EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
// Notify session that stream frame in packets 1 and 2 get lost although
@@ -1022,8 +1022,8 @@
// 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, QUICHE_ARRAYSIZE(acked), lost,
- QUICHE_ARRAYSIZE(lost));
+ ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), lost,
+ ABSL_ARRAYSIZE(lost));
EXPECT_CALL(notifier_, OnFrameLost(_)).Times(3);
EXPECT_CALL(notifier_, HasUnackedCryptoData()).WillRepeatedly(Return(false));
manager_.OnAckFrameStart(QuicPacketNumber(9), QuicTime::Delta::Infinite(),
@@ -1055,7 +1055,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, QUICHE_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
EXPECT_CALL(notifier_, HasUnackedCryptoData()).WillRepeatedly(Return(false));
EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
@@ -1067,7 +1067,7 @@
EXPECT_FALSE(manager_.HasUnackedCryptoPackets());
uint64_t unacked[] = {1, 3};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
}
TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeoutUnsentDataPacket) {
@@ -1114,14 +1114,14 @@
manager_.NeuterUnencryptedPackets();
EXPECT_FALSE(manager_.HasUnackedCryptoPackets());
uint64_t unacked[] = {1, 2, 3};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(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, QUICHE_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(4));
@@ -1610,7 +1610,7 @@
// Ack a packet before the first RTO and ensure the RTO timeout returns to the
// original value and OnRetransmissionTimeout is not called or reverted.
uint64_t acked[] = {1, 2};
- ExpectAcksAndLosses(true, acked, QUICHE_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Zero(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
@@ -2310,8 +2310,8 @@
// 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, QUICHE_ARRAYSIZE(acked1), lost1,
- QUICHE_ARRAYSIZE(lost1));
+ ExpectAcksAndLosses(true, acked1, ABSL_ARRAYSIZE(acked1), lost1,
+ ABSL_ARRAYSIZE(lost1));
EXPECT_CALL(notifier_, OnFrameLost(_)).Times(AnyNumber());
manager_.OnAckFrameStart(QuicPacketNumber(16), QuicTime::Delta::Infinite(),
clock_.Now());
@@ -2326,7 +2326,7 @@
// Ack [4, 8), [9, 13), [14, 21).
uint64_t acked2[] = {4, 7, 9, 12, 14, 17, 18, 19, 20};
- ExpectAcksAndLosses(true, acked2, QUICHE_ARRAYSIZE(acked2), nullptr, 0);
+ ExpectAcksAndLosses(true, acked2, ABSL_ARRAYSIZE(acked2), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(20), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(14), QuicPacketNumber(21));
@@ -2345,8 +2345,8 @@
// 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, QUICHE_ARRAYSIZE(acked1), lost1,
- QUICHE_ARRAYSIZE(lost1));
+ ExpectAcksAndLosses(true, acked1, ABSL_ARRAYSIZE(acked1), lost1,
+ ABSL_ARRAYSIZE(lost1));
EXPECT_CALL(notifier_, OnFrameLost(_)).Times(AnyNumber());
manager_.OnAckFrameStart(QuicPacketNumber(16), QuicTime::Delta::Infinite(),
clock_.Now());
@@ -2359,7 +2359,7 @@
// Making sure reneged ACK does not harm. Ack [4, 8), [9, 13).
uint64_t acked2[] = {4, 7, 9, 12};
- ExpectAcksAndLosses(true, acked2, QUICHE_ARRAYSIZE(acked2), nullptr, 0);
+ ExpectAcksAndLosses(true, acked2, ABSL_ARRAYSIZE(acked2), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(12), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(9), QuicPacketNumber(13));
@@ -2480,7 +2480,7 @@
APPLICATION_DATA));
// Ack all packets.
uint64_t acked[] = {4, 6, 7, 8};
- ExpectAcksAndLosses(true, acked, QUICHE_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(8), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(4), QuicPacketNumber(9));
@@ -2550,7 +2550,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, QUICHE_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(4));
@@ -2592,7 +2592,7 @@
// Received Ack of packets 1, 3 and 4.
uint64_t acked[] = {1, 3, 4};
- ExpectAcksAndLosses(true, acked, QUICHE_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(5));
@@ -2605,8 +2605,8 @@
uint64_t loss[] = {2};
// Verify packet 2 is detected lost.
EXPECT_CALL(notifier_, OnFrameLost(_)).Times(1);
- ExpectAcksAndLosses(true, acked2, QUICHE_ARRAYSIZE(acked2), loss,
- QUICHE_ARRAYSIZE(loss));
+ ExpectAcksAndLosses(true, acked2, ABSL_ARRAYSIZE(acked2), loss,
+ ABSL_ARRAYSIZE(loss));
manager_.OnAckFrameStart(QuicPacketNumber(6), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(7));
@@ -2697,7 +2697,7 @@
// Received ACK for packets 1 and 2.
uint64_t acked[] = {1, 2};
- ExpectAcksAndLosses(true, acked, QUICHE_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
@@ -2875,7 +2875,7 @@
// Received ACK for packets 1 and 2.
uint64_t acked[] = {1, 2};
- ExpectAcksAndLosses(true, acked, QUICHE_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
@@ -3474,7 +3474,7 @@
// Received ACK for packets 1 and 2.
uint64_t acked[] = {1, 2};
- ExpectAcksAndLosses(true, acked, QUICHE_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
@@ -3555,7 +3555,7 @@
// Received ACK for packets 1 and 2.
uint64_t acked[] = {1, 2};
- ExpectAcksAndLosses(true, acked, QUICHE_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
@@ -4026,7 +4026,7 @@
// Received ACK for HANDSHAKE packets.
uint64_t acked[] = {2, 3, 4};
- ExpectAcksAndLosses(true, acked, QUICHE_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(90));
manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
clock_.Now());
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 5161977..46ce528 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -9,6 +9,7 @@
#include <string>
#include <utility>
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
@@ -39,7 +40,6 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_stream_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_stream_send_buffer_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
using spdy::kV3HighestPriority;
@@ -2743,8 +2743,8 @@
.Times(1);
char data[1024];
std::vector<std::pair<char*, size_t>> buffers;
- buffers.push_back(std::make_pair(data, QUICHE_ARRAYSIZE(data)));
- buffers.push_back(std::make_pair(data, QUICHE_ARRAYSIZE(data)));
+ buffers.push_back(std::make_pair(data, ABSL_ARRAYSIZE(data)));
+ buffers.push_back(std::make_pair(data, ABSL_ARRAYSIZE(data)));
QuicTestMemSliceVector vector(buffers);
stream4->WriteMemSlices(vector.span(), false);
}
diff --git a/quic/core/quic_socket_address_coder_test.cc b/quic/core/quic_socket_address_coder_test.cc
index cbfe04f..4f3c3fe 100644
--- a/quic/core/quic_socket_address_coder_test.cc
+++ b/quic/core/quic_socket_address_coder_test.cc
@@ -6,8 +6,8 @@
#include <string>
+#include "absl/base/macros.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
namespace quic {
namespace test {
@@ -111,7 +111,7 @@
{"::1", 65534},
};
- for (size_t i = 0; i < QUICHE_ARRAYSIZE(test_case); i++) {
+ for (size_t i = 0; i < ABSL_ARRAYSIZE(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/quic/core/quic_stream_sequencer_test.cc b/quic/core/quic_stream_sequencer_test.cc
index cd39fcd..f53533c 100644
--- a/quic/core/quic_stream_sequencer_test.cc
+++ b/quic/core/quic_stream_sequencer_test.cc
@@ -11,6 +11,7 @@
#include <utility>
#include <vector>
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_stream.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
@@ -20,7 +21,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_stream_sequencer_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
using testing::_;
using testing::AnyNumber;
@@ -52,7 +52,7 @@
public:
void ConsumeData(size_t num_bytes) {
char buffer[1024];
- ASSERT_GT(QUICHE_ARRAYSIZE(buffer), num_bytes);
+ ASSERT_GT(ABSL_ARRAYSIZE(buffer), num_bytes);
struct iovec iov;
iov.iov_base = buffer;
iov.iov_len = num_bytes;
@@ -96,7 +96,7 @@
const std::vector<std::string>& expected) {
iovec iovecs[5];
size_t num_iovecs =
- sequencer.GetReadableRegions(iovecs, QUICHE_ARRAYSIZE(iovecs));
+ sequencer.GetReadableRegions(iovecs, ABSL_ARRAYSIZE(iovecs));
return VerifyReadableRegion(sequencer, expected) &&
VerifyIovecs(sequencer, iovecs, num_iovecs, expected);
}
@@ -380,7 +380,7 @@
typedef std::vector<Frame> FrameList;
void CreateFrames() {
- int payload_size = QUICHE_ARRAYSIZE(kPayload) - 1;
+ int payload_size = ABSL_ARRAYSIZE(kPayload) - 1;
int remaining_payload = payload_size;
while (remaining_payload != 0) {
int size = std::min(OneToN(6), remaining_payload);
@@ -403,10 +403,10 @@
void ReadAvailableData() {
// Read all available data
- char output[QUICHE_ARRAYSIZE(kPayload) + 1];
+ char output[ABSL_ARRAYSIZE(kPayload) + 1];
iovec iov;
iov.iov_base = output;
- iov.iov_len = QUICHE_ARRAYSIZE(output);
+ iov.iov_len = ABSL_ARRAYSIZE(output);
int bytes_read = sequencer_->Readv(&iov, 1);
EXPECT_NE(0, bytes_read);
output_.append(output, bytes_read);
@@ -442,9 +442,9 @@
list_.erase(list_.begin() + index);
}
- ASSERT_EQ(QUICHE_ARRAYSIZE(kPayload) - 1, output_.size());
+ ASSERT_EQ(ABSL_ARRAYSIZE(kPayload) - 1, output_.size());
EXPECT_EQ(kPayload, output_);
- EXPECT_EQ(QUICHE_ARRAYSIZE(kPayload) - 1, total_bytes_consumed);
+ EXPECT_EQ(ABSL_ARRAYSIZE(kPayload) - 1, total_bytes_consumed);
}
TEST_F(QuicSequencerRandomTest, RandomFramesNoDroppingBackup) {
@@ -464,7 +464,7 @@
total_bytes_consumed += bytes;
}));
- while (output_.size() != QUICHE_ARRAYSIZE(kPayload) - 1) {
+ while (output_.size() != ABSL_ARRAYSIZE(kPayload) - 1) {
if (!list_.empty() && OneToN(2) == 1) { // Send data
int index = OneToN(list_.size()) - 1;
OnFrame(list_[index].first, list_[index].second.data());
@@ -480,7 +480,7 @@
ASSERT_EQ(0, iovs_peeked);
ASSERT_FALSE(sequencer_->GetReadableRegion(peek_iov));
}
- int total_bytes_to_peek = QUICHE_ARRAYSIZE(buffer);
+ int total_bytes_to_peek = ABSL_ARRAYSIZE(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);
@@ -497,7 +497,7 @@
}
EXPECT_EQ(std::string(kPayload), output_);
EXPECT_EQ(std::string(kPayload), peeked_);
- EXPECT_EQ(QUICHE_ARRAYSIZE(kPayload) - 1, total_bytes_consumed);
+ EXPECT_EQ(ABSL_ARRAYSIZE(kPayload) - 1, total_bytes_consumed);
}
// Same as above, just using a different method for reading.
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index fcd0d28..d6ad3f8 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -8,6 +8,7 @@
#include <string>
#include <utility>
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_rst_stream_frame.h"
@@ -32,7 +33,6 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_stream_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_stream_sequencer_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
using testing::_;
using testing::AnyNumber;
@@ -1214,8 +1214,8 @@
Initialize();
char data[1024];
std::vector<std::pair<char*, size_t>> buffers;
- buffers.push_back(std::make_pair(data, QUICHE_ARRAYSIZE(data)));
- buffers.push_back(std::make_pair(data, QUICHE_ARRAYSIZE(data)));
+ buffers.push_back(std::make_pair(data, ABSL_ARRAYSIZE(data)));
+ buffers.push_back(std::make_pair(data, ABSL_ARRAYSIZE(data)));
QuicTestMemSliceVector vector1(buffers);
QuicTestMemSliceVector vector2(buffers);
QuicMemSliceSpan span1 = vector1.span();
@@ -1230,7 +1230,7 @@
QuicConsumedData consumed = stream_->WriteMemSlices(span1, false);
EXPECT_EQ(2048u, consumed.bytes_consumed);
EXPECT_FALSE(consumed.fin_consumed);
- EXPECT_EQ(2 * QUICHE_ARRAYSIZE(data) - 100, stream_->BufferedDataBytes());
+ EXPECT_EQ(2 * ABSL_ARRAYSIZE(data) - 100, stream_->BufferedDataBytes());
EXPECT_FALSE(stream_->fin_buffered());
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).Times(0);
@@ -1238,11 +1238,11 @@
consumed = stream_->WriteMemSlices(span2, true);
EXPECT_EQ(0u, consumed.bytes_consumed);
EXPECT_FALSE(consumed.fin_consumed);
- EXPECT_EQ(2 * QUICHE_ARRAYSIZE(data) - 100, stream_->BufferedDataBytes());
+ EXPECT_EQ(2 * ABSL_ARRAYSIZE(data) - 100, stream_->BufferedDataBytes());
EXPECT_FALSE(stream_->fin_buffered());
QuicByteCount data_to_write =
- 2 * QUICHE_ARRAYSIZE(data) - 100 -
+ 2 * ABSL_ARRAYSIZE(data) - 100 -
GetQuicFlag(FLAGS_quic_buffered_data_threshold) + 1;
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this, data_to_write]() {
@@ -1259,7 +1259,7 @@
consumed = stream_->WriteMemSlices(span2, true);
EXPECT_EQ(2048u, consumed.bytes_consumed);
EXPECT_TRUE(consumed.fin_consumed);
- EXPECT_EQ(2 * QUICHE_ARRAYSIZE(data) +
+ EXPECT_EQ(2 * ABSL_ARRAYSIZE(data) +
GetQuicFlag(FLAGS_quic_buffered_data_threshold) - 1,
stream_->BufferedDataBytes());
EXPECT_TRUE(stream_->fin_buffered());
@@ -1278,7 +1278,7 @@
QuicStreamPeer::SetStreamBytesWritten(kMaxStreamLength - 5u, stream_);
char data[5];
std::vector<std::pair<char*, size_t>> buffers;
- buffers.push_back(std::make_pair(data, QUICHE_ARRAYSIZE(data)));
+ buffers.push_back(std::make_pair(data, ABSL_ARRAYSIZE(data)));
QuicTestMemSliceVector vector1(buffers);
QuicMemSliceSpan span1 = vector1.span();
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
diff --git a/quic/core/quic_tag.cc b/quic/core/quic_tag.cc
index 7cc25e0..2858924 100644
--- a/quic/core/quic_tag.cc
+++ b/quic/core/quic_tag.cc
@@ -7,9 +7,9 @@
#include <algorithm>
#include <string>
+#include "absl/base/macros.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
namespace quic {
@@ -43,10 +43,10 @@
bool ascii = true;
const QuicTag orig_tag = tag;
- for (size_t i = 0; i < QUICHE_ARRAYSIZE(chars); i++) {
+ for (size_t i = 0; i < ABSL_ARRAYSIZE(chars); i++) {
chars[i] = static_cast<char>(tag);
if ((chars[i] == 0 || chars[i] == '\xff') &&
- i == QUICHE_ARRAYSIZE(chars) - 1) {
+ i == ABSL_ARRAYSIZE(chars) - 1) {
chars[i] = ' ';
}
if (!isprint(static_cast<unsigned char>(chars[i]))) {
diff --git a/quic/core/quic_unacked_packet_map_test.cc b/quic/core/quic_unacked_packet_map_test.cc
index 96ba08a..b81b3ea 100644
--- a/quic/core/quic_unacked_packet_map_test.cc
+++ b/quic/core/quic_unacked_packet_map_test.cc
@@ -5,13 +5,13 @@
#include "net/third_party/quiche/src/quic/core/quic_unacked_packet_map.h"
#include <limits>
+#include "absl/base/macros.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_stream_frame.h"
#include "net/third_party/quiche/src/quic/core/quic_transmission_info.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_unacked_packet_map_peer.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
using testing::_;
using testing::Return;
@@ -174,7 +174,7 @@
true);
uint64_t unacked[] = {1};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
VerifyInFlightPackets(nullptr, 0);
VerifyRetransmittablePackets(nullptr, 0);
@@ -190,18 +190,18 @@
unacked_packets_.AddSentPacket(&packet, NOT_RETRANSMISSION, now_, true, true);
uint64_t unacked[] = {1};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, QUICHE_ARRAYSIZE(unacked));
- VerifyRetransmittablePackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyRetransmittablePackets(unacked, ABSL_ARRAYSIZE(unacked));
unacked_packets_.RemoveRetransmittability(QuicPacketNumber(1));
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
VerifyRetransmittablePackets(nullptr, 0);
unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(1));
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
VerifyRetransmittablePackets(nullptr, 0);
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(1));
@@ -216,15 +216,15 @@
unacked_packets_.AddSentPacket(&packet, NOT_RETRANSMISSION, now_, true, true);
uint64_t unacked[] = {1};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
uint64_t retransmittable[] = {1};
VerifyRetransmittablePackets(retransmittable,
- QUICHE_ARRAYSIZE(retransmittable));
+ ABSL_ARRAYSIZE(retransmittable));
EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
VerifyRetransmittablePackets(nullptr, 0);
}
@@ -234,16 +234,16 @@
unacked_packets_.AddSentPacket(&packet, NOT_RETRANSMISSION, now_, true, true);
uint64_t unacked[] = {1};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
uint64_t retransmittable[] = {1};
VerifyRetransmittablePackets(retransmittable,
- QUICHE_ARRAYSIZE(retransmittable));
+ ABSL_ARRAYSIZE(retransmittable));
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
VerifyRetransmittablePackets(retransmittable,
- QUICHE_ARRAYSIZE(retransmittable));
+ ABSL_ARRAYSIZE(retransmittable));
}
TEST_P(QuicUnackedPacketMapTest, StopRetransmissionAfterRetransmission) {
@@ -254,14 +254,14 @@
RetransmitAndSendPacket(1, 2, LOSS_RETRANSMISSION);
uint64_t unacked[] = {1, 2};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
std::vector<uint64_t> retransmittable = {1, 2};
VerifyRetransmittablePackets(&retransmittable[0], retransmittable.size());
EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
VerifyRetransmittablePackets(nullptr, 0);
}
@@ -274,26 +274,26 @@
RetransmitAndSendPacket(1, 2, LOSS_RETRANSMISSION);
uint64_t unacked[] = {1, 2};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(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, QUICHE_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
VerifyRetransmittablePackets(nullptr, 0);
unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
VerifyRetransmittablePackets(nullptr, 0);
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
uint64_t unacked2[] = {1};
- VerifyUnackedPackets(unacked2, QUICHE_ARRAYSIZE(unacked2));
- VerifyInFlightPackets(unacked2, QUICHE_ARRAYSIZE(unacked2));
+ VerifyUnackedPackets(unacked2, ABSL_ARRAYSIZE(unacked2));
+ VerifyInFlightPackets(unacked2, ABSL_ARRAYSIZE(unacked2));
VerifyRetransmittablePackets(nullptr, 0);
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(1));
@@ -312,11 +312,11 @@
true);
uint64_t unacked[] = {1, 2};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
uint64_t retransmittable[] = {1, 2};
VerifyRetransmittablePackets(retransmittable,
- QUICHE_ARRAYSIZE(retransmittable));
+ ABSL_ARRAYSIZE(retransmittable));
// Early retransmit 1 as 3 and send new data as 4.
unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
@@ -329,9 +329,9 @@
true);
uint64_t unacked2[] = {1, 3, 4};
- VerifyUnackedPackets(unacked2, QUICHE_ARRAYSIZE(unacked2));
+ VerifyUnackedPackets(unacked2, ABSL_ARRAYSIZE(unacked2));
uint64_t pending2[] = {3, 4};
- VerifyInFlightPackets(pending2, QUICHE_ARRAYSIZE(pending2));
+ VerifyInFlightPackets(pending2, ABSL_ARRAYSIZE(pending2));
std::vector<uint64_t> retransmittable2 = {1, 3, 4};
VerifyRetransmittablePackets(&retransmittable2[0], retransmittable2.size());
@@ -349,7 +349,7 @@
VerifyUnackedPackets(&unacked3[0], unacked3.size());
VerifyRetransmittablePackets(&retransmittable3[0], retransmittable3.size());
uint64_t pending3[] = {3, 5, 6};
- VerifyInFlightPackets(pending3, QUICHE_ARRAYSIZE(pending3));
+ VerifyInFlightPackets(pending3, ABSL_ARRAYSIZE(pending3));
// Early retransmit 5 as 7 and ensure in flight packet 3 is not removed.
unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(6));
@@ -362,13 +362,13 @@
VerifyUnackedPackets(&unacked4[0], unacked4.size());
VerifyRetransmittablePackets(&retransmittable4[0], retransmittable4.size());
uint64_t pending4[] = {3, 5, 7};
- VerifyInFlightPackets(pending4, QUICHE_ARRAYSIZE(pending4));
+ VerifyInFlightPackets(pending4, ABSL_ARRAYSIZE(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, QUICHE_ARRAYSIZE(pending5));
+ VerifyInFlightPackets(pending5, ABSL_ARRAYSIZE(pending5));
}
TEST_P(QuicUnackedPacketMapTest, RetransmitFourTimes) {
@@ -381,11 +381,11 @@
true);
uint64_t unacked[] = {1, 2};
- VerifyUnackedPackets(unacked, QUICHE_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, QUICHE_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
uint64_t retransmittable[] = {1, 2};
VerifyRetransmittablePackets(retransmittable,
- QUICHE_ARRAYSIZE(retransmittable));
+ ABSL_ARRAYSIZE(retransmittable));
// Early retransmit 1 as 3.
unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
@@ -395,9 +395,9 @@
RetransmitAndSendPacket(1, 3, LOSS_RETRANSMISSION);
uint64_t unacked2[] = {1, 3};
- VerifyUnackedPackets(unacked2, QUICHE_ARRAYSIZE(unacked2));
+ VerifyUnackedPackets(unacked2, ABSL_ARRAYSIZE(unacked2));
uint64_t pending2[] = {3};
- VerifyInFlightPackets(pending2, QUICHE_ARRAYSIZE(pending2));
+ VerifyInFlightPackets(pending2, ABSL_ARRAYSIZE(pending2));
std::vector<uint64_t> retransmittable2 = {1, 3};
VerifyRetransmittablePackets(&retransmittable2[0], retransmittable2.size());
@@ -408,9 +408,9 @@
true);
uint64_t unacked3[] = {1, 3, 4, 5};
- VerifyUnackedPackets(unacked3, QUICHE_ARRAYSIZE(unacked3));
+ VerifyUnackedPackets(unacked3, ABSL_ARRAYSIZE(unacked3));
uint64_t pending3[] = {3, 4, 5};
- VerifyInFlightPackets(pending3, QUICHE_ARRAYSIZE(pending3));
+ VerifyInFlightPackets(pending3, ABSL_ARRAYSIZE(pending3));
std::vector<uint64_t> retransmittable3 = {1, 3, 4, 5};
VerifyRetransmittablePackets(&retransmittable3[0], retransmittable3.size());
@@ -425,7 +425,7 @@
std::vector<uint64_t> unacked4 = {4, 6};
VerifyUnackedPackets(&unacked4[0], unacked4.size());
uint64_t pending4[] = {6};
- VerifyInFlightPackets(pending4, QUICHE_ARRAYSIZE(pending4));
+ VerifyInFlightPackets(pending4, ABSL_ARRAYSIZE(pending4));
std::vector<uint64_t> retransmittable4 = {4, 6};
VerifyRetransmittablePackets(&retransmittable4[0], retransmittable4.size());
}
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index 4186716..b411e11 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -9,6 +9,7 @@
#include <cstring>
#include <string>
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
#include "net/third_party/quiche/src/quic/core/quic_constants.h"
@@ -20,7 +21,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_prefetch.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_uint128.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/quiche_endian.h"
namespace quic {
@@ -563,7 +563,7 @@
if (!VersionAllowsVariableLengthConnectionIds(version)) {
char connection_id_bytes[8] = {0, 0, 0, 0, 0, 0, 0, 0};
return QuicConnectionId(static_cast<char*>(connection_id_bytes),
- QUICHE_ARRAYSIZE(connection_id_bytes));
+ ABSL_ARRAYSIZE(connection_id_bytes));
}
return EmptyQuicConnectionId();
}
diff --git a/quic/core/quic_utils_test.cc b/quic/core/quic_utils_test.cc
index b3b8457..efcdb7e 100644
--- a/quic/core/quic_utils_test.cc
+++ b/quic/core/quic_utils_test.cc
@@ -6,12 +6,12 @@
#include <string>
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
#include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
namespace quic {
namespace test {
@@ -257,10 +257,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, QUICHE_ARRAYSIZE(connection_id_bytes));
+ random.RandBytes(connection_id_bytes, ABSL_ARRAYSIZE(connection_id_bytes));
EXPECT_EQ(connection_id,
QuicConnectionId(static_cast<char*>(connection_id_bytes),
- QUICHE_ARRAYSIZE(connection_id_bytes)));
+ ABSL_ARRAYSIZE(connection_id_bytes)));
EXPECT_NE(connection_id, EmptyQuicConnectionId());
EXPECT_NE(connection_id, TestConnectionId());
EXPECT_NE(connection_id, TestConnectionId(1));
@@ -276,10 +276,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, QUICHE_ARRAYSIZE(connection_id_bytes));
+ random.RandBytes(connection_id_bytes, ABSL_ARRAYSIZE(connection_id_bytes));
EXPECT_EQ(connection_id,
QuicConnectionId(static_cast<char*>(connection_id_bytes),
- QUICHE_ARRAYSIZE(connection_id_bytes)));
+ ABSL_ARRAYSIZE(connection_id_bytes)));
EXPECT_NE(connection_id, EmptyQuicConnectionId());
EXPECT_NE(connection_id, TestConnectionId());
EXPECT_NE(connection_id, TestConnectionId(1));
diff --git a/quic/core/quic_version_manager.cc b/quic/core/quic_version_manager.cc
index 7cf6a1d..9ca86f9 100644
--- a/quic/core/quic_version_manager.cc
+++ b/quic/core/quic_version_manager.cc
@@ -6,10 +6,10 @@
#include <algorithm>
+#include "absl/base/macros.h"
#include "net/third_party/quiche/src/quic/core/quic_versions.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
namespace quic {
diff --git a/quic/core/quic_version_manager_test.cc b/quic/core/quic_version_manager_test.cc
index c91ad99..487471f 100644
--- a/quic/core/quic_version_manager_test.cc
+++ b/quic/core/quic_version_manager_test.cc
@@ -4,10 +4,10 @@
#include "net/third_party/quiche/src/quic/core/quic_version_manager.h"
+#include "absl/base/macros.h"
#include "net/third_party/quiche/src/quic/core/quic_versions.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
using ::testing::ElementsAre;
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 30d7cb2..d2b5774 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -6,6 +6,7 @@
#include <string>
+#include "absl/base/macros.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
#include "net/third_party/quiche/src/quic/core/quic_tag.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
@@ -13,7 +14,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
#include "net/third_party/quiche/src/common/quiche_endian.h"
diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index eeadbf1..452f3f8 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -4,12 +4,12 @@
#include "net/third_party/quiche/src/quic/core/quic_versions.h"
+#include "absl/base/macros.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_mock_log.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
namespace quic {
namespace test {
@@ -371,7 +371,7 @@
QuicTransportVersion single_version[] = {QUIC_VERSION_43};
QuicTransportVersionVector versions_vector;
- for (size_t i = 0; i < QUICHE_ARRAYSIZE(single_version); ++i) {
+ for (size_t i = 0; i < ABSL_ARRAYSIZE(single_version); ++i) {
versions_vector.push_back(single_version[i]);
}
EXPECT_EQ("QUIC_VERSION_43",
@@ -380,7 +380,7 @@
QuicTransportVersion multiple_versions[] = {QUIC_VERSION_UNSUPPORTED,
QUIC_VERSION_43};
versions_vector.clear();
- for (size_t i = 0; i < QUICHE_ARRAYSIZE(multiple_versions); ++i) {
+ for (size_t i = 0; i < ABSL_ARRAYSIZE(multiple_versions); ++i) {
versions_vector.push_back(multiple_versions[i]);
}
EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_43",
diff --git a/quic/core/tls_client_handshaker_test.cc b/quic/core/tls_client_handshaker_test.cc
index 6a05159..7cd7d45 100644
--- a/quic/core/tls_client_handshaker_test.cc
+++ b/quic/core/tls_client_handshaker_test.cc
@@ -6,6 +6,7 @@
#include <string>
#include <utility>
+#include "absl/base/macros.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h"
#include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
@@ -24,7 +25,6 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/simple_session_cache.h"
#include "net/third_party/quiche/src/quic/tools/fake_proof_verifier.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h"
using testing::_;
@@ -286,7 +286,7 @@
};
stream()->crypto_message_parser()->ProcessInput(
absl::string_view(bogus_handshake_message,
- QUICHE_ARRAYSIZE(bogus_handshake_message)),
+ ABSL_ARRAYSIZE(bogus_handshake_message)),
ENCRYPTION_INITIAL);
EXPECT_FALSE(stream()->one_rtt_keys_available());
diff --git a/quic/core/tls_handshaker.cc b/quic/core/tls_handshaker.cc
index d9d08e6..7b3efd8 100644
--- a/quic/core/tls_handshaker.cc
+++ b/quic/core/tls_handshaker.cc
@@ -4,13 +4,13 @@
#include "net/third_party/quiche/src/quic/core/tls_handshaker.h"
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "third_party/boringssl/src/include/openssl/crypto.h"
#include "third_party/boringssl/src/include/openssl/ssl.h"
#include "net/third_party/quiche/src/quic/core/quic_crypto_stream.h"
#include "net/third_party/quiche/src/quic/core/tls_client_handshaker.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
namespace quic {
diff --git a/quic/core/tls_server_handshaker.cc b/quic/core/tls_server_handshaker.cc
index 7b5ec3b..31c4ce5 100644
--- a/quic/core/tls_server_handshaker.cc
+++ b/quic/core/tls_server_handshaker.cc
@@ -7,6 +7,7 @@
#include <memory>
#include <string>
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "third_party/boringssl/src/include/openssl/pool.h"
#include "third_party/boringssl/src/include/openssl/ssl.h"
@@ -16,7 +17,6 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_hostname_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
namespace quic {
diff --git a/quic/core/tls_server_handshaker_test.cc b/quic/core/tls_server_handshaker_test.cc
index b95b281..f890684 100644
--- a/quic/core/tls_server_handshaker_test.cc
+++ b/quic/core/tls_server_handshaker_test.cc
@@ -6,6 +6,7 @@
#include <utility>
#include <vector>
+#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/proof_source.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
@@ -23,7 +24,6 @@
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/simple_session_cache.h"
#include "net/third_party/quiche/src/quic/test_tools/test_ticket_crypter.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
namespace quic {
class QuicConnection;
@@ -296,7 +296,7 @@
};
server_stream()->crypto_message_parser()->ProcessInput(
absl::string_view(bogus_handshake_message,
- QUICHE_ARRAYSIZE(bogus_handshake_message)),
+ ABSL_ARRAYSIZE(bogus_handshake_message)),
ENCRYPTION_INITIAL);
EXPECT_FALSE(server_stream()->one_rtt_keys_available());
