Repalce QuicheTextUtils::HexEncode/Decode with Abseil equivalents.
PiperOrigin-RevId: 339366305
Change-Id: Ifa155b75569a17f3f3be908c7d0a9f9de7b9474c
diff --git a/common/platform/api/quiche_text_utils.h b/common/platform/api/quiche_text_utils.h
index 5bc5f50..1a11c2a 100644
--- a/common/platform/api/quiche_text_utils.h
+++ b/common/platform/api/quiche_text_utils.h
@@ -7,6 +7,7 @@
#include <string>
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
@@ -32,32 +33,12 @@
return quiche::QuicheTextUtilsImpl::Uint64ToString(in);
}
- // This converts |length| bytes of binary to a 2*|length|-character
- // hexadecimal representation.
- // Return value: 2*|length| characters of ASCII string.
- static std::string HexEncode(const char* data, size_t length) {
- return HexEncode(absl::string_view(data, length));
- }
-
- // This converts |data.length()| bytes of binary to a
- // 2*|data.length()|-character hexadecimal representation.
- // Return value: 2*|data.length()| characters of ASCII string.
- static std::string HexEncode(absl::string_view data) {
- return quiche::QuicheTextUtilsImpl::HexEncode(data);
- }
-
// This converts a uint32 into an 8-character hexidecimal
// representation. Return value: 8 characters of ASCII string.
static std::string Hex(uint32_t v) {
return quiche::QuicheTextUtilsImpl::Hex(v);
}
- // Converts |data| from a hexadecimal ASCII string to a binary string
- // that is |data.length()/2| bytes long.
- static std::string HexDecode(absl::string_view data) {
- return quiche::QuicheTextUtilsImpl::HexDecode(data);
- }
-
// Base64 encodes with no padding |data_len| bytes of |data| into |output|.
static void Base64Encode(const uint8_t* data,
size_t data_len,
diff --git a/common/platform/api/quiche_text_utils_test.cc b/common/platform/api/quiche_text_utils_test.cc
index 012d33d..f85f8b0 100644
--- a/common/platform/api/quiche_text_utils_test.cc
+++ b/common/platform/api/quiche_text_utils_test.cc
@@ -6,6 +6,7 @@
#include <string>
+#include "absl/strings/escaping.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_test.h"
namespace quiche {
@@ -37,21 +38,6 @@
EXPECT_EQ("1234", quiche::QuicheTextUtils::Uint64ToString(1234));
}
-TEST_F(QuicheTextUtilsTest, HexEncode) {
- EXPECT_EQ("48656c6c6f", quiche::QuicheTextUtils::HexEncode("Hello", 5));
- EXPECT_EQ("48656c6c6f", quiche::QuicheTextUtils::HexEncode("Hello World", 5));
- EXPECT_EQ("48656c6c6f", quiche::QuicheTextUtils::HexEncode("Hello"));
- EXPECT_EQ("0102779cfa",
- quiche::QuicheTextUtils::HexEncode("\x01\x02\x77\x9c\xfa"));
-}
-
-TEST_F(QuicheTextUtilsTest, HexDecode) {
- EXPECT_EQ("Hello", quiche::QuicheTextUtils::HexDecode("48656c6c6f"));
- EXPECT_EQ("", quiche::QuicheTextUtils::HexDecode(""));
- EXPECT_EQ("\x01\x02\x77\x9c\xfa",
- quiche::QuicheTextUtils::HexDecode("0102779cfa"));
-}
-
TEST_F(QuicheTextUtilsTest, HexDump) {
// Verify output of the HexDump method is as expected.
char packet[] = {
@@ -72,14 +58,13 @@
"0x0040: 6c69 6e65 7320 6f66 206f 7574 7075 742e lines.of.output.\n"
"0x0050: 0102 03 ...\n");
// Verify that 0x21 and 0x7e are printable, 0x20 and 0x7f are not.
- EXPECT_EQ("0x0000: 2021 7e7f .!~.\n",
- quiche::QuicheTextUtils::HexDump(
- quiche::QuicheTextUtils::HexDecode("20217e7f")));
+ EXPECT_EQ(
+ "0x0000: 2021 7e7f .!~.\n",
+ quiche::QuicheTextUtils::HexDump(absl::HexStringToBytes("20217e7f")));
// Verify that values above numeric_limits<unsigned char>::max() are formatted
// properly on platforms where char is unsigned.
EXPECT_EQ("0x0000: 90aa ff ...\n",
- quiche::QuicheTextUtils::HexDump(
- quiche::QuicheTextUtils::HexDecode("90aaff")));
+ quiche::QuicheTextUtils::HexDump(absl::HexStringToBytes("90aaff")));
}
TEST_F(QuicheTextUtilsTest, Base64Encode) {
diff --git a/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc b/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc
index 5b25250..aba1001 100644
--- a/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc
+++ b/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc
@@ -8,6 +8,7 @@
#include <string>
#include "absl/base/macros.h"
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
@@ -234,14 +235,14 @@
bool has_pt = test_vectors[j].pt;
// Decode the test vector.
- std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[j].key);
- std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[j].iv);
- std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[j].ct);
- std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[j].aad);
- std::string tag = quiche::QuicheTextUtils::HexDecode(test_vectors[j].tag);
+ std::string key = absl::HexStringToBytes(test_vectors[j].key);
+ std::string iv = absl::HexStringToBytes(test_vectors[j].iv);
+ std::string ct = absl::HexStringToBytes(test_vectors[j].ct);
+ std::string aad = absl::HexStringToBytes(test_vectors[j].aad);
+ std::string tag = absl::HexStringToBytes(test_vectors[j].tag);
std::string pt;
if (has_pt) {
- pt = quiche::QuicheTextUtils::HexDecode(test_vectors[j].pt);
+ pt = absl::HexStringToBytes(test_vectors[j].pt);
}
// The test vector's lengths should look sane. Note that the lengths
diff --git a/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc b/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc
index 1216f95..1495fd0 100644
--- a/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc
+++ b/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc
@@ -8,6 +8,7 @@
#include <string>
#include "absl/base/macros.h"
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
@@ -183,12 +184,12 @@
const TestGroupInfo& test_info = test_group_info[i];
for (size_t j = 0; test_vectors[j].key != nullptr; j++) {
// Decode the test vector.
- std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[j].key);
- std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[j].iv);
- std::string pt = quiche::QuicheTextUtils::HexDecode(test_vectors[j].pt);
- std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[j].aad);
- std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[j].ct);
- std::string tag = quiche::QuicheTextUtils::HexDecode(test_vectors[j].tag);
+ std::string key = absl::HexStringToBytes(test_vectors[j].key);
+ std::string iv = absl::HexStringToBytes(test_vectors[j].iv);
+ std::string pt = absl::HexStringToBytes(test_vectors[j].pt);
+ std::string aad = absl::HexStringToBytes(test_vectors[j].aad);
+ std::string ct = absl::HexStringToBytes(test_vectors[j].ct);
+ std::string tag = absl::HexStringToBytes(test_vectors[j].tag);
// The test vector's lengths should look sane. Note that the lengths
// in |test_info| are in bits.
diff --git a/quic/core/crypto/aes_128_gcm_decrypter_test.cc b/quic/core/crypto/aes_128_gcm_decrypter_test.cc
index 7625f7a..d4f38b9 100644
--- a/quic/core/crypto/aes_128_gcm_decrypter_test.cc
+++ b/quic/core/crypto/aes_128_gcm_decrypter_test.cc
@@ -8,6 +8,7 @@
#include <string>
#include "absl/base/macros.h"
+#include "absl/strings/escaping.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"
@@ -228,14 +229,14 @@
bool has_pt = test_vectors[j].pt;
// Decode the test vector.
- std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[j].key);
- std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[j].iv);
- std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[j].ct);
- std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[j].aad);
- std::string tag = quiche::QuicheTextUtils::HexDecode(test_vectors[j].tag);
+ std::string key = absl::HexStringToBytes(test_vectors[j].key);
+ std::string iv = absl::HexStringToBytes(test_vectors[j].iv);
+ std::string ct = absl::HexStringToBytes(test_vectors[j].ct);
+ std::string aad = absl::HexStringToBytes(test_vectors[j].aad);
+ std::string tag = absl::HexStringToBytes(test_vectors[j].tag);
std::string pt;
if (has_pt) {
- pt = quiche::QuicheTextUtils::HexDecode(test_vectors[j].pt);
+ pt = absl::HexStringToBytes(test_vectors[j].pt);
}
// The test vector's lengths should look sane. Note that the lengths
@@ -274,15 +275,14 @@
TEST_F(Aes128GcmDecrypterTest, GenerateHeaderProtectionMask) {
Aes128GcmDecrypter decrypter;
- std::string key =
- quiche::QuicheTextUtils::HexDecode("d9132370cb18476ab833649cf080d970");
+ std::string key = absl::HexStringToBytes("d9132370cb18476ab833649cf080d970");
std::string sample =
- quiche::QuicheTextUtils::HexDecode("d1d7998068517adb769b48b924a32c47");
+ absl::HexStringToBytes("d1d7998068517adb769b48b924a32c47");
QuicDataReader sample_reader(sample.data(), sample.size());
ASSERT_TRUE(decrypter.SetHeaderProtectionKey(key));
std::string mask = decrypter.GenerateHeaderProtectionMask(&sample_reader);
std::string expected_mask =
- quiche::QuicheTextUtils::HexDecode("b132c37d6164da4ea4dc9b763aceec27");
+ absl::HexStringToBytes("b132c37d6164da4ea4dc9b763aceec27");
quiche::test::CompareCharArraysWithHexError(
"header protection mask", mask.data(), mask.size(), expected_mask.data(),
expected_mask.size());
diff --git a/quic/core/crypto/aes_128_gcm_encrypter_test.cc b/quic/core/crypto/aes_128_gcm_encrypter_test.cc
index 462c2e4..c7c096f 100644
--- a/quic/core/crypto/aes_128_gcm_encrypter_test.cc
+++ b/quic/core/crypto/aes_128_gcm_encrypter_test.cc
@@ -8,6 +8,7 @@
#include <string>
#include "absl/base/macros.h"
+#include "absl/strings/escaping.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"
@@ -182,12 +183,12 @@
const TestGroupInfo& test_info = test_group_info[i];
for (size_t j = 0; test_vectors[j].key != nullptr; j++) {
// Decode the test vector.
- std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[j].key);
- std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[j].iv);
- std::string pt = quiche::QuicheTextUtils::HexDecode(test_vectors[j].pt);
- std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[j].aad);
- std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[j].ct);
- std::string tag = quiche::QuicheTextUtils::HexDecode(test_vectors[j].tag);
+ std::string key = absl::HexStringToBytes(test_vectors[j].key);
+ std::string iv = absl::HexStringToBytes(test_vectors[j].iv);
+ std::string pt = absl::HexStringToBytes(test_vectors[j].pt);
+ std::string aad = absl::HexStringToBytes(test_vectors[j].aad);
+ std::string ct = absl::HexStringToBytes(test_vectors[j].ct);
+ std::string tag = absl::HexStringToBytes(test_vectors[j].tag);
// The test vector's lengths should look sane. Note that the lengths
// in |test_info| are in bits.
@@ -219,16 +220,13 @@
}
TEST_F(Aes128GcmEncrypterTest, EncryptPacket) {
- std::string key =
- quiche::QuicheTextUtils::HexDecode("d95a145250826c25a77b6a84fd4d34fc");
- std::string iv =
- quiche::QuicheTextUtils::HexDecode("50c4431ebb18283448e276e2");
+ std::string key = absl::HexStringToBytes("d95a145250826c25a77b6a84fd4d34fc");
+ std::string iv = absl::HexStringToBytes("50c4431ebb18283448e276e2");
uint64_t packet_num = 0x13278f44;
std::string aad =
- quiche::QuicheTextUtils::HexDecode("875d49f64a70c9cbe713278f44ff000005");
- std::string pt =
- quiche::QuicheTextUtils::HexDecode("aa0003a250bd000000000001");
- std::string ct = quiche::QuicheTextUtils::HexDecode(
+ absl::HexStringToBytes("875d49f64a70c9cbe713278f44ff000005");
+ std::string pt = absl::HexStringToBytes("aa0003a250bd000000000001");
+ std::string ct = absl::HexStringToBytes(
"7dd4708b989ee7d38a013e3656e9b37beefd05808fe1ab41e3b4f2c0");
std::vector<char> out(ct.size());
@@ -260,14 +258,13 @@
TEST_F(Aes128GcmEncrypterTest, GenerateHeaderProtectionMask) {
Aes128GcmEncrypter encrypter;
- std::string key =
- quiche::QuicheTextUtils::HexDecode("d9132370cb18476ab833649cf080d970");
+ std::string key = absl::HexStringToBytes("d9132370cb18476ab833649cf080d970");
std::string sample =
- quiche::QuicheTextUtils::HexDecode("d1d7998068517adb769b48b924a32c47");
+ absl::HexStringToBytes("d1d7998068517adb769b48b924a32c47");
ASSERT_TRUE(encrypter.SetHeaderProtectionKey(key));
std::string mask = encrypter.GenerateHeaderProtectionMask(sample);
std::string expected_mask =
- quiche::QuicheTextUtils::HexDecode("b132c37d6164da4ea4dc9b763aceec27");
+ absl::HexStringToBytes("b132c37d6164da4ea4dc9b763aceec27");
quiche::test::CompareCharArraysWithHexError(
"header protection mask", mask.data(), mask.size(), expected_mask.data(),
expected_mask.size());
diff --git a/quic/core/crypto/aes_256_gcm_decrypter_test.cc b/quic/core/crypto/aes_256_gcm_decrypter_test.cc
index ef7bb95..c688ce4 100644
--- a/quic/core/crypto/aes_256_gcm_decrypter_test.cc
+++ b/quic/core/crypto/aes_256_gcm_decrypter_test.cc
@@ -8,6 +8,7 @@
#include <string>
#include "absl/base/macros.h"
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
@@ -233,14 +234,14 @@
bool has_pt = test_vectors[j].pt;
// Decode the test vector.
- std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[j].key);
- std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[j].iv);
- std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[j].ct);
- std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[j].aad);
- std::string tag = quiche::QuicheTextUtils::HexDecode(test_vectors[j].tag);
+ std::string key = absl::HexStringToBytes(test_vectors[j].key);
+ std::string iv = absl::HexStringToBytes(test_vectors[j].iv);
+ std::string ct = absl::HexStringToBytes(test_vectors[j].ct);
+ std::string aad = absl::HexStringToBytes(test_vectors[j].aad);
+ std::string tag = absl::HexStringToBytes(test_vectors[j].tag);
std::string pt;
if (has_pt) {
- pt = quiche::QuicheTextUtils::HexDecode(test_vectors[j].pt);
+ pt = absl::HexStringToBytes(test_vectors[j].pt);
}
// The test vector's lengths should look sane. Note that the lengths
@@ -279,15 +280,15 @@
TEST_F(Aes256GcmDecrypterTest, GenerateHeaderProtectionMask) {
Aes256GcmDecrypter decrypter;
- std::string key = quiche::QuicheTextUtils::HexDecode(
+ std::string key = absl::HexStringToBytes(
"ed23ecbf54d426def5c52c3dcfc84434e62e57781d3125bb21ed91b7d3e07788");
std::string sample =
- quiche::QuicheTextUtils::HexDecode("4d190c474be2b8babafb49ec4e38e810");
+ absl::HexStringToBytes("4d190c474be2b8babafb49ec4e38e810");
QuicDataReader sample_reader(sample.data(), sample.size());
ASSERT_TRUE(decrypter.SetHeaderProtectionKey(key));
std::string mask = decrypter.GenerateHeaderProtectionMask(&sample_reader);
std::string expected_mask =
- quiche::QuicheTextUtils::HexDecode("db9ed4e6ccd033af2eae01407199c56e");
+ absl::HexStringToBytes("db9ed4e6ccd033af2eae01407199c56e");
quiche::test::CompareCharArraysWithHexError(
"header protection mask", mask.data(), mask.size(), expected_mask.data(),
expected_mask.size());
diff --git a/quic/core/crypto/aes_256_gcm_encrypter_test.cc b/quic/core/crypto/aes_256_gcm_encrypter_test.cc
index c6bb294..c09f8a8 100644
--- a/quic/core/crypto/aes_256_gcm_encrypter_test.cc
+++ b/quic/core/crypto/aes_256_gcm_encrypter_test.cc
@@ -8,6 +8,7 @@
#include <string>
#include "absl/base/macros.h"
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
@@ -190,12 +191,12 @@
const TestGroupInfo& test_info = test_group_info[i];
for (size_t j = 0; test_vectors[j].key != nullptr; j++) {
// Decode the test vector.
- std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[j].key);
- std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[j].iv);
- std::string pt = quiche::QuicheTextUtils::HexDecode(test_vectors[j].pt);
- std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[j].aad);
- std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[j].ct);
- std::string tag = quiche::QuicheTextUtils::HexDecode(test_vectors[j].tag);
+ std::string key = absl::HexStringToBytes(test_vectors[j].key);
+ std::string iv = absl::HexStringToBytes(test_vectors[j].iv);
+ std::string pt = absl::HexStringToBytes(test_vectors[j].pt);
+ std::string aad = absl::HexStringToBytes(test_vectors[j].aad);
+ std::string ct = absl::HexStringToBytes(test_vectors[j].ct);
+ std::string tag = absl::HexStringToBytes(test_vectors[j].tag);
// The test vector's lengths should look sane. Note that the lengths
// in |test_info| are in bits.
@@ -242,14 +243,14 @@
TEST_F(Aes256GcmEncrypterTest, GenerateHeaderProtectionMask) {
Aes256GcmEncrypter encrypter;
- std::string key = quiche::QuicheTextUtils::HexDecode(
+ std::string key = absl::HexStringToBytes(
"ed23ecbf54d426def5c52c3dcfc84434e62e57781d3125bb21ed91b7d3e07788");
std::string sample =
- quiche::QuicheTextUtils::HexDecode("4d190c474be2b8babafb49ec4e38e810");
+ absl::HexStringToBytes("4d190c474be2b8babafb49ec4e38e810");
ASSERT_TRUE(encrypter.SetHeaderProtectionKey(key));
std::string mask = encrypter.GenerateHeaderProtectionMask(sample);
std::string expected_mask =
- quiche::QuicheTextUtils::HexDecode("db9ed4e6ccd033af2eae01407199c56e");
+ absl::HexStringToBytes("db9ed4e6ccd033af2eae01407199c56e");
quiche::test::CompareCharArraysWithHexError(
"header protection mask", mask.data(), mask.size(), expected_mask.data(),
expected_mask.size());
diff --git a/quic/core/crypto/cert_compressor_test.cc b/quic/core/crypto/cert_compressor_test.cc
index 6a3c27c..87446ac 100644
--- a/quic/core/crypto/cert_compressor_test.cc
+++ b/quic/core/crypto/cert_compressor_test.cc
@@ -7,6 +7,7 @@
#include <memory>
#include <string>
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
@@ -22,7 +23,7 @@
std::vector<std::string> chain;
const std::string compressed = CertCompressor::CompressChain(
chain, absl::string_view(), absl::string_view(), nullptr);
- EXPECT_EQ("00", quiche::QuicheTextUtils::HexEncode(compressed));
+ EXPECT_EQ("00", absl::BytesToHexString(compressed));
std::vector<std::string> chain2, cached_certs;
ASSERT_TRUE(CertCompressor::DecompressChain(compressed, cached_certs, nullptr,
@@ -36,8 +37,7 @@
const std::string compressed = CertCompressor::CompressChain(
chain, absl::string_view(), absl::string_view(), nullptr);
ASSERT_GE(compressed.size(), 2u);
- EXPECT_EQ("0100",
- quiche::QuicheTextUtils::HexEncode(compressed.substr(0, 2)));
+ EXPECT_EQ("0100", absl::BytesToHexString(compressed.substr(0, 2)));
std::vector<std::string> chain2, cached_certs;
ASSERT_TRUE(CertCompressor::DecompressChain(compressed, cached_certs, nullptr,
@@ -62,7 +62,7 @@
"2a00000000000000" /* set hash 42 */
"01000000" /* index 1 */
"00" /* end of list */,
- quiche::QuicheTextUtils::HexEncode(compressed));
+ absl::BytesToHexString(compressed));
std::vector<std::string> chain2, cached_certs;
ASSERT_TRUE(CertCompressor::DecompressChain(compressed, cached_certs,
@@ -79,9 +79,9 @@
const std::string compressed = CertCompressor::CompressChain(
chain, absl::string_view(), hash_bytes, nullptr);
- EXPECT_EQ("02" /* cached */ + quiche::QuicheTextUtils::HexEncode(hash_bytes) +
+ EXPECT_EQ("02" /* cached */ + absl::BytesToHexString(hash_bytes) +
"00" /* end of list */,
- quiche::QuicheTextUtils::HexEncode(compressed));
+ absl::BytesToHexString(compressed));
std::vector<std::string> cached_certs, chain2;
cached_certs.push_back(chain[0]);
@@ -95,37 +95,37 @@
std::vector<std::string> cached_certs, chain;
EXPECT_FALSE(CertCompressor::DecompressChain(
- quiche::QuicheTextUtils::HexEncode("04") /* bad entry type */,
- cached_certs, nullptr, &chain));
+ absl::BytesToHexString("04") /* bad entry type */, cached_certs, nullptr,
+ &chain));
EXPECT_FALSE(CertCompressor::DecompressChain(
- quiche::QuicheTextUtils::HexEncode("01") /* no terminator */,
- cached_certs, nullptr, &chain));
+ absl::BytesToHexString("01") /* no terminator */, cached_certs, nullptr,
+ &chain));
EXPECT_FALSE(CertCompressor::DecompressChain(
- quiche::QuicheTextUtils::HexEncode("0200") /* hash truncated */,
- cached_certs, nullptr, &chain));
+ absl::BytesToHexString("0200") /* hash truncated */, cached_certs,
+ nullptr, &chain));
EXPECT_FALSE(CertCompressor::DecompressChain(
- quiche::QuicheTextUtils::HexEncode("0300") /* hash and index truncated */,
+ absl::BytesToHexString("0300") /* hash and index truncated */,
cached_certs, nullptr, &chain));
/* without a CommonCertSets */
- EXPECT_FALSE(CertCompressor::DecompressChain(
- quiche::QuicheTextUtils::HexEncode("03"
- "0000000000000000"
- "00000000"),
- cached_certs, nullptr, &chain));
+ EXPECT_FALSE(
+ CertCompressor::DecompressChain(absl::BytesToHexString("03"
+ "0000000000000000"
+ "00000000"),
+ cached_certs, nullptr, &chain));
std::unique_ptr<CommonCertSets> common_sets(
crypto_test_utils::MockCommonCertSets("foo", 42, 1));
/* incorrect hash and index */
- EXPECT_FALSE(CertCompressor::DecompressChain(
- quiche::QuicheTextUtils::HexEncode("03"
- "a200000000000000"
- "00000000"),
- cached_certs, nullptr, &chain));
+ EXPECT_FALSE(
+ CertCompressor::DecompressChain(absl::BytesToHexString("03"
+ "a200000000000000"
+ "00000000"),
+ cached_certs, nullptr, &chain));
}
} // namespace test
diff --git a/quic/core/crypto/chacha20_poly1305_decrypter_test.cc b/quic/core/crypto/chacha20_poly1305_decrypter_test.cc
index ab1baad..3711104 100644
--- a/quic/core/crypto/chacha20_poly1305_decrypter_test.cc
+++ b/quic/core/crypto/chacha20_poly1305_decrypter_test.cc
@@ -7,6 +7,7 @@
#include <memory>
#include <string>
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
@@ -143,15 +144,14 @@
bool has_pt = test_vectors[i].pt;
// Decode the test vector.
- std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[i].key);
- std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[i].iv);
- std::string fixed =
- quiche::QuicheTextUtils::HexDecode(test_vectors[i].fixed);
- std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[i].aad);
- std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[i].ct);
+ std::string key = absl::HexStringToBytes(test_vectors[i].key);
+ std::string iv = absl::HexStringToBytes(test_vectors[i].iv);
+ std::string fixed = absl::HexStringToBytes(test_vectors[i].fixed);
+ std::string aad = absl::HexStringToBytes(test_vectors[i].aad);
+ std::string ct = absl::HexStringToBytes(test_vectors[i].ct);
std::string pt;
if (has_pt) {
- pt = quiche::QuicheTextUtils::HexDecode(test_vectors[i].pt);
+ pt = absl::HexStringToBytes(test_vectors[i].pt);
}
ChaCha20Poly1305Decrypter decrypter;
diff --git a/quic/core/crypto/chacha20_poly1305_encrypter_test.cc b/quic/core/crypto/chacha20_poly1305_encrypter_test.cc
index ec6b887..91b32ef 100644
--- a/quic/core/crypto/chacha20_poly1305_encrypter_test.cc
+++ b/quic/core/crypto/chacha20_poly1305_encrypter_test.cc
@@ -92,7 +92,7 @@
ChaCha20Poly1305Encrypter encrypter;
ChaCha20Poly1305Decrypter decrypter;
- std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[0].key);
+ std::string key = absl::HexStringToBytes(test_vectors[0].key);
ASSERT_TRUE(encrypter.SetKey(key));
ASSERT_TRUE(decrypter.SetKey(key));
ASSERT_TRUE(encrypter.SetNoncePrefix("abcd"));
@@ -116,13 +116,12 @@
TEST_F(ChaCha20Poly1305EncrypterTest, Encrypt) {
for (size_t i = 0; test_vectors[i].key != nullptr; i++) {
// Decode the test vector.
- std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[i].key);
- std::string pt = quiche::QuicheTextUtils::HexDecode(test_vectors[i].pt);
- std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[i].iv);
- std::string fixed =
- quiche::QuicheTextUtils::HexDecode(test_vectors[i].fixed);
- std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[i].aad);
- std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[i].ct);
+ std::string key = absl::HexStringToBytes(test_vectors[i].key);
+ std::string pt = absl::HexStringToBytes(test_vectors[i].pt);
+ std::string iv = absl::HexStringToBytes(test_vectors[i].iv);
+ std::string fixed = absl::HexStringToBytes(test_vectors[i].fixed);
+ std::string aad = absl::HexStringToBytes(test_vectors[i].aad);
+ std::string ct = absl::HexStringToBytes(test_vectors[i].ct);
ChaCha20Poly1305Encrypter encrypter;
ASSERT_TRUE(encrypter.SetKey(key));
diff --git a/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc b/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc
index 2c7aba1..431f012 100644
--- a/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc
+++ b/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc
@@ -7,6 +7,7 @@
#include <memory>
#include <string>
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
@@ -138,15 +139,14 @@
bool has_pt = test_vectors[i].pt;
// Decode the test vector.
- std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[i].key);
- std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[i].iv);
- std::string fixed =
- quiche::QuicheTextUtils::HexDecode(test_vectors[i].fixed);
- std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[i].aad);
- std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[i].ct);
+ std::string key = absl::HexStringToBytes(test_vectors[i].key);
+ std::string iv = absl::HexStringToBytes(test_vectors[i].iv);
+ std::string fixed = absl::HexStringToBytes(test_vectors[i].fixed);
+ std::string aad = absl::HexStringToBytes(test_vectors[i].aad);
+ std::string ct = absl::HexStringToBytes(test_vectors[i].ct);
std::string pt;
if (has_pt) {
- pt = quiche::QuicheTextUtils::HexDecode(test_vectors[i].pt);
+ pt = absl::HexStringToBytes(test_vectors[i].pt);
}
ChaCha20Poly1305TlsDecrypter decrypter;
@@ -172,14 +172,14 @@
TEST_F(ChaCha20Poly1305TlsDecrypterTest, GenerateHeaderProtectionMask) {
ChaCha20Poly1305TlsDecrypter decrypter;
- std::string key = quiche::QuicheTextUtils::HexDecode(
+ std::string key = absl::HexStringToBytes(
"6a067f432787bd6034dd3f08f07fc9703a27e58c70e2d88d948b7f6489923cc7");
std::string sample =
- quiche::QuicheTextUtils::HexDecode("1210d91cceb45c716b023f492c29e612");
+ absl::HexStringToBytes("1210d91cceb45c716b023f492c29e612");
QuicDataReader sample_reader(sample.data(), sample.size());
ASSERT_TRUE(decrypter.SetHeaderProtectionKey(key));
std::string mask = decrypter.GenerateHeaderProtectionMask(&sample_reader);
- std::string expected_mask = quiche::QuicheTextUtils::HexDecode("1cc2cd98dc");
+ std::string expected_mask = absl::HexStringToBytes("1cc2cd98dc");
quiche::test::CompareCharArraysWithHexError(
"header protection mask", mask.data(), mask.size(), expected_mask.data(),
expected_mask.size());
diff --git a/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc b/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc
index 276a413..1918d2a 100644
--- a/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc
+++ b/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc
@@ -8,6 +8,7 @@
#include <string>
#include "absl/base/macros.h"
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/chacha20_poly1305_tls_decrypter.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
@@ -92,7 +93,7 @@
ChaCha20Poly1305TlsEncrypter encrypter;
ChaCha20Poly1305TlsDecrypter decrypter;
- std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[0].key);
+ std::string key = absl::HexStringToBytes(test_vectors[0].key);
ASSERT_TRUE(encrypter.SetKey(key));
ASSERT_TRUE(decrypter.SetKey(key));
ASSERT_TRUE(encrypter.SetIV("abcdefghijkl"));
@@ -116,13 +117,12 @@
TEST_F(ChaCha20Poly1305TlsEncrypterTest, Encrypt) {
for (size_t i = 0; test_vectors[i].key != nullptr; i++) {
// Decode the test vector.
- std::string key = quiche::QuicheTextUtils::HexDecode(test_vectors[i].key);
- std::string pt = quiche::QuicheTextUtils::HexDecode(test_vectors[i].pt);
- std::string iv = quiche::QuicheTextUtils::HexDecode(test_vectors[i].iv);
- std::string fixed =
- quiche::QuicheTextUtils::HexDecode(test_vectors[i].fixed);
- std::string aad = quiche::QuicheTextUtils::HexDecode(test_vectors[i].aad);
- std::string ct = quiche::QuicheTextUtils::HexDecode(test_vectors[i].ct);
+ std::string key = absl::HexStringToBytes(test_vectors[i].key);
+ std::string pt = absl::HexStringToBytes(test_vectors[i].pt);
+ std::string iv = absl::HexStringToBytes(test_vectors[i].iv);
+ std::string fixed = absl::HexStringToBytes(test_vectors[i].fixed);
+ std::string aad = absl::HexStringToBytes(test_vectors[i].aad);
+ std::string ct = absl::HexStringToBytes(test_vectors[i].ct);
ChaCha20Poly1305TlsEncrypter encrypter;
ASSERT_TRUE(encrypter.SetKey(key));
@@ -158,13 +158,13 @@
TEST_F(ChaCha20Poly1305TlsEncrypterTest, GenerateHeaderProtectionMask) {
ChaCha20Poly1305TlsEncrypter encrypter;
- std::string key = quiche::QuicheTextUtils::HexDecode(
+ std::string key = absl::HexStringToBytes(
"6a067f432787bd6034dd3f08f07fc9703a27e58c70e2d88d948b7f6489923cc7");
std::string sample =
- quiche::QuicheTextUtils::HexDecode("1210d91cceb45c716b023f492c29e612");
+ absl::HexStringToBytes("1210d91cceb45c716b023f492c29e612");
ASSERT_TRUE(encrypter.SetHeaderProtectionKey(key));
std::string mask = encrypter.GenerateHeaderProtectionMask(sample);
- std::string expected_mask = quiche::QuicheTextUtils::HexDecode("1cc2cd98dc");
+ std::string expected_mask = absl::HexStringToBytes("1cc2cd98dc");
quiche::test::CompareCharArraysWithHexError(
"header protection mask", mask.data(), mask.size(), expected_mask.data(),
expected_mask.size());
diff --git a/quic/core/crypto/crypto_handshake_message.cc b/quic/core/crypto/crypto_handshake_message.cc
index 1b61da3..75bd3fe 100644
--- a/quic/core/crypto/crypto_handshake_message.cc
+++ b/quic/core/crypto/crypto_handshake_message.cc
@@ -7,6 +7,7 @@
#include <memory>
#include <string>
+#include "absl/strings/escaping.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_protocol.h"
@@ -370,7 +371,7 @@
if (!done) {
// If there's no specific format for this tag, or the value is invalid,
// then just use hex.
- ret += "0x" + quiche::QuicheTextUtils::HexEncode(it->second);
+ ret += "0x" + absl::BytesToHexString(it->second);
}
ret += "\n";
}
diff --git a/quic/core/crypto/crypto_message_printer_bin.cc b/quic/core/crypto/crypto_message_printer_bin.cc
index f5584ad..9a4e223 100644
--- a/quic/core/crypto/crypto_message_printer_bin.cc
+++ b/quic/core/crypto/crypto_message_printer_bin.cc
@@ -10,6 +10,7 @@
#include <iostream>
#include <string>
+#include "absl/strings/escaping.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
@@ -47,7 +48,7 @@
quic::CryptoFramer framer;
framer.set_visitor(&printer);
framer.set_process_truncated_messages(true);
- std::string input = quiche::QuicheTextUtils::HexDecode(messages[0]);
+ std::string input = absl::HexStringToBytes(messages[0]);
if (!framer.ProcessInput(input)) {
return 1;
}
diff --git a/quic/core/crypto/crypto_server_test.cc b/quic/core/crypto/crypto_server_test.cc
index c68fcc2..51dc418 100644
--- a/quic/core/crypto/crypto_server_test.cc
+++ b/quic/core/crypto/crypto_server_test.cc
@@ -11,6 +11,7 @@
#include <vector>
#include "absl/base/macros.h"
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "third_party/boringssl/src/include/openssl/sha.h"
#include "net/third_party/quiche/src/quic/core/crypto/cert_compressor.h"
@@ -135,9 +136,9 @@
char public_value[32];
memset(public_value, 42, sizeof(public_value));
- nonce_hex_ = "#" + quiche::QuicheTextUtils::HexEncode(GenerateNonce());
- pub_hex_ = "#" + quiche::QuicheTextUtils::HexEncode(public_value,
- sizeof(public_value));
+ nonce_hex_ = "#" + absl::BytesToHexString(GenerateNonce());
+ pub_hex_ = "#" + absl::BytesToHexString(
+ absl::string_view(public_value, sizeof(public_value)));
CryptoHandshakeMessage client_hello =
crypto_test_utils::CreateCHLO({{"PDMD", "X509"},
@@ -158,7 +159,7 @@
absl::string_view srct;
ASSERT_TRUE(out_.GetStringPiece(kSourceAddressTokenTag, &srct));
- srct_hex_ = "#" + quiche::QuicheTextUtils::HexEncode(srct);
+ srct_hex_ = "#" + absl::BytesToHexString(srct);
absl::string_view scfg;
ASSERT_TRUE(out_.GetStringPiece(kSCFG, &scfg));
@@ -166,7 +167,7 @@
absl::string_view scid;
ASSERT_TRUE(server_config_->GetStringPiece(kSCID, &scid));
- scid_hex_ = "#" + quiche::QuicheTextUtils::HexEncode(scid);
+ scid_hex_ = "#" + absl::BytesToHexString(scid);
signed_config_ = QuicReferenceCountedPointer<QuicSignedServerConfig>(
new QuicSignedServerConfig());
@@ -340,8 +341,8 @@
std::string XlctHexString() {
uint64_t xlct = crypto_test_utils::LeafCertHashForTesting();
- return "#" + quiche::QuicheTextUtils::HexEncode(
- reinterpret_cast<char*>(&xlct), sizeof(xlct));
+ return "#" + absl::BytesToHexString(absl::string_view(
+ reinterpret_cast<char*>(&xlct), sizeof(xlct)));
}
protected:
diff --git a/quic/core/crypto/crypto_utils_test.cc b/quic/core/crypto/crypto_utils_test.cc
index 1c67cc8..e0d1165 100644
--- a/quic/core/crypto/crypto_utils_test.cc
+++ b/quic/core/crypto/crypto_utils_test.cc
@@ -7,6 +7,7 @@
#include <string>
#include "absl/base/macros.h"
+#include "absl/strings/escaping.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"
@@ -53,16 +54,14 @@
for (size_t i = 0; i < ABSL_ARRAYSIZE(test_vector); i++) {
// Decode the test vector.
std::string subkey_secret =
- quiche::QuicheTextUtils::HexDecode(test_vector[i].subkey_secret);
- std::string label =
- quiche::QuicheTextUtils::HexDecode(test_vector[i].label);
- std::string context =
- quiche::QuicheTextUtils::HexDecode(test_vector[i].context);
+ absl::HexStringToBytes(test_vector[i].subkey_secret);
+ std::string label = absl::HexStringToBytes(test_vector[i].label);
+ std::string context = absl::HexStringToBytes(test_vector[i].context);
size_t result_len = test_vector[i].result_len;
bool expect_ok = test_vector[i].expected != nullptr;
std::string expected;
if (expect_ok) {
- expected = quiche::QuicheTextUtils::HexDecode(test_vector[i].expected);
+ expected = absl::HexStringToBytes(test_vector[i].expected);
}
std::string result;
diff --git a/quic/core/crypto/quic_crypto_server_config.cc b/quic/core/crypto/quic_crypto_server_config.cc
index 42379ad..5169f9b 100644
--- a/quic/core/crypto/quic_crypto_server_config.cc
+++ b/quic/core/crypto/quic_crypto_server_config.cc
@@ -11,6 +11,7 @@
#include <utility>
#include "absl/base/attributes.h"
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "third_party/boringssl/src/include/openssl/sha.h"
#include "third_party/boringssl/src/include/openssl/ssl.h"
@@ -408,7 +409,7 @@
if (configs_.find(config->id) != configs_.end()) {
QUIC_LOG(WARNING) << "Failed to add config because another with the same "
"server config id already exists: "
- << quiche::QuicheTextUtils::HexEncode(config->id);
+ << absl::BytesToHexString(config->id);
return nullptr;
}
@@ -454,7 +455,7 @@
return false;
}
QUIC_LOG(INFO) << "Fallback config has scid "
- << quiche::QuicheTextUtils::HexEncode(fallback_config->id);
+ << absl::BytesToHexString(fallback_config->id);
parsed_configs.push_back(fallback_config);
} else {
QUIC_LOG(INFO) << "No fallback config provided";
@@ -474,26 +475,27 @@
for (const QuicReferenceCountedPointer<Config>& config : parsed_configs) {
auto it = configs_.find(config->id);
if (it != configs_.end()) {
- QUIC_LOG(INFO)
- << "Keeping scid: " << quiche::QuicheTextUtils::HexEncode(config->id)
- << " orbit: "
- << quiche::QuicheTextUtils::HexEncode(
- reinterpret_cast<const char*>(config->orbit), kOrbitSize)
- << " new primary_time " << config->primary_time.ToUNIXSeconds()
- << " old primary_time " << it->second->primary_time.ToUNIXSeconds()
- << " new priority " << config->priority << " old priority "
- << it->second->priority;
+ QUIC_LOG(INFO) << "Keeping scid: " << absl::BytesToHexString(config->id)
+ << " orbit: "
+ << absl::BytesToHexString(absl::string_view(
+ reinterpret_cast<const char*>(config->orbit),
+ kOrbitSize))
+ << " new primary_time "
+ << config->primary_time.ToUNIXSeconds()
+ << " old primary_time "
+ << it->second->primary_time.ToUNIXSeconds()
+ << " new priority " << config->priority << " old priority "
+ << it->second->priority;
// Update primary_time and priority.
it->second->primary_time = config->primary_time;
it->second->priority = config->priority;
new_configs.insert(*it);
} else {
- QUIC_LOG(INFO) << "Adding scid: "
- << quiche::QuicheTextUtils::HexEncode(config->id)
+ QUIC_LOG(INFO) << "Adding scid: " << absl::BytesToHexString(config->id)
<< " orbit: "
- << quiche::QuicheTextUtils::HexEncode(
+ << absl::BytesToHexString(absl::string_view(
reinterpret_cast<const char*>(config->orbit),
- kOrbitSize)
+ kOrbitSize))
<< " primary_time " << config->primary_time.ToUNIXSeconds()
<< " priority " << config->priority;
new_configs.emplace(config->id, config);
@@ -1172,10 +1174,10 @@
primary_config_ = new_primary;
new_primary->is_primary = true;
QUIC_DLOG(INFO) << "New primary config. orbit: "
- << quiche::QuicheTextUtils::HexEncode(
- reinterpret_cast<const char*>(
- primary_config_->orbit),
- kOrbitSize);
+ << absl::BytesToHexString(
+ absl::string_view(reinterpret_cast<const char*>(
+ primary_config_->orbit),
+ kOrbitSize));
if (primary_config_changed_cb_ != nullptr) {
primary_config_changed_cb_->Run(primary_config_->id);
}
@@ -1192,11 +1194,10 @@
primary_config_ = new_primary;
new_primary->is_primary = true;
QUIC_DLOG(INFO) << "New primary config. orbit: "
- << quiche::QuicheTextUtils::HexEncode(
+ << absl::BytesToHexString(absl::string_view(
reinterpret_cast<const char*>(primary_config_->orbit),
- kOrbitSize)
- << " scid: "
- << quiche::QuicheTextUtils::HexEncode(primary_config_->id);
+ kOrbitSize))
+ << " scid: " << absl::BytesToHexString(primary_config_->id);
next_config_promotion_time_ = QuicWallTime::Zero();
if (primary_config_changed_cb_ != nullptr) {
primary_config_changed_cb_->Run(primary_config_->id);
diff --git a/quic/core/crypto/quic_hkdf_test.cc b/quic/core/crypto/quic_hkdf_test.cc
index bee3540..48e089f 100644
--- a/quic/core/crypto/quic_hkdf_test.cc
+++ b/quic/core/crypto/quic_hkdf_test.cc
@@ -7,6 +7,7 @@
#include <string>
#include "absl/base/macros.h"
+#include "absl/strings/escaping.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
@@ -71,11 +72,10 @@
const HKDFInput& test(kHKDFInputs[i]);
SCOPED_TRACE(i);
- const std::string key = quiche::QuicheTextUtils::HexDecode(test.key_hex);
- const std::string salt = quiche::QuicheTextUtils::HexDecode(test.salt_hex);
- const std::string info = quiche::QuicheTextUtils::HexDecode(test.info_hex);
- const std::string expected =
- quiche::QuicheTextUtils::HexDecode(test.output_hex);
+ const std::string key = absl::HexStringToBytes(test.key_hex);
+ const std::string salt = absl::HexStringToBytes(test.salt_hex);
+ const std::string info = absl::HexStringToBytes(test.info_hex);
+ const std::string expected = absl::HexStringToBytes(test.output_hex);
// We set the key_length to the length of the expected output and then take
// the result from the first key, which is the client write key.
diff --git a/quic/core/crypto/transport_parameters.cc b/quic/core/crypto/transport_parameters.cc
index b143d9d..c047e0f 100644
--- a/quic/core/crypto/transport_parameters.cc
+++ b/quic/core/crypto/transport_parameters.cc
@@ -10,6 +10,7 @@
#include <memory>
#include <utility>
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "third_party/boringssl/src/include/openssl/digest.h"
#include "third_party/boringssl/src/include/openssl/sha.h"
@@ -394,9 +395,9 @@
return "[" + ipv4_socket_address.ToString() + " " +
ipv6_socket_address.ToString() + " connection_id " +
connection_id.ToString() + " stateless_reset_token " +
- quiche::QuicheTextUtils::HexEncode(
+ absl::BytesToHexString(absl::string_view(
reinterpret_cast<const char*>(stateless_reset_token.data()),
- stateless_reset_token.size()) +
+ stateless_reset_token.size())) +
"]";
}
@@ -426,9 +427,9 @@
rv += max_idle_timeout_ms.ToString(/*for_use_in_list=*/true);
if (!stateless_reset_token.empty()) {
rv += " " + TransportParameterIdToString(kStatelessResetToken) + " " +
- quiche::QuicheTextUtils::HexEncode(
+ absl::BytesToHexString(absl::string_view(
reinterpret_cast<const char*>(stateless_reset_token.data()),
- stateless_reset_token.size());
+ stateless_reset_token.size()));
}
rv += max_udp_payload_size.ToString(/*for_use_in_list=*/true);
rv += initial_max_data.ToString(/*for_use_in_list=*/true);
@@ -485,10 +486,10 @@
rv += "=";
static constexpr size_t kMaxPrintableLength = 32;
if (kv.second.length() <= kMaxPrintableLength) {
- rv += quiche::QuicheTextUtils::HexEncode(kv.second);
+ rv += absl::BytesToHexString(kv.second);
} else {
absl::string_view truncated(kv.second.data(), kMaxPrintableLength);
- rv += quiche::QuicheStrCat(quiche::QuicheTextUtils::HexEncode(truncated),
+ rv += quiche::QuicheStrCat(absl::BytesToHexString(truncated),
"...(length ", kv.second.length(), ")");
}
}
diff --git a/quic/core/frames/quic_new_token_frame.cc b/quic/core/frames/quic_new_token_frame.cc
index 0178422..6806cda 100644
--- a/quic/core/frames/quic_new_token_frame.cc
+++ b/quic/core/frames/quic_new_token_frame.cc
@@ -4,6 +4,7 @@
#include "net/third_party/quiche/src/quic/core/frames/quic_new_token_frame.h"
+#include "absl/strings/escaping.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
@@ -15,7 +16,7 @@
std::ostream& operator<<(std::ostream& os, const QuicNewTokenFrame& s) {
os << "{ control_frame_id: " << s.control_frame_id
- << ", token: " << quiche::QuicheTextUtils::HexEncode(s.token) << " }\n";
+ << ", token: " << absl::BytesToHexString(s.token) << " }\n";
return os;
}
diff --git a/quic/core/frames/quic_path_challenge_frame.cc b/quic/core/frames/quic_path_challenge_frame.cc
index 4a8d120..eb841b2 100644
--- a/quic/core/frames/quic_path_challenge_frame.cc
+++ b/quic/core/frames/quic_path_challenge_frame.cc
@@ -4,6 +4,7 @@
#include "net/third_party/quiche/src/quic/core/frames/quic_path_challenge_frame.h"
+#include "absl/strings/escaping.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
@@ -21,9 +22,9 @@
std::ostream& operator<<(std::ostream& os,
const QuicPathChallengeFrame& frame) {
os << "{ control_frame_id: " << frame.control_frame_id << ", data: "
- << quiche::QuicheTextUtils::HexEncode(
+ << absl::BytesToHexString(absl::string_view(
reinterpret_cast<const char*>(frame.data_buffer.data()),
- frame.data_buffer.size())
+ frame.data_buffer.size()))
<< " }\n";
return os;
}
diff --git a/quic/core/frames/quic_path_response_frame.cc b/quic/core/frames/quic_path_response_frame.cc
index 4779c6a..1623777 100644
--- a/quic/core/frames/quic_path_response_frame.cc
+++ b/quic/core/frames/quic_path_response_frame.cc
@@ -4,6 +4,7 @@
#include "net/third_party/quiche/src/quic/core/frames/quic_path_response_frame.h"
+#include "absl/strings/escaping.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
@@ -20,9 +21,9 @@
std::ostream& operator<<(std::ostream& os, const QuicPathResponseFrame& frame) {
os << "{ control_frame_id: " << frame.control_frame_id << ", data: "
- << quiche::QuicheTextUtils::HexEncode(
+ << absl::BytesToHexString(absl::string_view(
reinterpret_cast<const char*>(frame.data_buffer.data()),
- frame.data_buffer.size())
+ frame.data_buffer.size()))
<< " }\n";
return os;
}
diff --git a/quic/core/http/http_decoder_test.cc b/quic/core/http/http_decoder_test.cc
index 9558b9a..7702b0d 100644
--- a/quic/core/http/http_decoder_test.cc
+++ b/quic/core/http/http_decoder_test.cc
@@ -8,6 +8,7 @@
#include <utility>
#include "absl/base/macros.h"
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/http/http_encoder.h"
#include "net/third_party/quiche/src/quic/core/http/http_frames.h"
@@ -229,7 +230,7 @@
TEST_F(HttpDecoderTest, CancelPush) {
InSequence s;
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"03" // type (CANCEL_PUSH)
"01" // length
"01"); // Push Id
@@ -257,10 +258,10 @@
TEST_F(HttpDecoderTest, PushPromiseFrame) {
InSequence s;
std::string input = quiche::QuicheStrCat(
- quiche::QuicheTextUtils::HexDecode("05" // type (PUSH PROMISE)
- "0f" // length
- "C000000000000101"), // push id 257
- "Headers"); // headers
+ absl::HexStringToBytes("05" // type (PUSH PROMISE)
+ "0f" // length
+ "C000000000000101"), // push id 257
+ "Headers"); // headers
// Visitor pauses processing.
EXPECT_CALL(visitor_, OnPushPromiseFrameStart(2)).WillOnce(Return(false));
@@ -325,7 +326,7 @@
TEST_F(HttpDecoderTest, CorruptPushPromiseFrame) {
InSequence s;
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"05" // type (PUSH_PROMISE)
"01" // length
"40"); // first byte of two-byte varint push id
@@ -356,7 +357,7 @@
TEST_F(HttpDecoderTest, MaxPushId) {
InSequence s;
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"0D" // type (MAX_PUSH_ID)
"01" // length
"01"); // Push Id
@@ -383,7 +384,7 @@
TEST_F(HttpDecoderTest, SettingsFrame) {
InSequence s;
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"04" // type (SETTINGS)
"07" // length
"01" // identifier (SETTINGS_QPACK_MAX_TABLE_CAPACITY)
@@ -463,7 +464,7 @@
}
TEST_F(HttpDecoderTest, DuplicateSettingsIdentifier) {
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"04" // type (SETTINGS)
"04" // length
"01" // identifier
@@ -483,10 +484,10 @@
TEST_F(HttpDecoderTest, DataFrame) {
InSequence s;
- std::string input = quiche::QuicheStrCat(
- quiche::QuicheTextUtils::HexDecode("00" // type (DATA)
- "05"), // length
- "Data!"); // data
+ std::string input =
+ quiche::QuicheStrCat(absl::HexStringToBytes("00" // type (DATA)
+ "05"), // length
+ "Data!"); // data
// Visitor pauses processing.
EXPECT_CALL(visitor_, OnDataFrameStart(2, 5)).WillOnce(Return(false));
@@ -585,7 +586,7 @@
TEST_F(HttpDecoderTest, GoAway) {
InSequence s;
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"07" // type (GOAWAY)
"01" // length
"01"); // ID
@@ -612,10 +613,10 @@
TEST_F(HttpDecoderTest, HeadersFrame) {
InSequence s;
- std::string input = quiche::QuicheStrCat(
- quiche::QuicheTextUtils::HexDecode("01" // type (HEADERS)
- "07"), // length
- "Headers"); // headers
+ std::string input =
+ quiche::QuicheStrCat(absl::HexStringToBytes("01" // type (HEADERS)
+ "07"), // length
+ "Headers"); // headers
// Visitor pauses processing.
EXPECT_CALL(visitor_, OnHeadersFrameStart(2, 7)).WillOnce(Return(false));
@@ -660,7 +661,7 @@
TEST_F(HttpDecoderTest, EmptyDataFrame) {
InSequence s;
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"00" // type (DATA)
"00"); // length
@@ -690,7 +691,7 @@
TEST_F(HttpDecoderTest, EmptyHeadersFrame) {
InSequence s;
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"01" // type (HEADERS)
"00"); // length
@@ -720,7 +721,7 @@
TEST_F(HttpDecoderTest, PushPromiseFrameNoHeaders) {
InSequence s;
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"05" // type (PUSH_PROMISE)
"01" // length
"01"); // Push Id
@@ -754,7 +755,7 @@
}
TEST_F(HttpDecoderTest, MalformedFrameWithOverlyLargePayload) {
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"03" // type (CANCEL_PUSH)
"10" // length
"15"); // malformed payload
@@ -782,7 +783,7 @@
TEST_F(HttpDecoderTest, Http2Frame) {
SetQuicReloadableFlag(quic_reject_spdy_frames, true);
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"06" // PING in HTTP/2 but not supported in HTTP/3.
"05" // length
"15"); // random payload
@@ -797,13 +798,13 @@
TEST_F(HttpDecoderTest, HeadersPausedThenData) {
InSequence s;
- std::string input = quiche::QuicheStrCat(
- quiche::QuicheTextUtils::HexDecode("01" // type (HEADERS)
- "07"), // length
- "Headers", // headers
- quiche::QuicheTextUtils::HexDecode("00" // type (DATA)
- "05"), // length
- "Data!"); // data
+ std::string input =
+ quiche::QuicheStrCat(absl::HexStringToBytes("01" // type (HEADERS)
+ "07"), // length
+ "Headers", // headers
+ absl::HexStringToBytes("00" // type (DATA)
+ "05"), // length
+ "Data!"); // data
// Visitor pauses processing, maybe because header decompression is blocked.
EXPECT_CALL(visitor_, OnHeadersFrameStart(2, 7));
@@ -886,7 +887,7 @@
}
TEST_F(HttpDecoderTest, EmptyCancelPushFrame) {
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"03" // type (CANCEL_PUSH)
"00"); // frame length
@@ -897,7 +898,7 @@
}
TEST_F(HttpDecoderTest, EmptySettingsFrame) {
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"04" // type (SETTINGS)
"00"); // frame length
@@ -913,7 +914,7 @@
// Regression test for https://crbug.com/1001823.
TEST_F(HttpDecoderTest, EmptyPushPromiseFrame) {
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"05" // type (PUSH_PROMISE)
"00"); // frame length
@@ -924,7 +925,7 @@
}
TEST_F(HttpDecoderTest, EmptyGoAwayFrame) {
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"07" // type (GOAWAY)
"00"); // frame length
@@ -935,7 +936,7 @@
}
TEST_F(HttpDecoderTest, EmptyMaxPushIdFrame) {
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"0d" // type (MAX_PUSH_ID)
"00"); // frame length
@@ -959,7 +960,7 @@
TEST_F(HttpDecoderTest, PriorityUpdateFrame) {
InSequence s;
- std::string input1 = quiche::QuicheTextUtils::HexDecode(
+ std::string input1 = absl::HexStringToBytes(
"0f" // type (PRIORITY_UPDATE)
"02" // length
"00" // prioritized element type: REQUEST_STREAM
@@ -998,7 +999,7 @@
EXPECT_THAT(decoder_.error(), IsQuicNoError());
EXPECT_EQ("", decoder_.error_detail());
- std::string input2 = quiche::QuicheTextUtils::HexDecode(
+ std::string input2 = absl::HexStringToBytes(
"0f" // type (PRIORIRTY)
"05" // length
"80" // prioritized element type: PUSH_STREAM
@@ -1040,11 +1041,11 @@
}
TEST_F(HttpDecoderTest, CorruptPriorityUpdateFrame) {
- std::string payload1 = quiche::QuicheTextUtils::HexDecode(
+ std::string payload1 = absl::HexStringToBytes(
"80" // prioritized element type: PUSH_STREAM
"4005"); // prioritized element id
- std::string payload2 = quiche::QuicheTextUtils::HexDecode(
- "42"); // invalid prioritized element type
+ std::string payload2 =
+ absl::HexStringToBytes("42"); // invalid prioritized element type
struct {
const char* const payload;
size_t payload_length;
@@ -1076,7 +1077,7 @@
}
TEST_F(HttpDecoderTest, DecodeSettings) {
- std::string input = quiche::QuicheTextUtils::HexDecode(
+ std::string input = absl::HexStringToBytes(
"04" // type (SETTINGS)
"07" // length
"01" // identifier (SETTINGS_QPACK_MAX_TABLE_CAPACITY)
@@ -1096,7 +1097,7 @@
EXPECT_EQ(frame, out);
// non-settings frame.
- input = quiche::QuicheTextUtils::HexDecode(
+ input = absl::HexStringToBytes(
"0D" // type (MAX_PUSH_ID)
"01" // length
"01"); // Push Id
@@ -1104,7 +1105,7 @@
EXPECT_FALSE(HttpDecoder::DecodeSettings(input.data(), input.size(), &out));
// Corrupt SETTINGS.
- input = quiche::QuicheTextUtils::HexDecode(
+ input = absl::HexStringToBytes(
"04" // type (SETTINGS)
"01" // length
"42"); // First byte of setting identifier, indicating a 2-byte varint62.
diff --git a/quic/core/http/quic_receive_control_stream_test.cc b/quic/core/http/quic_receive_control_stream_test.cc
index 4aa3063..5a401b6 100644
--- a/quic/core/http/quic_receive_control_stream_test.cc
+++ b/quic/core/http/quic_receive_control_stream_test.cc
@@ -4,6 +4,7 @@
#include "net/third_party/quiche/src/quic/core/http/quic_receive_control_stream.h"
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/http/http_constants.h"
#include "net/third_party/quiche/src/quic/core/qpack/qpack_header_table.h"
@@ -336,7 +337,7 @@
EXPECT_EQ(offset, NumBytesConsumed());
// Receive unknown frame.
- std::string unknown_frame = quiche::QuicheTextUtils::HexDecode(
+ std::string unknown_frame = absl::HexStringToBytes(
"21" // reserved frame type
"03" // payload length
"666f6f"); // payload "foo"
@@ -365,7 +366,7 @@
offset += settings_frame.length();
// Receive unknown frame.
- std::string unknown_frame = quiche::QuicheTextUtils::HexDecode(
+ std::string unknown_frame = absl::HexStringToBytes(
"21" // reserved frame type
"03" // payload length
"666f6f"); // payload "foo"
@@ -377,7 +378,7 @@
}
TEST_P(QuicReceiveControlStreamTest, CancelPushFrameBeforeSettings) {
- std::string cancel_push_frame = quiche::QuicheTextUtils::HexDecode(
+ std::string cancel_push_frame = absl::HexStringToBytes(
"03" // type CANCEL_PUSH
"01" // payload length
"01"); // push ID
@@ -396,7 +397,7 @@
}
TEST_P(QuicReceiveControlStreamTest, UnknownFrameBeforeSettings) {
- std::string unknown_frame = quiche::QuicheTextUtils::HexDecode(
+ std::string unknown_frame = absl::HexStringToBytes(
"21" // reserved frame type
"03" // payload length
"666f6f"); // payload "foo"
diff --git a/quic/core/http/quic_send_control_stream_test.cc b/quic/core/http/quic_send_control_stream_test.cc
index bc49107..53d0d6d 100644
--- a/quic/core/http/quic_send_control_stream_test.cc
+++ b/quic/core/http/quic_send_control_stream_test.cc
@@ -6,6 +6,7 @@
#include <utility>
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
@@ -113,7 +114,7 @@
Initialize();
testing::InSequence s;
- std::string expected_write_data = quiche::QuicheTextUtils::HexDecode(
+ std::string expected_write_data = absl::HexStringToBytes(
"00" // stream type: control stream
"04" // frame type: SETTINGS frame
"0b" // frame length
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index d95fa6d..36ebf87 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -11,6 +11,7 @@
#include <utility>
#include "absl/base/macros.h"
+#include "absl/strings/escaping.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/crypto/null_encrypter.h"
@@ -1979,7 +1980,7 @@
EXPECT_EQ(0u, QuicSessionPeer::GetNumOpenDynamicStreams(&session_));
// Push unidirectional stream is type 0x01.
- std::string frame_type1 = quiche::QuicheTextUtils::HexDecode("01");
+ std::string frame_type1 = absl::HexStringToBytes("01");
QuicStreamId stream_id1 =
GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 0);
session_.OnStreamFrame(QuicStreamFrame(stream_id1, /* fin = */ false,
@@ -1991,7 +1992,7 @@
EXPECT_EQ(1u, session_.flow_controller()->bytes_consumed());
// The same stream type can be encoded differently.
- std::string frame_type2 = quiche::QuicheTextUtils::HexDecode("80000001");
+ std::string frame_type2 = absl::HexStringToBytes("80000001");
QuicStreamId stream_id2 =
GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 1);
session_.OnStreamFrame(QuicStreamFrame(stream_id2, /* fin = */ false,
@@ -2011,9 +2012,9 @@
EXPECT_EQ(0u, QuicSessionPeer::GetNumOpenDynamicStreams(&session_));
// Push unidirectional stream is type 0x01.
- std::string frame_type = quiche::QuicheTextUtils::HexDecode("01");
+ std::string frame_type = absl::HexStringToBytes("01");
// The first field of a push stream is the Push ID.
- std::string push_id = quiche::QuicheTextUtils::HexDecode("4000");
+ std::string push_id = absl::HexStringToBytes("4000");
QuicStreamId stream_id =
GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 0);
@@ -2485,7 +2486,7 @@
TestStream* stream = session_.CreateIncomingStream(stream_id);
// HEADERS frame referencing first dynamic table entry.
- std::string headers_payload = quiche::QuicheTextUtils::HexDecode("020080");
+ std::string headers_payload = absl::HexStringToBytes("020080");
std::unique_ptr<char[]> headers_buffer;
QuicByteCount headers_frame_header_length =
HttpEncoder::SerializeHeadersFrameHeader(headers_payload.length(),
@@ -2520,7 +2521,7 @@
TestStream* stream = session_.CreateIncomingStream(stream_id);
// HEADERS frame referencing first dynamic table entry.
- std::string headers_payload = quiche::QuicheTextUtils::HexDecode("020080");
+ std::string headers_payload = absl::HexStringToBytes("020080");
std::unique_ptr<char[]> headers_buffer;
QuicByteCount headers_frame_header_length =
HttpEncoder::SerializeHeadersFrameHeader(headers_payload.length(),
@@ -2553,7 +2554,7 @@
// Payload consists of two bytes. The first byte is an unknown unidirectional
// stream type. The second one would be the type of a push stream, but it
// must not be interpreted as stream type.
- std::string payload = quiche::QuicheTextUtils::HexDecode("3f01");
+ std::string payload = absl::HexStringToBytes("3f01");
QuicStreamFrame frame(stream_id, /* fin = */ false, /* offset = */ 0,
payload);
@@ -2599,7 +2600,7 @@
// Payload consists of two bytes. The first byte is an unknown unidirectional
// stream type. The second one would be the type of a push stream, but it
// must not be interpreted as stream type.
- std::string payload = quiche::QuicheTextUtils::HexDecode("3f01");
+ std::string payload = absl::HexStringToBytes("3f01");
QuicStreamFrame frame(stream_id, /* fin = */ false, /* offset = */ 0,
payload);
@@ -2636,7 +2637,7 @@
GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 0);
// Payload is the first byte of a two byte varint encoding.
- std::string payload = quiche::QuicheTextUtils::HexDecode("40");
+ std::string payload = absl::HexStringToBytes("40");
QuicStreamFrame frame(stream_id, /* fin = */ false, /* offset = */ 0,
payload);
@@ -2664,7 +2665,7 @@
GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 0);
// Payload is the first byte of a two byte varint encoding with a FIN.
- std::string payload = quiche::QuicheTextUtils::HexDecode("40");
+ std::string payload = absl::HexStringToBytes("40");
QuicStreamFrame frame(stream_id, /* fin = */ true, /* offset = */ 0, payload);
session_.OnStreamFrame(frame);
@@ -2741,7 +2742,7 @@
return;
}
- std::string data = quiche::QuicheTextUtils::HexDecode(
+ std::string data = absl::HexStringToBytes(
"02" // Encoder stream.
"00"); // Duplicate entry 0, but no entries exist.
@@ -2765,7 +2766,7 @@
return;
}
- std::string data = quiche::QuicheTextUtils::HexDecode(
+ std::string data = absl::HexStringToBytes(
"03" // Decoder stream.
"00"); // Insert Count Increment with forbidden increment value of zero.
@@ -2920,7 +2921,7 @@
// Index 126 does not exist (static table has 61 entries and dynamic table is
// empty).
- std::string headers_frame = quiche::QuicheTextUtils::HexDecode(
+ std::string headers_frame = absl::HexStringToBytes(
"000006" // length
"01" // type
"24" // flags: PRIORITY | END_HEADERS
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index 6cd7634..526b987 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -10,6 +10,7 @@
#include <utility>
#include "absl/base/macros.h"
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
#include "net/third_party/quiche/src/quic/core/http/http_encoder.h"
@@ -696,7 +697,7 @@
Initialize(kShouldProcessData);
// PUSH_PROMISE frame with empty payload is considered invalid.
- std::string invalid_http3_frame = quiche::QuicheTextUtils::HexDecode("0500");
+ std::string invalid_http3_frame = absl::HexStringToBytes("0500");
QuicStreamFrame stream_frame(stream_->id(), /* fin = */ false,
/* offset = */ 0, invalid_http3_frame);
@@ -712,7 +713,7 @@
Initialize(kShouldProcessData);
// SETTINGS frame with empty payload.
- std::string settings = quiche::QuicheTextUtils::HexDecode("0400");
+ std::string settings = absl::HexStringToBytes("0400");
QuicStreamFrame stream_frame(stream_->id(), /* fin = */ false,
/* offset = */ 0, settings);
@@ -2088,7 +2089,7 @@
// Random bad headers.
std::string headers =
- HeadersFrame(quiche::QuicheTextUtils::HexDecode("00002a94e7036261"));
+ HeadersFrame(absl::HexStringToBytes("00002a94e7036261"));
std::string data = DataFrame(kDataFramePayload);
std::string stream_frame_payload = quiche::QuicheStrCat(headers, data);
@@ -2164,8 +2165,7 @@
// Invalid headers: Required Insert Count is zero, but the header block
// contains a dynamic table reference.
- std::string headers =
- HeadersFrame(quiche::QuicheTextUtils::HexDecode("000080"));
+ std::string headers = HeadersFrame(absl::HexStringToBytes("000080"));
QuicStreamFrame frame(stream_->id(), false, 0, headers);
stream_->OnStreamFrame(frame);
}
@@ -2188,7 +2188,7 @@
session_->qpack_decoder()->OnInsertWithoutNameReference("foo", "bar");
// HEADERS frame referencing first dynamic table entry.
- std::string encoded_headers = quiche::QuicheTextUtils::HexDecode("020080");
+ std::string encoded_headers = absl::HexStringToBytes("020080");
std::string headers = HeadersFrame(encoded_headers);
EXPECT_CALL(debug_visitor,
OnHeadersFrameReceived(stream_->id(), encoded_headers.length()));
@@ -2222,7 +2222,7 @@
session_->qpack_decoder()->OnInsertWithoutNameReference("trailing", "foobar");
// Trailing HEADERS frame referencing second dynamic table entry.
- std::string encoded_trailers = quiche::QuicheTextUtils::HexDecode("030080");
+ std::string encoded_trailers = absl::HexStringToBytes("030080");
std::string trailers = HeadersFrame(encoded_trailers);
EXPECT_CALL(debug_visitor,
OnHeadersFrameReceived(stream_->id(), encoded_trailers.length()));
@@ -2254,7 +2254,7 @@
session_->set_debug_visitor(&debug_visitor);
// HEADERS frame referencing first dynamic table entry.
- std::string encoded_headers = quiche::QuicheTextUtils::HexDecode("020080");
+ std::string encoded_headers = absl::HexStringToBytes("020080");
std::string headers = HeadersFrame(encoded_headers);
EXPECT_CALL(debug_visitor,
OnHeadersFrameReceived(stream_->id(), encoded_headers.length()));
@@ -2292,7 +2292,7 @@
EXPECT_EQ(kDataFramePayload, stream_->data());
// Trailing HEADERS frame referencing second dynamic table entry.
- std::string encoded_trailers = quiche::QuicheTextUtils::HexDecode("030080");
+ std::string encoded_trailers = absl::HexStringToBytes("030080");
std::string trailers = HeadersFrame(encoded_trailers);
EXPECT_CALL(debug_visitor,
OnHeadersFrameReceived(stream_->id(), encoded_trailers.length()));
@@ -2326,8 +2326,7 @@
// HEADERS frame only referencing entry with absolute index 0 but with
// Required Insert Count = 2, which is incorrect.
- std::string headers =
- HeadersFrame(quiche::QuicheTextUtils::HexDecode("030081"));
+ std::string headers = HeadersFrame(absl::HexStringToBytes("030081"));
stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, 0, headers));
// Even though entire header block is received and every referenced entry is
@@ -2359,8 +2358,7 @@
session_->qpack_decoder()->OnSetDynamicTableCapacity(1024);
// Relative index 2 is invalid because it is larger than or equal to the Base.
- std::string headers =
- HeadersFrame(quiche::QuicheTextUtils::HexDecode("020082"));
+ std::string headers = HeadersFrame(absl::HexStringToBytes("020082"));
stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, 0, headers));
// Decoding is blocked.
@@ -2388,8 +2386,7 @@
session_->qpack_decoder()->OnSetDynamicTableCapacity(1024);
// HEADERS frame referencing first dynamic table entry.
- std::string headers =
- HeadersFrame(quiche::QuicheTextUtils::HexDecode("020080"));
+ std::string headers = HeadersFrame(absl::HexStringToBytes("020080"));
stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, 0, headers));
// Decoding is blocked because dynamic table entry has not been received yet.
@@ -2422,8 +2419,7 @@
// Trailing HEADERS frame only referencing entry with absolute index 0 but
// with Required Insert Count = 2, which is incorrect.
- std::string trailers =
- HeadersFrame(quiche::QuicheTextUtils::HexDecode("030081"));
+ std::string trailers = HeadersFrame(absl::HexStringToBytes("030081"));
stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), true, /* offset = */
headers.length() + data.length(),
trailers));
@@ -2459,7 +2455,7 @@
session_->set_debug_visitor(&debug_visitor);
// HEADERS frame referencing first dynamic table entry.
- std::string encoded_headers = quiche::QuicheTextUtils::HexDecode("020080");
+ std::string encoded_headers = absl::HexStringToBytes("020080");
std::string headers = HeadersFrame(encoded_headers);
EXPECT_CALL(debug_visitor,
OnHeadersFrameReceived(stream_->id(), encoded_headers.length()));
@@ -2903,7 +2899,7 @@
Initialize(kShouldProcessData);
// SETTINGS frame with empty payload.
- std::string settings = quiche::QuicheTextUtils::HexDecode("0400");
+ std::string settings = absl::HexStringToBytes("0400");
// HEADERS frame.
// Since it arrives after a SETTINGS frame, it should never be read.
diff --git a/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc b/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
index eeb34eb..2a5b0da 100644
--- a/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
+++ b/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
@@ -6,6 +6,7 @@
#include <cstring>
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/qpack/qpack_decoder.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
@@ -84,7 +85,7 @@
// HEADERS frame payload must have a complete Header Block Prefix.
TEST_F(QpackDecodedHeadersAccumulatorTest, TruncatedHeaderBlockPrefix) {
- accumulator_.Decode(quiche::QuicheTextUtils::HexDecode("00"));
+ accumulator_.Decode(absl::HexStringToBytes("00"));
EXPECT_CALL(visitor_,
OnHeaderDecodingError(Eq("Incomplete header data prefix.")));
@@ -92,7 +93,7 @@
}
TEST_F(QpackDecodedHeadersAccumulatorTest, EmptyHeaderList) {
- std::string encoded_data(quiche::QuicheTextUtils::HexDecode("0000"));
+ std::string encoded_data(absl::HexStringToBytes("0000"));
accumulator_.Decode(encoded_data);
QuicHeaderList header_list;
@@ -108,7 +109,7 @@
// This payload is the prefix of a valid payload, but EndHeaderBlock() is called
// before it can be completely decoded.
TEST_F(QpackDecodedHeadersAccumulatorTest, TruncatedPayload) {
- accumulator_.Decode(quiche::QuicheTextUtils::HexDecode("00002366"));
+ accumulator_.Decode(absl::HexStringToBytes("00002366"));
EXPECT_CALL(visitor_, OnHeaderDecodingError(Eq("Incomplete header block.")));
accumulator_.EndHeaderBlock();
@@ -118,12 +119,11 @@
TEST_F(QpackDecodedHeadersAccumulatorTest, InvalidPayload) {
EXPECT_CALL(visitor_,
OnHeaderDecodingError(Eq("Static table entry not found.")));
- accumulator_.Decode(quiche::QuicheTextUtils::HexDecode("0000ff23ff24"));
+ accumulator_.Decode(absl::HexStringToBytes("0000ff23ff24"));
}
TEST_F(QpackDecodedHeadersAccumulatorTest, Success) {
- std::string encoded_data(
- quiche::QuicheTextUtils::HexDecode("000023666f6f03626172"));
+ std::string encoded_data(absl::HexStringToBytes("000023666f6f03626172"));
accumulator_.Decode(encoded_data);
QuicHeaderList header_list;
@@ -141,7 +141,7 @@
// otherwise decoding could fail with "incomplete header block" error.
TEST_F(QpackDecodedHeadersAccumulatorTest, ExceedLimitThenSplitInstruction) {
// Total length of header list exceeds kMaxHeaderListSize.
- accumulator_.Decode(quiche::QuicheTextUtils::HexDecode(
+ accumulator_.Decode(absl::HexStringToBytes(
"0000" // header block prefix
"26666f6f626172" // header key: "foobar"
"7d61616161616161616161616161616161616161" // header value: 'a' 125 times
@@ -149,7 +149,7 @@
"616161616161616161616161616161616161616161616161616161616161616161616161"
"61616161616161616161616161616161616161616161616161616161616161616161"
"ff")); // first byte of a two-byte long Indexed Header Field instruction
- accumulator_.Decode(quiche::QuicheTextUtils::HexDecode(
+ accumulator_.Decode(absl::HexStringToBytes(
"0f" // second byte of a two-byte long Indexed Header Field instruction
));
@@ -160,7 +160,7 @@
// Test that header list limit enforcement works with blocked encoding.
TEST_F(QpackDecodedHeadersAccumulatorTest, ExceedLimitBlocked) {
// Total length of header list exceeds kMaxHeaderListSize.
- accumulator_.Decode(quiche::QuicheTextUtils::HexDecode(
+ accumulator_.Decode(absl::HexStringToBytes(
"0200" // header block prefix
"80" // reference to dynamic table entry not yet received
"26666f6f626172" // header key: "foobar"
@@ -182,7 +182,7 @@
TEST_F(QpackDecodedHeadersAccumulatorTest, BlockedDecoding) {
// Reference to dynamic table entry not yet received.
- std::string encoded_data(quiche::QuicheTextUtils::HexDecode("020080"));
+ std::string encoded_data(absl::HexStringToBytes("020080"));
accumulator_.Decode(encoded_data);
accumulator_.EndHeaderBlock();
@@ -206,7 +206,7 @@
TEST_F(QpackDecodedHeadersAccumulatorTest,
BlockedDecodingUnblockedBeforeEndOfHeaderBlock) {
// Reference to dynamic table entry not yet received.
- accumulator_.Decode(quiche::QuicheTextUtils::HexDecode("020080"));
+ accumulator_.Decode(absl::HexStringToBytes("020080"));
// Set dynamic table capacity.
qpack_decoder_.OnSetDynamicTableCapacity(kMaxDynamicTableCapacity);
@@ -216,7 +216,7 @@
// Rest of header block: same entry again.
EXPECT_CALL(decoder_stream_sender_delegate_,
WriteStreamData(Eq(kHeaderAcknowledgement)));
- accumulator_.Decode(quiche::QuicheTextUtils::HexDecode("80"));
+ accumulator_.Decode(absl::HexStringToBytes("80"));
QuicHeaderList header_list;
EXPECT_CALL(visitor_, OnHeadersDecoded(_, false))
@@ -231,12 +231,12 @@
BlockedDecodingUnblockedAndErrorBeforeEndOfHeaderBlock) {
// Required Insert Count higher than number of entries causes decoding to be
// blocked.
- accumulator_.Decode(quiche::QuicheTextUtils::HexDecode("0200"));
+ accumulator_.Decode(absl::HexStringToBytes("0200"));
// Indexed Header Field instruction addressing dynamic table entry with
// relative index 0, absolute index 0.
- accumulator_.Decode(quiche::QuicheTextUtils::HexDecode("80"));
+ accumulator_.Decode(absl::HexStringToBytes("80"));
// Relative index larger than or equal to Base is invalid.
- accumulator_.Decode(quiche::QuicheTextUtils::HexDecode("81"));
+ accumulator_.Decode(absl::HexStringToBytes("81"));
// Set dynamic table capacity.
qpack_decoder_.OnSetDynamicTableCapacity(kMaxDynamicTableCapacity);
diff --git a/quic/core/qpack/qpack_decoder_stream_receiver_test.cc b/quic/core/qpack/qpack_decoder_stream_receiver_test.cc
index af8af8c..fd79595 100644
--- a/quic/core/qpack/qpack_decoder_stream_receiver_test.cc
+++ b/quic/core/qpack/qpack_decoder_stream_receiver_test.cc
@@ -4,6 +4,7 @@
#include "net/third_party/quiche/src/quic/core/qpack/qpack_decoder_stream_receiver.h"
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
@@ -42,59 +43,59 @@
TEST_F(QpackDecoderStreamReceiverTest, InsertCountIncrement) {
EXPECT_CALL(delegate_, OnInsertCountIncrement(0));
- stream_.Decode(quiche::QuicheTextUtils::HexDecode("00"));
+ stream_.Decode(absl::HexStringToBytes("00"));
EXPECT_CALL(delegate_, OnInsertCountIncrement(10));
- stream_.Decode(quiche::QuicheTextUtils::HexDecode("0a"));
+ stream_.Decode(absl::HexStringToBytes("0a"));
EXPECT_CALL(delegate_, OnInsertCountIncrement(63));
- stream_.Decode(quiche::QuicheTextUtils::HexDecode("3f00"));
+ stream_.Decode(absl::HexStringToBytes("3f00"));
EXPECT_CALL(delegate_, OnInsertCountIncrement(200));
- stream_.Decode(quiche::QuicheTextUtils::HexDecode("3f8901"));
+ stream_.Decode(absl::HexStringToBytes("3f8901"));
EXPECT_CALL(delegate_,
OnErrorDetected(QUIC_QPACK_DECODER_STREAM_INTEGER_TOO_LARGE,
Eq("Encoded integer too large.")));
- stream_.Decode(quiche::QuicheTextUtils::HexDecode("3fffffffffffffffffffff"));
+ stream_.Decode(absl::HexStringToBytes("3fffffffffffffffffffff"));
}
TEST_F(QpackDecoderStreamReceiverTest, HeaderAcknowledgement) {
EXPECT_CALL(delegate_, OnHeaderAcknowledgement(0));
- stream_.Decode(quiche::QuicheTextUtils::HexDecode("80"));
+ stream_.Decode(absl::HexStringToBytes("80"));
EXPECT_CALL(delegate_, OnHeaderAcknowledgement(37));
- stream_.Decode(quiche::QuicheTextUtils::HexDecode("a5"));
+ stream_.Decode(absl::HexStringToBytes("a5"));
EXPECT_CALL(delegate_, OnHeaderAcknowledgement(127));
- stream_.Decode(quiche::QuicheTextUtils::HexDecode("ff00"));
+ stream_.Decode(absl::HexStringToBytes("ff00"));
EXPECT_CALL(delegate_, OnHeaderAcknowledgement(503));
- stream_.Decode(quiche::QuicheTextUtils::HexDecode("fff802"));
+ stream_.Decode(absl::HexStringToBytes("fff802"));
EXPECT_CALL(delegate_,
OnErrorDetected(QUIC_QPACK_DECODER_STREAM_INTEGER_TOO_LARGE,
Eq("Encoded integer too large.")));
- stream_.Decode(quiche::QuicheTextUtils::HexDecode("ffffffffffffffffffffff"));
+ stream_.Decode(absl::HexStringToBytes("ffffffffffffffffffffff"));
}
TEST_F(QpackDecoderStreamReceiverTest, StreamCancellation) {
EXPECT_CALL(delegate_, OnStreamCancellation(0));
- stream_.Decode(quiche::QuicheTextUtils::HexDecode("40"));
+ stream_.Decode(absl::HexStringToBytes("40"));
EXPECT_CALL(delegate_, OnStreamCancellation(19));
- stream_.Decode(quiche::QuicheTextUtils::HexDecode("53"));
+ stream_.Decode(absl::HexStringToBytes("53"));
EXPECT_CALL(delegate_, OnStreamCancellation(63));
- stream_.Decode(quiche::QuicheTextUtils::HexDecode("7f00"));
+ stream_.Decode(absl::HexStringToBytes("7f00"));
EXPECT_CALL(delegate_, OnStreamCancellation(110));
- stream_.Decode(quiche::QuicheTextUtils::HexDecode("7f2f"));
+ stream_.Decode(absl::HexStringToBytes("7f2f"));
EXPECT_CALL(delegate_,
OnErrorDetected(QUIC_QPACK_DECODER_STREAM_INTEGER_TOO_LARGE,
Eq("Encoded integer too large.")));
- stream_.Decode(quiche::QuicheTextUtils::HexDecode("7fffffffffffffffffffff"));
+ stream_.Decode(absl::HexStringToBytes("7fffffffffffffffffffff"));
}
} // namespace
diff --git a/quic/core/qpack/qpack_decoder_stream_sender_test.cc b/quic/core/qpack/qpack_decoder_stream_sender_test.cc
index 1d18fa9..c412c9f 100644
--- a/quic/core/qpack/qpack_decoder_stream_sender_test.cc
+++ b/quic/core/qpack/qpack_decoder_stream_sender_test.cc
@@ -4,6 +4,7 @@
#include "net/third_party/quiche/src/quic/core/qpack/qpack_decoder_stream_sender.h"
+#include "absl/strings/escaping.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
@@ -27,67 +28,55 @@
};
TEST_F(QpackDecoderStreamSenderTest, InsertCountIncrement) {
- EXPECT_CALL(delegate_,
- WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("00"))));
+ EXPECT_CALL(delegate_, WriteStreamData(Eq(absl::HexStringToBytes("00"))));
stream_.SendInsertCountIncrement(0);
stream_.Flush();
- EXPECT_CALL(delegate_,
- WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("0a"))));
+ EXPECT_CALL(delegate_, WriteStreamData(Eq(absl::HexStringToBytes("0a"))));
stream_.SendInsertCountIncrement(10);
stream_.Flush();
- EXPECT_CALL(delegate_,
- WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("3f00"))));
+ EXPECT_CALL(delegate_, WriteStreamData(Eq(absl::HexStringToBytes("3f00"))));
stream_.SendInsertCountIncrement(63);
stream_.Flush();
- EXPECT_CALL(delegate_, WriteStreamData(
- Eq(quiche::QuicheTextUtils::HexDecode("3f8901"))));
+ EXPECT_CALL(delegate_, WriteStreamData(Eq(absl::HexStringToBytes("3f8901"))));
stream_.SendInsertCountIncrement(200);
stream_.Flush();
}
TEST_F(QpackDecoderStreamSenderTest, HeaderAcknowledgement) {
- EXPECT_CALL(delegate_,
- WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("80"))));
+ EXPECT_CALL(delegate_, WriteStreamData(Eq(absl::HexStringToBytes("80"))));
stream_.SendHeaderAcknowledgement(0);
stream_.Flush();
- EXPECT_CALL(delegate_,
- WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("a5"))));
+ EXPECT_CALL(delegate_, WriteStreamData(Eq(absl::HexStringToBytes("a5"))));
stream_.SendHeaderAcknowledgement(37);
stream_.Flush();
- EXPECT_CALL(delegate_,
- WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("ff00"))));
+ EXPECT_CALL(delegate_, WriteStreamData(Eq(absl::HexStringToBytes("ff00"))));
stream_.SendHeaderAcknowledgement(127);
stream_.Flush();
- EXPECT_CALL(delegate_, WriteStreamData(
- Eq(quiche::QuicheTextUtils::HexDecode("fff802"))));
+ EXPECT_CALL(delegate_, WriteStreamData(Eq(absl::HexStringToBytes("fff802"))));
stream_.SendHeaderAcknowledgement(503);
stream_.Flush();
}
TEST_F(QpackDecoderStreamSenderTest, StreamCancellation) {
- EXPECT_CALL(delegate_,
- WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("40"))));
+ EXPECT_CALL(delegate_, WriteStreamData(Eq(absl::HexStringToBytes("40"))));
stream_.SendStreamCancellation(0);
stream_.Flush();
- EXPECT_CALL(delegate_,
- WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("53"))));
+ EXPECT_CALL(delegate_, WriteStreamData(Eq(absl::HexStringToBytes("53"))));
stream_.SendStreamCancellation(19);
stream_.Flush();
- EXPECT_CALL(delegate_,
- WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("7f00"))));
+ EXPECT_CALL(delegate_, WriteStreamData(Eq(absl::HexStringToBytes("7f00"))));
stream_.SendStreamCancellation(63);
stream_.Flush();
- EXPECT_CALL(delegate_,
- WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("7f2f"))));
+ EXPECT_CALL(delegate_, WriteStreamData(Eq(absl::HexStringToBytes("7f2f"))));
stream_.SendStreamCancellation(110);
stream_.Flush();
}
@@ -97,16 +86,14 @@
stream_.SendHeaderAcknowledgement(37);
stream_.SendStreamCancellation(0);
- EXPECT_CALL(delegate_, WriteStreamData(
- Eq(quiche::QuicheTextUtils::HexDecode("0aa540"))));
+ EXPECT_CALL(delegate_, WriteStreamData(Eq(absl::HexStringToBytes("0aa540"))));
stream_.Flush();
stream_.SendInsertCountIncrement(63);
stream_.SendStreamCancellation(110);
- EXPECT_CALL(
- delegate_,
- WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("3f007f2f"))));
+ EXPECT_CALL(delegate_,
+ WriteStreamData(Eq(absl::HexStringToBytes("3f007f2f"))));
stream_.Flush();
}
diff --git a/quic/core/qpack/qpack_decoder_test.cc b/quic/core/qpack/qpack_decoder_test.cc
index 988ba8f..cf7c9d3 100644
--- a/quic/core/qpack/qpack_decoder_test.cc
+++ b/quic/core/qpack/qpack_decoder_test.cc
@@ -6,6 +6,7 @@
#include <algorithm>
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.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"
@@ -117,7 +118,7 @@
OnDecodingErrorDetected(Eq("Incomplete header data prefix.")));
// Header Data Prefix is at least two bytes long.
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("00"));
+ DecodeHeaderBlock(absl::HexStringToBytes("00"));
}
// Regression test for https://1025209: QpackProgressiveDecoder must not crash
@@ -129,42 +130,41 @@
OnDecodingErrorDetected(Eq("Encoded integer too large.")));
// Encoded Required Insert Count in Header Data Prefix is too large.
- DecodeData(
- quiche::QuicheTextUtils::HexDecode("ffffffffffffffffffffffffffff"));
+ DecodeData(absl::HexStringToBytes("ffffffffffffffffffffffffffff"));
}
TEST_P(QpackDecoderTest, EmptyHeaderBlock) {
EXPECT_CALL(handler_, OnDecodingCompleted());
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("0000"));
+ DecodeHeaderBlock(absl::HexStringToBytes("0000"));
}
TEST_P(QpackDecoderTest, LiteralEntryEmptyName) {
EXPECT_CALL(handler_, OnHeaderDecoded(Eq(""), Eq("foo")));
EXPECT_CALL(handler_, OnDecodingCompleted());
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("00002003666f6f"));
+ DecodeHeaderBlock(absl::HexStringToBytes("00002003666f6f"));
}
TEST_P(QpackDecoderTest, LiteralEntryEmptyValue) {
EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("")));
EXPECT_CALL(handler_, OnDecodingCompleted());
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("000023666f6f00"));
+ DecodeHeaderBlock(absl::HexStringToBytes("000023666f6f00"));
}
TEST_P(QpackDecoderTest, LiteralEntryEmptyNameAndValue) {
EXPECT_CALL(handler_, OnHeaderDecoded(Eq(""), Eq("")));
EXPECT_CALL(handler_, OnDecodingCompleted());
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("00002000"));
+ DecodeHeaderBlock(absl::HexStringToBytes("00002000"));
}
TEST_P(QpackDecoderTest, SimpleLiteralEntry) {
EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("bar")));
EXPECT_CALL(handler_, OnDecodingCompleted());
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("000023666f6f03626172"));
+ DecodeHeaderBlock(absl::HexStringToBytes("000023666f6f03626172"));
}
TEST_P(QpackDecoderTest, MultipleLiteralEntries) {
@@ -173,7 +173,7 @@
EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foobaar"), absl::string_view(str)));
EXPECT_CALL(handler_, OnDecodingCompleted());
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0000" // prefix
"23666f6f03626172" // foo: bar
"2700666f6f62616172" // 7 octet long header name, the smallest number
@@ -191,8 +191,7 @@
EXPECT_CALL(handler_,
OnDecodingErrorDetected(Eq("Encoded integer too large.")));
- DecodeHeaderBlock(
- quiche::QuicheTextUtils::HexDecode("000027ffffffffffffffffffff"));
+ DecodeHeaderBlock(absl::HexStringToBytes("000027ffffffffffffffffffff"));
}
// Name Length value can be decoded by varint decoder but exceeds 1 MB limit.
@@ -200,7 +199,7 @@
EXPECT_CALL(handler_,
OnDecodingErrorDetected(Eq("String literal too long.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("000027ffff7f"));
+ DecodeHeaderBlock(absl::HexStringToBytes("000027ffff7f"));
}
// Value Length value is too large for varint decoder to decode.
@@ -209,7 +208,7 @@
OnDecodingErrorDetected(Eq("Encoded integer too large.")));
DecodeHeaderBlock(
- quiche::QuicheTextUtils::HexDecode("000023666f6f7fffffffffffffffffffff"));
+ absl::HexStringToBytes("000023666f6f7fffffffffffffffffffff"));
}
// Value Length value can be decoded by varint decoder but exceeds 1 MB limit.
@@ -217,22 +216,22 @@
EXPECT_CALL(handler_,
OnDecodingErrorDetected(Eq("String literal too long.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("000023666f6f7fffff7f"));
+ DecodeHeaderBlock(absl::HexStringToBytes("000023666f6f7fffff7f"));
}
TEST_P(QpackDecoderTest, IncompleteHeaderBlock) {
EXPECT_CALL(handler_,
OnDecodingErrorDetected(Eq("Incomplete header block.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("00002366"));
+ DecodeHeaderBlock(absl::HexStringToBytes("00002366"));
}
TEST_P(QpackDecoderTest, HuffmanSimple) {
EXPECT_CALL(handler_, OnHeaderDecoded(Eq("custom-key"), Eq("custom-value")));
EXPECT_CALL(handler_, OnDecodingCompleted());
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
- "00002f0125a849e95ba97d7f8925a849e95bb8e8b4bf"));
+ DecodeHeaderBlock(
+ absl::HexStringToBytes("00002f0125a849e95ba97d7f8925a849e95bb8e8b4bf"));
}
TEST_P(QpackDecoderTest, AlternatingHuffmanNonHuffman) {
@@ -240,7 +239,7 @@
.Times(4);
EXPECT_CALL(handler_, OnDecodingCompleted());
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0000" // Prefix.
"2f0125a849e95ba97d7f" // Huffman-encoded name.
"8925a849e95bb8e8b4bf" // Huffman-encoded value.
@@ -258,8 +257,8 @@
// 'y' ends in 0b0 on the most significant bit of the last byte.
// The remaining 7 bits must be a prefix of EOS, which is all 1s.
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
- "00002f0125a849e95ba97d7e8925a849e95bb8e8b4bf"));
+ DecodeHeaderBlock(
+ absl::HexStringToBytes("00002f0125a849e95ba97d7e8925a849e95bb8e8b4bf"));
}
TEST_P(QpackDecoderTest, HuffmanValueDoesNotHaveEOSPrefix) {
@@ -268,8 +267,8 @@
// 'e' ends in 0b101, taking up the 3 most significant bits of the last byte.
// The remaining 5 bits must be a prefix of EOS, which is all 1s.
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
- "00002f0125a849e95ba97d7f8925a849e95bb8e8b4be"));
+ DecodeHeaderBlock(
+ absl::HexStringToBytes("00002f0125a849e95ba97d7f8925a849e95bb8e8b4be"));
}
TEST_P(QpackDecoderTest, HuffmanNameEOSPrefixTooLong) {
@@ -279,8 +278,8 @@
// The trailing EOS prefix must be at most 7 bits long. Appending one octet
// with value 0xff is invalid, even though 0b111111111111111 (15 bits) is a
// prefix of EOS.
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
- "00002f0225a849e95ba97d7fff8925a849e95bb8e8b4bf"));
+ DecodeHeaderBlock(
+ absl::HexStringToBytes("00002f0225a849e95ba97d7fff8925a849e95bb8e8b4bf"));
}
TEST_P(QpackDecoderTest, HuffmanValueEOSPrefixTooLong) {
@@ -290,8 +289,8 @@
// The trailing EOS prefix must be at most 7 bits long. Appending one octet
// with value 0xff is invalid, even though 0b1111111111111 (13 bits) is a
// prefix of EOS.
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
- "00002f0125a849e95ba97d7f8a25a849e95bb8e8b4bfff"));
+ DecodeHeaderBlock(
+ absl::HexStringToBytes("00002f0125a849e95ba97d7f8a25a849e95bb8e8b4bfff"));
}
TEST_P(QpackDecoderTest, StaticTable) {
@@ -312,7 +311,7 @@
EXPECT_CALL(handler_, OnDecodingCompleted());
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0000d1dfccd45f108621e9aec2a11f5c8294e75f000554524143455f1000"));
}
@@ -325,11 +324,11 @@
EXPECT_CALL(handler_,
OnDecodingErrorDetected(Eq("Static table entry not found.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("0000ff23ff24"));
+ DecodeHeaderBlock(absl::HexStringToBytes("0000ff23ff24"));
}
TEST_P(QpackDecoderTest, DynamicTable) {
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode(
+ DecodeEncoderStreamData(absl::HexStringToBytes(
"3fe107" // Set dynamic table capacity to 1024.
"6294e703626172" // Add literal entry with name "foo" and value "bar".
"80035a5a5a" // Add entry with name of dynamic table entry index 0
@@ -358,7 +357,7 @@
.InSequence(s);
EXPECT_CALL(handler_, OnDecodingCompleted()).InSequence(s);
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0500" // Required Insert Count 4 and Delta Base 0.
// Base is 4 + 0 = 4.
"83" // Dynamic table entry with relative index 3, absolute index 0.
@@ -379,7 +378,7 @@
.InSequence(s);
EXPECT_CALL(handler_, OnDecodingCompleted()).InSequence(s);
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0502" // Required Insert Count 4 and Delta Base 2.
// Base is 4 + 2 = 6.
"85" // Dynamic table entry with relative index 5, absolute index 0.
@@ -400,7 +399,7 @@
.InSequence(s);
EXPECT_CALL(handler_, OnDecodingCompleted()).InSequence(s);
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0582" // Required Insert Count 4 and Delta Base 2 with sign bit set.
// Base is 4 - 2 - 1 = 1.
"80" // Dynamic table entry with relative index 0, absolute index 0.
@@ -413,28 +412,28 @@
TEST_P(QpackDecoderTest, DecreasingDynamicTableCapacityEvictsEntries) {
// Set dynamic table capacity to 1024.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3fe107"));
// Add literal entry with name "foo" and value "bar".
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("6294e703626172"));
EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("bar")));
EXPECT_CALL(handler_, OnDecodingCompleted());
EXPECT_CALL(decoder_stream_sender_delegate_,
WriteStreamData(Eq(kHeaderAcknowledgement)));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0200" // Required Insert Count 1 and Delta Base 0.
// Base is 1 + 0 = 1.
"80")); // Dynamic table entry with relative index 0, absolute index 0.
// Change dynamic table capacity to 32 bytes, smaller than the entry.
// This must cause the entry to be evicted.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3f01"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3f01"));
EXPECT_CALL(handler_, OnDecodingErrorDetected(
Eq("Dynamic table entry already evicted.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0200" // Required Insert Count 1 and Delta Base 0.
// Base is 1 + 0 = 1.
"80")); // Dynamic table entry with relative index 0, absolute index 0.
@@ -449,9 +448,9 @@
Eq("Error inserting literal entry.")));
// Set dynamic table capacity to 34.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3f03"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3f03"));
// Add literal entry with name "foo" and value "bar", size is 32 + 3 + 3 = 38.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("6294e703626172"));
}
TEST_P(QpackDecoderTest, EncoderStreamErrorInvalidStaticTableEntry) {
@@ -463,7 +462,7 @@
Eq("Invalid static table entry.")));
// Address invalid static table entry index 99.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("ff2400"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("ff2400"));
}
TEST_P(QpackDecoderTest, EncoderStreamErrorInvalidDynamicTableEntry) {
@@ -475,7 +474,7 @@
: QUIC_QPACK_ENCODER_STREAM_ERROR,
Eq("Invalid relative index.")));
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode(
+ DecodeEncoderStreamData(absl::HexStringToBytes(
"3fe107" // Set dynamic table capacity to 1024.
"6294e703626172" // Add literal entry with name "foo" and value "bar".
"8100")); // Address dynamic table entry with relative index 1. Such
@@ -492,7 +491,7 @@
: QUIC_QPACK_ENCODER_STREAM_ERROR,
Eq("Invalid relative index.")));
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode(
+ DecodeEncoderStreamData(absl::HexStringToBytes(
"3fe107" // Set dynamic table capacity to 1024.
"6294e703626172" // Add literal entry with name "foo" and value "bar".
"01")); // Duplicate dynamic table entry with relative index 1. Such
@@ -508,19 +507,18 @@
: QUIC_QPACK_ENCODER_STREAM_ERROR,
Eq("Encoded integer too large.")));
- DecodeEncoderStreamData(
- quiche::QuicheTextUtils::HexDecode("3fffffffffffffffffffff"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3fffffffffffffffffffff"));
}
TEST_P(QpackDecoderTest, InvalidDynamicEntryWhenBaseIsZero) {
EXPECT_CALL(handler_, OnDecodingErrorDetected(Eq("Invalid relative index.")));
// Set dynamic table capacity to 1024.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3fe107"));
// Add literal entry with name "foo" and value "bar".
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("6294e703626172"));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0280" // Required Insert Count is 1. Base 1 - 1 - 0 = 0 is explicitly
// permitted by the spec.
"80")); // However, addressing entry with relative index 0 would point to
@@ -532,18 +530,18 @@
// Required Insert Count 1, Delta Base 1 with sign bit set, Base would
// be 1 - 1 - 1 = -1, but it is not allowed to be negative.
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("0281"));
+ DecodeHeaderBlock(absl::HexStringToBytes("0281"));
}
TEST_P(QpackDecoderTest, InvalidDynamicEntryByRelativeIndex) {
// Set dynamic table capacity to 1024.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3fe107"));
// Add literal entry with name "foo" and value "bar".
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("6294e703626172"));
EXPECT_CALL(handler_, OnDecodingErrorDetected(Eq("Invalid relative index.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0200" // Required Insert Count 1 and Delta Base 0.
// Base is 1 + 0 = 1.
"81")); // Indexed Header Field instruction addressing relative index 1.
@@ -551,7 +549,7 @@
EXPECT_CALL(handler_, OnDecodingErrorDetected(Eq("Invalid relative index.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0200" // Required Insert Count 1 and Delta Base 0.
// Base is 1 + 0 = 1.
"4100")); // Literal Header Field with Name Reference instruction
@@ -561,18 +559,18 @@
TEST_P(QpackDecoderTest, EvictedDynamicTableEntry) {
// Update dynamic table capacity to 128.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3f61"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3f61"));
// Add literal entry with name "foo" and value "bar", size 32 + 3 + 3 = 38.
// This fits in the table three times.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("6294e703626172"));
// Duplicate entry four times. This evicts the first two instances.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("00000000"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("00000000"));
EXPECT_CALL(handler_, OnDecodingErrorDetected(
Eq("Dynamic table entry already evicted.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0500" // Required Insert Count 4 and Delta Base 0.
// Base is 4 + 0 = 4.
"82")); // Indexed Header Field instruction addressing relative index 2.
@@ -581,7 +579,7 @@
EXPECT_CALL(handler_, OnDecodingErrorDetected(
Eq("Dynamic table entry already evicted.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0500" // Required Insert Count 4 and Delta Base 0.
// Base is 4 + 0 = 4.
"4200")); // Literal Header Field with Name Reference instruction
@@ -591,7 +589,7 @@
EXPECT_CALL(handler_, OnDecodingErrorDetected(
Eq("Dynamic table entry already evicted.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0380" // Required Insert Count 2 and Delta Base 0 with sign bit set.
// Base is 2 - 0 - 1 = 1
"10")); // Indexed Header Field instruction addressing dynamic table
@@ -601,7 +599,7 @@
EXPECT_CALL(handler_, OnDecodingErrorDetected(
Eq("Dynamic table entry already evicted.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0380" // Required Insert Count 2 and Delta Base 0 with sign bit set.
// Base is 2 - 0 - 1 = 1
"0000")); // Literal Header Field With Name Reference instruction
@@ -618,12 +616,12 @@
Eq("Error updating dynamic table capacity.")));
// Try to update dynamic table capacity to 2048, which exceeds the maximum.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe10f"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3fe10f"));
}
TEST_P(QpackDecoderTest, SetDynamicTableCapacity) {
// Update dynamic table capacity to 128, which does not exceed the maximum.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3f61"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3f61"));
}
TEST_P(QpackDecoderTest, InvalidEncodedRequiredInsertCount) {
@@ -633,7 +631,7 @@
// A value of 1 cannot be encoded as 65 even though it has the same remainder.
EXPECT_CALL(handler_, OnDecodingErrorDetected(
Eq("Error decoding Required Insert Count.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("4100"));
+ DecodeHeaderBlock(absl::HexStringToBytes("4100"));
}
// Regression test for https://crbug.com/970218: Decoder must stop processing
@@ -642,7 +640,7 @@
EXPECT_CALL(handler_, OnDecodingErrorDetected(
Eq("Error decoding Required Insert Count.")));
// Header Block Prefix followed by some extra data.
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("410000"));
+ DecodeHeaderBlock(absl::HexStringToBytes("410000"));
}
TEST_P(QpackDecoderTest, WrappedRequiredInsertCount) {
@@ -650,12 +648,12 @@
// MaxEntries is 1024 / 32 = 32.
// Set dynamic table capacity to 1024.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3fe107"));
// Add literal entry with name "foo" and a 600 byte long value. This will fit
// in the dynamic table once but not twice.
DecodeEncoderStreamData(
- quiche::QuicheTextUtils::HexDecode("6294e7" // Name "foo".
- "7fd903")); // Value length 600.
+ absl::HexStringToBytes("6294e7" // Name "foo".
+ "7fd903")); // Value length 600.
std::string header_value(600, 'Z');
DecodeEncoderStreamData(header_value);
@@ -670,7 +668,7 @@
WriteStreamData(Eq(kHeaderAcknowledgement)));
// Send header block with Required Insert Count = 201.
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0a00" // Encoded Required Insert Count 10, Required Insert Count 201,
// Delta Base 0, Base 201.
"80")); // Emit dynamic table entry with relative index 0.
@@ -678,31 +676,31 @@
TEST_P(QpackDecoderTest, NonZeroRequiredInsertCountButNoDynamicEntries) {
// Set dynamic table capacity to 1024.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3fe107"));
// Add literal entry with name "foo" and value "bar".
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("6294e703626172"));
EXPECT_CALL(handler_, OnHeaderDecoded(Eq(":method"), Eq("GET")));
EXPECT_CALL(handler_,
OnDecodingErrorDetected(Eq("Required Insert Count too large.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0200" // Required Insert Count is 1.
"d1")); // But the only instruction references the static table.
}
TEST_P(QpackDecoderTest, AddressEntryNotAllowedByRequiredInsertCount) {
// Set dynamic table capacity to 1024.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3fe107"));
// Add literal entry with name "foo" and value "bar".
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("6294e703626172"));
EXPECT_CALL(
handler_,
OnDecodingErrorDetected(
Eq("Absolute Index must be smaller than Required Insert Count.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0201" // Required Insert Count 1 and Delta Base 1.
// Base is 1 + 1 = 2.
"80")); // Indexed Header Field instruction addressing dynamic table
@@ -714,7 +712,7 @@
OnDecodingErrorDetected(
Eq("Absolute Index must be smaller than Required Insert Count.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0201" // Required Insert Count 1 and Delta Base 1.
// Base is 1 + 1 = 2.
"4000")); // Literal Header Field with Name Reference instruction
@@ -727,7 +725,7 @@
OnDecodingErrorDetected(
Eq("Absolute Index must be smaller than Required Insert Count.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0200" // Required Insert Count 1 and Delta Base 0.
// Base is 1 + 0 = 1.
"10")); // Indexed Header Field with Post-Base Index instruction
@@ -740,7 +738,7 @@
OnDecodingErrorDetected(
Eq("Absolute Index must be smaller than Required Insert Count.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0200" // Required Insert Count 1 and Delta Base 0.
// Base is 1 + 0 = 1.
"0000")); // Literal Header Field with Post-Base Name Reference
@@ -751,19 +749,19 @@
TEST_P(QpackDecoderTest, PromisedRequiredInsertCountLargerThanActual) {
// Set dynamic table capacity to 1024.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3fe107"));
// Add literal entry with name "foo" and value "bar".
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("6294e703626172"));
// Duplicate entry twice so that decoding of header blocks with Required
// Insert Count not exceeding 3 is not blocked.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("00"));
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("00"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("00"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("00"));
EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("bar")));
EXPECT_CALL(handler_,
OnDecodingErrorDetected(Eq("Required Insert Count too large.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0300" // Required Insert Count 2 and Delta Base 0.
// Base is 2 + 0 = 2.
"81")); // Indexed Header Field instruction addressing dynamic table
@@ -775,7 +773,7 @@
EXPECT_CALL(handler_,
OnDecodingErrorDetected(Eq("Required Insert Count too large.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0300" // Required Insert Count 2 and Delta Base 0.
// Base is 2 + 0 = 2.
"4100")); // Literal Header Field with Name Reference instruction
@@ -787,7 +785,7 @@
EXPECT_CALL(handler_,
OnDecodingErrorDetected(Eq("Required Insert Count too large.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0481" // Required Insert Count 3 and Delta Base 1 with sign bit set.
// Base is 3 - 1 - 1 = 1.
"10")); // Indexed Header Field with Post-Base Index instruction
@@ -799,7 +797,7 @@
EXPECT_CALL(handler_,
OnDecodingErrorDetected(Eq("Required Insert Count too large.")));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0481" // Required Insert Count 3 and Delta Base 1 with sign bit set.
// Base is 3 - 1 - 1 = 1.
"0000")); // Literal Header Field with Post-Base Name Reference
@@ -809,7 +807,7 @@
}
TEST_P(QpackDecoderTest, BlockedDecoding) {
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0200" // Required Insert Count 1 and Delta Base 0.
// Base is 1 + 0 = 1.
"80")); // Indexed Header Field instruction addressing dynamic table
@@ -821,14 +819,14 @@
WriteStreamData(Eq(kHeaderAcknowledgement)));
// Set dynamic table capacity to 1024.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3fe107"));
// Add literal entry with name "foo" and value "bar".
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("6294e703626172"));
}
TEST_P(QpackDecoderTest, BlockedDecodingUnblockedBeforeEndOfHeaderBlock) {
StartDecoding();
- DecodeData(quiche::QuicheTextUtils::HexDecode(
+ DecodeData(absl::HexStringToBytes(
"0200" // Required Insert Count 1 and Delta Base 0.
// Base is 1 + 0 = 1.
"80" // Indexed Header Field instruction addressing dynamic table
@@ -836,7 +834,7 @@
"d1")); // Static table entry with index 17.
// Set dynamic table capacity to 1024.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3fe107"));
// Add literal entry with name "foo" and value "bar". Decoding is now
// unblocked because dynamic table Insert Count reached the Required Insert
@@ -844,14 +842,14 @@
// the already consumed part of the header block.
EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("bar")));
EXPECT_CALL(handler_, OnHeaderDecoded(Eq(":method"), Eq("GET")));
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("6294e703626172"));
Mock::VerifyAndClearExpectations(&handler_);
// Rest of header block is processed by QpackProgressiveDecoder
// in the unblocked state.
EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("bar")));
EXPECT_CALL(handler_, OnHeaderDecoded(Eq(":scheme"), Eq("https")));
- DecodeData(quiche::QuicheTextUtils::HexDecode(
+ DecodeData(absl::HexStringToBytes(
"80" // Indexed Header Field instruction addressing dynamic table
// entry with relative index 0, absolute index 0.
"d7")); // Static table entry with index 23.
@@ -867,7 +865,7 @@
TEST_P(QpackDecoderTest,
BlockedDecodingUnblockedAndErrorBeforeEndOfHeaderBlock) {
StartDecoding();
- DecodeData(quiche::QuicheTextUtils::HexDecode(
+ DecodeData(absl::HexStringToBytes(
"0200" // Required Insert Count 1 and Delta Base 0.
// Base is 1 + 0 = 1.
"80" // Indexed Header Field instruction addressing dynamic table
@@ -875,7 +873,7 @@
"81")); // Relative index 1 is equal to Base, therefore invalid.
// Set dynamic table capacity to 1024.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3fe107"));
// Add literal entry with name "foo" and value "bar". Decoding is now
// unblocked because dynamic table Insert Count reached the Required Insert
@@ -883,7 +881,7 @@
// the already consumed part of the header block.
EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("bar")));
EXPECT_CALL(handler_, OnDecodingErrorDetected(Eq("Invalid relative index.")));
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("6294e703626172"));
}
// Make sure that Required Insert Count is compared to Insert Count,
@@ -891,19 +889,19 @@
TEST_P(QpackDecoderTest, BlockedDecodingAndEvictedEntries) {
// Update dynamic table capacity to 128.
// At most three non-empty entries fit in the dynamic table.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3f61"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("3f61"));
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0700" // Required Insert Count 6 and Delta Base 0.
// Base is 6 + 0 = 6.
"80")); // Indexed Header Field instruction addressing dynamic table
// entry with relative index 0, absolute index 5.
// Add literal entry with name "foo" and value "bar".
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("6294e703626172"));
// Duplicate entry four times. This evicts the first two instances.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("00000000"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("00000000"));
EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("baz")));
EXPECT_CALL(handler_, OnDecodingCompleted());
@@ -912,13 +910,13 @@
// Add literal entry with name "foo" and value "bar".
// Insert Count is now 6, reaching Required Insert Count of the header block.
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e70362617a"));
+ DecodeEncoderStreamData(absl::HexStringToBytes("6294e70362617a"));
}
TEST_P(QpackDecoderTest, TooManyBlockedStreams) {
// Required Insert Count 1 and Delta Base 0.
// Without any dynamic table entries received, decoding is blocked.
- std::string data = quiche::QuicheTextUtils::HexDecode("0200");
+ std::string data = absl::HexStringToBytes("0200");
auto progressive_decoder1 = CreateProgressiveDecoder(/* stream_id = */ 1);
progressive_decoder1->Decode(data);
@@ -931,7 +929,7 @@
}
TEST_P(QpackDecoderTest, InsertCountIncrement) {
- DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode(
+ DecodeEncoderStreamData(absl::HexStringToBytes(
"3fe107" // Set dynamic table capacity to 1024.
"6294e703626172" // Add literal entry with name "foo" and value "bar".
"00")); // Duplicate entry.
@@ -943,11 +941,11 @@
// Known Insert Count to one. Decoder should send an Insert Count Increment
// instruction with increment of one to update Known Insert Count to two.
EXPECT_CALL(decoder_stream_sender_delegate_,
- WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode(
+ WriteStreamData(Eq(absl::HexStringToBytes(
"81" // Header Acknowledgement on stream 1
"01")))); // Insert Count Increment with increment of one
- DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+ DecodeHeaderBlock(absl::HexStringToBytes(
"0200" // Required Insert Count 1 and Delta Base 0.
// Base is 1 + 0 = 1.
"80")); // Dynamic table entry with relative index 0, absolute index 0.
diff --git a/quic/core/qpack/qpack_encoder_stream_receiver_test.cc b/quic/core/qpack/qpack_encoder_stream_receiver_test.cc
index 235bd79..31bea89 100644
--- a/quic/core/qpack/qpack_encoder_stream_receiver_test.cc
+++ b/quic/core/qpack/qpack_encoder_stream_receiver_test.cc
@@ -4,6 +4,7 @@
#include "net/third_party/quiche/src/quic/core/qpack/qpack_encoder_stream_receiver.h"
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
@@ -60,7 +61,7 @@
EXPECT_CALL(*delegate(),
OnInsertWithNameReference(false, 42, Eq(std::string(127, 'Z'))));
- Decode(quiche::QuicheTextUtils::HexDecode(
+ Decode(absl::HexStringToBytes(
"c500"
"c28294e7"
"bf4a03626172"
@@ -75,7 +76,7 @@
OnErrorDetected(QUIC_QPACK_ENCODER_STREAM_INTEGER_TOO_LARGE,
Eq("Encoded integer too large.")));
- Decode(quiche::QuicheTextUtils::HexDecode("bfffffffffffffffffffffff"));
+ Decode(absl::HexStringToBytes("bfffffffffffffffffffffff"));
}
TEST_F(QpackEncoderStreamReceiverTest, InsertWithNameReferenceValueTooLong) {
@@ -83,7 +84,7 @@
OnErrorDetected(QUIC_QPACK_ENCODER_STREAM_INTEGER_TOO_LARGE,
Eq("Encoded integer too large.")));
- Decode(quiche::QuicheTextUtils::HexDecode("c57fffffffffffffffffffff"));
+ Decode(absl::HexStringToBytes("c57fffffffffffffffffffff"));
}
TEST_F(QpackEncoderStreamReceiverTest, InsertWithoutNameReference) {
@@ -99,7 +100,7 @@
OnInsertWithoutNameReference(Eq(std::string(31, 'Z')),
Eq(std::string(127, 'Z'))));
- Decode(quiche::QuicheTextUtils::HexDecode(
+ Decode(absl::HexStringToBytes(
"4000"
"4362617203626172"
"6294e78294e7"
@@ -117,7 +118,7 @@
OnErrorDetected(QUIC_QPACK_ENCODER_STREAM_INTEGER_TOO_LARGE,
Eq("Encoded integer too large.")));
- Decode(quiche::QuicheTextUtils::HexDecode("5fffffffffffffffffffff"));
+ Decode(absl::HexStringToBytes("5fffffffffffffffffffff"));
}
// Name Length value can be decoded by varint decoder but exceeds 1 MB limit.
@@ -127,7 +128,7 @@
OnErrorDetected(QUIC_QPACK_ENCODER_STREAM_STRING_LITERAL_TOO_LONG,
Eq("String literal too long.")));
- Decode(quiche::QuicheTextUtils::HexDecode("5fffff7f"));
+ Decode(absl::HexStringToBytes("5fffff7f"));
}
// Value Length value is too large for varint decoder to decode.
@@ -137,7 +138,7 @@
OnErrorDetected(QUIC_QPACK_ENCODER_STREAM_INTEGER_TOO_LARGE,
Eq("Encoded integer too large.")));
- Decode(quiche::QuicheTextUtils::HexDecode("436261727fffffffffffffffffffff"));
+ Decode(absl::HexStringToBytes("436261727fffffffffffffffffffff"));
}
// Value Length value can be decoded by varint decoder but exceeds 1 MB limit.
@@ -147,7 +148,7 @@
OnErrorDetected(QUIC_QPACK_ENCODER_STREAM_STRING_LITERAL_TOO_LONG,
Eq("String literal too long.")));
- Decode(quiche::QuicheTextUtils::HexDecode("436261727fffff7f"));
+ Decode(absl::HexStringToBytes("436261727fffff7f"));
}
TEST_F(QpackEncoderStreamReceiverTest, Duplicate) {
@@ -156,7 +157,7 @@
// Large index requires two extension bytes.
EXPECT_CALL(*delegate(), OnDuplicate(500));
- Decode(quiche::QuicheTextUtils::HexDecode("111fd503"));
+ Decode(absl::HexStringToBytes("111fd503"));
}
TEST_F(QpackEncoderStreamReceiverTest, DuplicateIndexTooLarge) {
@@ -164,7 +165,7 @@
OnErrorDetected(QUIC_QPACK_ENCODER_STREAM_INTEGER_TOO_LARGE,
Eq("Encoded integer too large.")));
- Decode(quiche::QuicheTextUtils::HexDecode("1fffffffffffffffffffff"));
+ Decode(absl::HexStringToBytes("1fffffffffffffffffffff"));
}
TEST_F(QpackEncoderStreamReceiverTest, SetDynamicTableCapacity) {
@@ -173,7 +174,7 @@
// Large capacity requires two extension bytes.
EXPECT_CALL(*delegate(), OnSetDynamicTableCapacity(500));
- Decode(quiche::QuicheTextUtils::HexDecode("313fd503"));
+ Decode(absl::HexStringToBytes("313fd503"));
}
TEST_F(QpackEncoderStreamReceiverTest, SetDynamicTableCapacityTooLarge) {
@@ -181,7 +182,7 @@
OnErrorDetected(QUIC_QPACK_ENCODER_STREAM_INTEGER_TOO_LARGE,
Eq("Encoded integer too large.")));
- Decode(quiche::QuicheTextUtils::HexDecode("3fffffffffffffffffffff"));
+ Decode(absl::HexStringToBytes("3fffffffffffffffffffff"));
}
TEST_F(QpackEncoderStreamReceiverTest, InvalidHuffmanEncoding) {
@@ -189,7 +190,7 @@
OnErrorDetected(QUIC_QPACK_ENCODER_STREAM_HUFFMAN_ENCODING_ERROR,
Eq("Error in Huffman-encoded string.")));
- Decode(quiche::QuicheTextUtils::HexDecode("c281ff"));
+ Decode(absl::HexStringToBytes("c281ff"));
}
} // namespace
diff --git a/quic/core/qpack/qpack_encoder_stream_sender_test.cc b/quic/core/qpack/qpack_encoder_stream_sender_test.cc
index ea45acc..0813819 100644
--- a/quic/core/qpack/qpack_encoder_stream_sender_test.cc
+++ b/quic/core/qpack/qpack_encoder_stream_sender_test.cc
@@ -4,6 +4,7 @@
#include "net/third_party/quiche/src/quic/core/qpack/qpack_encoder_stream_sender.h"
+#include "absl/strings/escaping.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
@@ -30,22 +31,21 @@
EXPECT_EQ(0u, stream_.BufferedByteCount());
// Static, index fits in prefix, empty value.
- std::string expected_encoded_data =
- quiche::QuicheTextUtils::HexDecode("c500");
+ std::string expected_encoded_data = absl::HexStringToBytes("c500");
EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
stream_.SendInsertWithNameReference(true, 5, "");
EXPECT_EQ(expected_encoded_data.size(), stream_.BufferedByteCount());
stream_.Flush();
// Static, index fits in prefix, Huffman encoded value.
- expected_encoded_data = quiche::QuicheTextUtils::HexDecode("c28294e7");
+ expected_encoded_data = absl::HexStringToBytes("c28294e7");
EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
stream_.SendInsertWithNameReference(true, 2, "foo");
EXPECT_EQ(expected_encoded_data.size(), stream_.BufferedByteCount());
stream_.Flush();
// Not static, index does not fit in prefix, not Huffman encoded value.
- expected_encoded_data = quiche::QuicheTextUtils::HexDecode("bf4a03626172");
+ expected_encoded_data = absl::HexStringToBytes("bf4a03626172");
EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
stream_.SendInsertWithNameReference(false, 137, "bar");
EXPECT_EQ(expected_encoded_data.size(), stream_.BufferedByteCount());
@@ -53,7 +53,7 @@
// Value length does not fit in prefix.
// 'Z' would be Huffman encoded to 8 bits, so no Huffman encoding is used.
- expected_encoded_data = quiche::QuicheTextUtils::HexDecode(
+ expected_encoded_data = absl::HexStringToBytes(
"aa7f005a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"
"5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"
"5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"
@@ -68,23 +68,21 @@
EXPECT_EQ(0u, stream_.BufferedByteCount());
// Empty name and value.
- std::string expected_encoded_data =
- quiche::QuicheTextUtils::HexDecode("4000");
+ std::string expected_encoded_data = absl::HexStringToBytes("4000");
EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
stream_.SendInsertWithoutNameReference("", "");
EXPECT_EQ(expected_encoded_data.size(), stream_.BufferedByteCount());
stream_.Flush();
// Huffman encoded short strings.
- expected_encoded_data = quiche::QuicheTextUtils::HexDecode("6294e78294e7");
+ expected_encoded_data = absl::HexStringToBytes("6294e78294e7");
EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
stream_.SendInsertWithoutNameReference("foo", "foo");
EXPECT_EQ(expected_encoded_data.size(), stream_.BufferedByteCount());
stream_.Flush();
// Not Huffman encoded short strings.
- expected_encoded_data =
- quiche::QuicheTextUtils::HexDecode("4362617203626172");
+ expected_encoded_data = absl::HexStringToBytes("4362617203626172");
EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
stream_.SendInsertWithoutNameReference("bar", "bar");
EXPECT_EQ(expected_encoded_data.size(), stream_.BufferedByteCount());
@@ -92,7 +90,7 @@
// Not Huffman encoded long strings; length does not fit on prefix.
// 'Z' would be Huffman encoded to 8 bits, so no Huffman encoding is used.
- expected_encoded_data = quiche::QuicheTextUtils::HexDecode(
+ expected_encoded_data = absl::HexStringToBytes(
"5f005a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a7f"
"005a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"
"5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"
@@ -109,14 +107,14 @@
EXPECT_EQ(0u, stream_.BufferedByteCount());
// Small index fits in prefix.
- std::string expected_encoded_data = quiche::QuicheTextUtils::HexDecode("11");
+ std::string expected_encoded_data = absl::HexStringToBytes("11");
EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
stream_.SendDuplicate(17);
EXPECT_EQ(expected_encoded_data.size(), stream_.BufferedByteCount());
stream_.Flush();
// Large index requires two extension bytes.
- expected_encoded_data = quiche::QuicheTextUtils::HexDecode("1fd503");
+ expected_encoded_data = absl::HexStringToBytes("1fd503");
EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
stream_.SendDuplicate(500);
EXPECT_EQ(expected_encoded_data.size(), stream_.BufferedByteCount());
@@ -127,7 +125,7 @@
EXPECT_EQ(0u, stream_.BufferedByteCount());
// Small capacity fits in prefix.
- std::string expected_encoded_data = quiche::QuicheTextUtils::HexDecode("31");
+ std::string expected_encoded_data = absl::HexStringToBytes("31");
EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
stream_.SendSetDynamicTableCapacity(17);
EXPECT_EQ(expected_encoded_data.size(), stream_.BufferedByteCount());
@@ -135,7 +133,7 @@
EXPECT_EQ(0u, stream_.BufferedByteCount());
// Large capacity requires two extension bytes.
- expected_encoded_data = quiche::QuicheTextUtils::HexDecode("3fd503");
+ expected_encoded_data = absl::HexStringToBytes("3fd503");
EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
stream_.SendSetDynamicTableCapacity(500);
EXPECT_EQ(expected_encoded_data.size(), stream_.BufferedByteCount());
@@ -157,7 +155,7 @@
// Duplicate entry.
stream_.SendDuplicate(17);
- std::string expected_encoded_data = quiche::QuicheTextUtils::HexDecode(
+ std::string expected_encoded_data = absl::HexStringToBytes(
"c500" // Insert entry with static name reference.
"c28294e7" // Insert entry with static name reference.
"6294e78294e7" // Insert literal entry.
diff --git a/quic/core/qpack/qpack_encoder_test.cc b/quic/core/qpack/qpack_encoder_test.cc
index 9bc377e..08c6123 100644
--- a/quic/core/qpack/qpack_encoder_test.cc
+++ b/quic/core/qpack/qpack_encoder_test.cc
@@ -7,6 +7,7 @@
#include <limits>
#include <string>
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.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"
@@ -51,7 +52,7 @@
spdy::Http2HeaderBlock header_list;
std::string output = Encode(header_list);
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("0000"), output);
+ EXPECT_EQ(absl::HexStringToBytes("0000"), output);
}
TEST_F(QpackEncoderTest, EmptyName) {
@@ -59,7 +60,7 @@
header_list[""] = "foo";
std::string output = Encode(header_list);
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("0000208294e7"), output);
+ EXPECT_EQ(absl::HexStringToBytes("0000208294e7"), output);
}
TEST_F(QpackEncoderTest, EmptyValue) {
@@ -67,7 +68,7 @@
header_list["foo"] = "";
std::string output = Encode(header_list);
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("00002a94e700"), output);
+ EXPECT_EQ(absl::HexStringToBytes("00002a94e700"), output);
}
TEST_F(QpackEncoderTest, EmptyNameAndValue) {
@@ -75,7 +76,7 @@
header_list[""] = "";
std::string output = Encode(header_list);
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("00002000"), output);
+ EXPECT_EQ(absl::HexStringToBytes("00002000"), output);
}
TEST_F(QpackEncoderTest, Simple) {
@@ -83,7 +84,7 @@
header_list["foo"] = "bar";
std::string output = Encode(header_list);
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("00002a94e703626172"), output);
+ EXPECT_EQ(absl::HexStringToBytes("00002a94e703626172"), output);
}
TEST_F(QpackEncoderTest, Multiple) {
@@ -94,7 +95,7 @@
std::string output = Encode(header_list);
EXPECT_EQ(
- quiche::QuicheTextUtils::HexDecode(
+ absl::HexStringToBytes(
"0000" // prefix
"2a94e703626172" // foo: bar
"27005a5a5a5a5a5a5a" // 7 octet long header name, the smallest number
@@ -116,7 +117,7 @@
header_list["location"] = "";
std::string output = Encode(header_list);
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("0000d1dfcc"), output);
+ EXPECT_EQ(absl::HexStringToBytes("0000d1dfcc"), output);
}
{
spdy::Http2HeaderBlock header_list;
@@ -125,9 +126,8 @@
header_list["location"] = "foo";
std::string output = Encode(header_list);
- EXPECT_EQ(
- quiche::QuicheTextUtils::HexDecode("0000d45f108621e9aec2a11f5c8294e7"),
- output);
+ EXPECT_EQ(absl::HexStringToBytes("0000d45f108621e9aec2a11f5c8294e7"),
+ output);
}
{
spdy::Http2HeaderBlock header_list;
@@ -135,8 +135,7 @@
header_list["accept-encoding"] = "";
std::string output = Encode(header_list);
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("00005f000554524143455f1000"),
- output);
+ EXPECT_EQ(absl::HexStringToBytes("00005f000554524143455f1000"), output);
}
}
@@ -151,7 +150,7 @@
QpackEncoder encoder(&decoder_stream_error_delegate_);
encoder.set_qpack_stream_sender_delegate(&encoder_stream_sender_delegate_);
encoder.decoder_stream_receiver()->Decode(
- quiche::QuicheTextUtils::HexDecode("ffffffffffffffffffffff"));
+ absl::HexStringToBytes("ffffffffffffffffffffff"));
}
TEST_F(QpackEncoderTest, SplitAlongNullCharacter) {
@@ -159,11 +158,11 @@
header_list["foo"] = absl::string_view("bar\0bar\0baz", 11);
std::string output = Encode(header_list);
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("0000" // prefix
- "2a94e703626172" // foo: bar
- "2a94e703626172" // foo: bar
- "2a94e70362617a" // foo: baz
- ),
+ EXPECT_EQ(absl::HexStringToBytes("0000" // prefix
+ "2a94e703626172" // foo: bar
+ "2a94e703626172" // foo: bar
+ "2a94e70362617a" // foo: baz
+ ),
output);
}
@@ -241,10 +240,9 @@
header_list["cookie"] = "baz"; // name matches static entry
// Set Dynamic Table Capacity instruction.
- std::string set_dyanamic_table_capacity =
- quiche::QuicheTextUtils::HexDecode("3fe11f");
+ std::string set_dyanamic_table_capacity = absl::HexStringToBytes("3fe11f");
// Insert three entries into the dynamic table.
- std::string insert_entries = quiche::QuicheTextUtils::HexDecode(
+ std::string insert_entries = absl::HexStringToBytes(
"62" // insert without name reference
"94e7" // Huffman-encoded name "foo"
"03626172" // value "bar"
@@ -256,7 +254,7 @@
WriteStreamData(Eq(quiche::QuicheStrCat(
set_dyanamic_table_capacity, insert_entries))));
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode(
+ EXPECT_EQ(absl::HexStringToBytes(
"0400" // prefix
"828180"), // dynamic entries with relative index 0, 1, and 2
Encode(header_list));
@@ -278,10 +276,9 @@
header_list["bar"] = "baz"; // no match
// Set Dynamic Table Capacity instruction.
- std::string set_dyanamic_table_capacity =
- quiche::QuicheTextUtils::HexDecode("3f07");
+ std::string set_dyanamic_table_capacity = absl::HexStringToBytes("3f07");
// Insert one entry into the dynamic table.
- std::string insert_entry = quiche::QuicheTextUtils::HexDecode(
+ std::string insert_entry = absl::HexStringToBytes(
"62" // insert without name reference
"94e7" // Huffman-encoded name "foo"
"03626172"); // value "bar"
@@ -289,15 +286,14 @@
WriteStreamData(Eq(quiche::QuicheStrCat(
set_dyanamic_table_capacity, insert_entry))));
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode(
- "0200" // prefix
- "80" // dynamic entry 0
- "40" // reference to dynamic entry 0 name
- "0362617a" // with literal value "baz"
- "55" // reference to static entry 5 name
- "0362617a" // with literal value "baz"
- "23626172" // literal name "bar"
- "0362617a"), // with literal value "baz"
+ EXPECT_EQ(absl::HexStringToBytes("0200" // prefix
+ "80" // dynamic entry 0
+ "40" // reference to dynamic entry 0 name
+ "0362617a" // with literal value "baz"
+ "55" // reference to static entry 5 name
+ "0362617a" // with literal value "baz"
+ "23626172" // literal name "bar"
+ "0362617a"), // with literal value "baz"
Encode(header_list));
EXPECT_EQ(insert_entry.size(), encoder_stream_sent_byte_count_);
@@ -312,10 +308,9 @@
header_list1["foo"] = "bar";
// Set Dynamic Table Capacity instruction.
- std::string set_dyanamic_table_capacity =
- quiche::QuicheTextUtils::HexDecode("3fe11f");
+ std::string set_dyanamic_table_capacity = absl::HexStringToBytes("3fe11f");
// Insert one entry into the dynamic table.
- std::string insert_entry1 = quiche::QuicheTextUtils::HexDecode(
+ std::string insert_entry1 = absl::HexStringToBytes(
"62" // insert without name reference
"94e7" // Huffman-encoded name "foo"
"03626172"); // value "bar"
@@ -323,8 +318,8 @@
WriteStreamData(Eq(quiche::QuicheStrCat(
set_dyanamic_table_capacity, insert_entry1))));
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("0200" // prefix
- "80"), // dynamic entry 0
+ EXPECT_EQ(absl::HexStringToBytes("0200" // prefix
+ "80"), // dynamic entry 0
encoder_.EncodeHeaderList(/* stream_id = */ 1, header_list1,
&encoder_stream_sent_byte_count_));
EXPECT_EQ(insert_entry1.size(), encoder_stream_sent_byte_count_);
@@ -337,16 +332,15 @@
header_list2["cookie"] = "baz"; // name matches static entry
header_list2["bar"] = "baz"; // no match
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode(
- "0000" // prefix
- "2a94e7" // literal name "foo"
- "03626172" // with literal value "bar"
- "2a94e7" // literal name "foo"
- "0362617a" // with literal value "baz"
- "55" // name of static entry 5
- "0362617a" // with literal value "baz"
- "23626172" // literal name "bar"
- "0362617a"), // with literal value "baz"
+ EXPECT_EQ(absl::HexStringToBytes("0000" // prefix
+ "2a94e7" // literal name "foo"
+ "03626172" // with literal value "bar"
+ "2a94e7" // literal name "foo"
+ "0362617a" // with literal value "baz"
+ "55" // name of static entry 5
+ "0362617a" // with literal value "baz"
+ "23626172" // literal name "bar"
+ "0362617a"), // with literal value "baz"
encoder_.EncodeHeaderList(/* stream_id = */ 2, header_list2,
&encoder_stream_sent_byte_count_));
EXPECT_EQ(0u, encoder_stream_sent_byte_count_);
@@ -356,7 +350,7 @@
encoder_.OnInsertCountIncrement(1);
// Insert three entries into the dynamic table.
- std::string insert_entries = quiche::QuicheTextUtils::HexDecode(
+ std::string insert_entries = absl::HexStringToBytes(
"80" // insert with name reference, dynamic index 0
"0362617a" // value "baz"
"c5" // insert with name reference, static index 5
@@ -367,23 +361,22 @@
EXPECT_CALL(encoder_stream_sender_delegate_,
WriteStreamData(Eq(insert_entries)));
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("0500" // prefix
- "83828180"), // dynamic entries
+ EXPECT_EQ(absl::HexStringToBytes("0500" // prefix
+ "83828180"), // dynamic entries
encoder_.EncodeHeaderList(/* stream_id = */ 3, header_list2,
&encoder_stream_sent_byte_count_));
EXPECT_EQ(insert_entries.size(), encoder_stream_sent_byte_count_);
// Stream 3 is blocked. Stream 4 is not allowed to block, but it can
// reference already acknowledged dynamic entry 0.
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode(
- "0200" // prefix
- "80" // dynamic entry 0
- "2a94e7" // literal name "foo"
- "0362617a" // with literal value "baz"
- "2c21cfd4c5" // literal name "cookie"
- "0362617a" // with literal value "baz"
- "23626172" // literal name "bar"
- "0362617a"), // with literal value "baz"
+ EXPECT_EQ(absl::HexStringToBytes("0200" // prefix
+ "80" // dynamic entry 0
+ "2a94e7" // literal name "foo"
+ "0362617a" // with literal value "baz"
+ "2c21cfd4c5" // literal name "cookie"
+ "0362617a" // with literal value "baz"
+ "23626172" // literal name "bar"
+ "0362617a"), // with literal value "baz"
encoder_.EncodeHeaderList(/* stream_id = */ 4, header_list2,
&encoder_stream_sent_byte_count_));
EXPECT_EQ(0u, encoder_stream_sent_byte_count_);
@@ -394,11 +387,10 @@
// Stream 5 is not allowed to block, but it can reference already acknowledged
// dynamic entries 0, 1, and 2.
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode(
- "0400" // prefix
- "828180" // dynamic entries
- "23626172" // literal name "bar"
- "0362617a"), // with literal value "baz"
+ EXPECT_EQ(absl::HexStringToBytes("0400" // prefix
+ "828180" // dynamic entries
+ "23626172" // literal name "bar"
+ "0362617a"), // with literal value "baz"
encoder_.EncodeHeaderList(/* stream_id = */ 5, header_list2,
&encoder_stream_sent_byte_count_));
EXPECT_EQ(0u, encoder_stream_sent_byte_count_);
@@ -407,8 +399,8 @@
// Stream 3 is not blocked any longer.
encoder_.OnHeaderAcknowledgement(3);
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("0500" // prefix
- "83828180"), // dynamic entries
+ EXPECT_EQ(absl::HexStringToBytes("0500" // prefix
+ "83828180"), // dynamic entries
encoder_.EncodeHeaderList(/* stream_id = */ 6, header_list2,
&encoder_stream_sent_byte_count_));
EXPECT_EQ(0u, encoder_stream_sent_byte_count_);
@@ -443,9 +435,8 @@
// dynamic table.
EXPECT_CALL(encoder_stream_sender_delegate_, WriteStreamData(_));
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode(
- "0b00" // prefix
- "89888786858483828180"), // dynamic entries
+ EXPECT_EQ(absl::HexStringToBytes("0b00" // prefix
+ "89888786858483828180"), // dynamic entries
Encode(header_list1));
// Entry is identical to oldest one, which is draining. It will be
@@ -455,11 +446,10 @@
// Duplicate oldest entry.
EXPECT_CALL(encoder_stream_sender_delegate_,
- WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("09"))));
+ WriteStreamData(Eq(absl::HexStringToBytes("09"))));
- EXPECT_EQ(quiche::QuicheTextUtils::HexDecode(
- "0c00" // prefix
- "80"), // most recent dynamic table entry
+ EXPECT_EQ(absl::HexStringToBytes("0c00" // prefix
+ "80"), // most recent dynamic table entry
Encode(header_list2));
spdy::Http2HeaderBlock header_list3;
@@ -470,13 +460,12 @@
// no room to insert new entry, it will be encoded with string literals.
header_list3.AppendValueOrAddHeader("two", "bar");
- EXPECT_EQ(
- quiche::QuicheTextUtils::HexDecode("0000" // prefix
- "2374776f" // literal name "two"
- "8294e7" // literal value "foo"
- "2374776f" // literal name "two"
- "03626172"), // literal value "bar"
- Encode(header_list3));
+ EXPECT_EQ(absl::HexStringToBytes("0000" // prefix
+ "2374776f" // literal name "two"
+ "8294e7" // literal value "foo"
+ "2374776f" // literal name "two"
+ "03626172"), // literal value "bar"
+ Encode(header_list3));
}
TEST_F(QpackEncoderTest, DynamicTableCapacityLessThanMaximum) {
diff --git a/quic/core/qpack/qpack_instruction_decoder_test.cc b/quic/core/qpack/qpack_instruction_decoder_test.cc
index ac7b369..52ec38b 100644
--- a/quic/core/qpack/qpack_instruction_decoder_test.cc
+++ b/quic/core/qpack/qpack_instruction_decoder_test.cc
@@ -6,6 +6,7 @@
#include <algorithm>
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/qpack/qpack_instructions.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
@@ -130,14 +131,14 @@
TEST_P(QpackInstructionDecoderTest, SBitAndVarint2) {
EXPECT_CALL(delegate_, OnInstructionDecoded(TestInstruction1()));
- DecodeInstruction(quiche::QuicheTextUtils::HexDecode("7f01ff65"));
+ DecodeInstruction(absl::HexStringToBytes("7f01ff65"));
EXPECT_TRUE(decoder_->s_bit());
EXPECT_EQ(64u, decoder_->varint());
EXPECT_EQ(356u, decoder_->varint2());
EXPECT_CALL(delegate_, OnInstructionDecoded(TestInstruction1()));
- DecodeInstruction(quiche::QuicheTextUtils::HexDecode("05c8"));
+ DecodeInstruction(absl::HexStringToBytes("05c8"));
EXPECT_FALSE(decoder_->s_bit());
EXPECT_EQ(5u, decoder_->varint());
@@ -146,19 +147,19 @@
TEST_P(QpackInstructionDecoderTest, NameAndValue) {
EXPECT_CALL(delegate_, OnInstructionDecoded(TestInstruction2()));
- DecodeInstruction(quiche::QuicheTextUtils::HexDecode("83666f6f03626172"));
+ DecodeInstruction(absl::HexStringToBytes("83666f6f03626172"));
EXPECT_EQ("foo", decoder_->name());
EXPECT_EQ("bar", decoder_->value());
EXPECT_CALL(delegate_, OnInstructionDecoded(TestInstruction2()));
- DecodeInstruction(quiche::QuicheTextUtils::HexDecode("8000"));
+ DecodeInstruction(absl::HexStringToBytes("8000"));
EXPECT_EQ("", decoder_->name());
EXPECT_EQ("", decoder_->value());
EXPECT_CALL(delegate_, OnInstructionDecoded(TestInstruction2()));
- DecodeInstruction(quiche::QuicheTextUtils::HexDecode("c294e7838c767f"));
+ DecodeInstruction(absl::HexStringToBytes("c294e7838c767f"));
EXPECT_EQ("foo", decoder_->name());
EXPECT_EQ("bar", decoder_->value());
@@ -169,7 +170,7 @@
OnInstructionDecodingError(
QpackInstructionDecoder::ErrorCode::HUFFMAN_ENCODING_ERROR,
Eq("Error in Huffman-encoded string.")));
- DecodeInstruction(quiche::QuicheTextUtils::HexDecode("c1ff"));
+ DecodeInstruction(absl::HexStringToBytes("c1ff"));
}
TEST_P(QpackInstructionDecoderTest, InvalidVarintEncoding) {
@@ -177,8 +178,7 @@
OnInstructionDecodingError(
QpackInstructionDecoder::ErrorCode::INTEGER_TOO_LARGE,
Eq("Encoded integer too large.")));
- DecodeInstruction(
- quiche::QuicheTextUtils::HexDecode("ffffffffffffffffffffff"));
+ DecodeInstruction(absl::HexStringToBytes("ffffffffffffffffffffff"));
}
TEST_P(QpackInstructionDecoderTest, StringLiteralTooLong) {
@@ -186,7 +186,7 @@
OnInstructionDecodingError(
QpackInstructionDecoder::ErrorCode::STRING_LITERAL_TOO_LONG,
Eq("String literal too long.")));
- DecodeInstruction(quiche::QuicheTextUtils::HexDecode("bfffff7f"));
+ DecodeInstruction(absl::HexStringToBytes("bfffff7f"));
}
TEST_P(QpackInstructionDecoderTest, DelegateSignalsError) {
@@ -206,8 +206,8 @@
return false;
}));
- EXPECT_FALSE(decoder_->Decode(
- quiche::QuicheTextUtils::HexDecode("01000200030004000500")));
+ EXPECT_FALSE(
+ decoder_->Decode(absl::HexStringToBytes("01000200030004000500")));
}
// QpackInstructionDecoder must not crash if it is destroyed from a
@@ -219,7 +219,7 @@
decoder_.reset();
return false;
}));
- DecodeInstruction(quiche::QuicheTextUtils::HexDecode("0100"));
+ DecodeInstruction(absl::HexStringToBytes("0100"));
}
} // namespace
diff --git a/quic/core/qpack/qpack_instruction_encoder_test.cc b/quic/core/qpack/qpack_instruction_encoder_test.cc
index 66a6c42..893bc50 100644
--- a/quic/core/qpack/qpack_instruction_encoder_test.cc
+++ b/quic/core/qpack/qpack_instruction_encoder_test.cc
@@ -4,6 +4,7 @@
#include "net/third_party/quiche/src/quic/core/qpack/qpack_instruction_encoder.h"
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
@@ -65,8 +66,7 @@
bool EncodedSegmentMatches(absl::string_view hex_encoded_expected_substring) {
auto recently_encoded =
absl::string_view(output_).substr(verified_position_);
- auto expected =
- quiche::QuicheTextUtils::HexDecode(hex_encoded_expected_substring);
+ auto expected = absl::HexStringToBytes(hex_encoded_expected_substring);
verified_position_ = output_.size();
return recently_encoded == expected;
}
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 1dc7f94..f493598 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -15,6 +15,7 @@
#include <string>
#include <utility>
+#include "absl/strings/escaping.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/crypto/crypto_utils.h"
@@ -939,21 +940,20 @@
QUIC_DLOG(ERROR) << "Ignoring RETRY with original connection ID "
<< original_connection_id << " not matching expected "
<< server_connection_id_ << " token "
- << quiche::QuicheTextUtils::HexEncode(retry_token);
+ << absl::BytesToHexString(retry_token);
return;
}
}
if (drop_incoming_retry_packets_) {
QUIC_DLOG(ERROR) << "Ignoring RETRY with token "
- << quiche::QuicheTextUtils::HexEncode(retry_token);
+ << absl::BytesToHexString(retry_token);
return;
}
drop_incoming_retry_packets_ = true;
stats_.retry_packet_processed = true;
QUIC_DLOG(INFO) << "Received RETRY, replacing connection ID "
<< server_connection_id_ << " with " << new_connection_id
- << ", received token "
- << quiche::QuicheTextUtils::HexEncode(retry_token);
+ << ", received token " << absl::BytesToHexString(retry_token);
if (!original_destination_connection_id_.has_value()) {
original_destination_connection_id_ = server_connection_id_;
}
diff --git a/quic/core/quic_connection_id.cc b/quic/core/quic_connection_id.cc
index 57e57c5..e682ee3 100644
--- a/quic/core/quic_connection_id.cc
+++ b/quic/core/quic_connection_id.cc
@@ -10,6 +10,7 @@
#include <iomanip>
#include <string>
+#include "absl/strings/escaping.h"
#include "third_party/boringssl/src/include/openssl/siphash.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
@@ -144,7 +145,7 @@
if (IsEmpty()) {
return std::string("0");
}
- return quiche::QuicheTextUtils::HexEncode(data(), length_);
+ return absl::BytesToHexString(absl::string_view(data(), length_));
}
std::ostream& operator<<(std::ostream& os, const QuicConnectionId& v) {
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 66765b0..58bf909 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -14,6 +14,7 @@
#include "absl/base/attributes.h"
#include "absl/base/macros.h"
#include "absl/base/optimization.h"
+#include "absl/strings/escaping.h"
#include "absl/strings/numbers.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
@@ -1648,8 +1649,8 @@
<< "Failed to parse received coalesced header of length "
<< coalesced_data_length
<< " with error: " << detailed_error_ << ": "
- << quiche::QuicheTextUtils::HexEncode(coalesced_data,
- coalesced_data_length)
+ << absl::BytesToHexString(absl::string_view(
+ coalesced_data, coalesced_data_length))
<< " previous header was " << header;
return;
}
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index aa7fa8b..ba9a70e 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -13,6 +13,7 @@
#include <vector>
#include "absl/base/macros.h"
+#include "absl/strings/escaping.h"
#include "absl/strings/match.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/crypto/null_decrypter.h"
@@ -768,10 +769,8 @@
retry_token_length, length_length);
if (associated_data != decrypter_->associated_data_) {
QUIC_LOG(ERROR) << "Decrypted incorrect associated data. expected "
- << quiche::QuicheTextUtils::HexEncode(associated_data)
- << " actual: "
- << quiche::QuicheTextUtils::HexEncode(
- decrypter_->associated_data_);
+ << absl::BytesToHexString(associated_data) << " actual: "
+ << absl::BytesToHexString(decrypter_->associated_data_);
return false;
}
absl::string_view ciphertext(
@@ -782,12 +781,10 @@
retry_token_length_length, retry_token_length, length_length)));
if (ciphertext != decrypter_->ciphertext_) {
QUIC_LOG(ERROR) << "Decrypted incorrect ciphertext data. expected "
- << quiche::QuicheTextUtils::HexEncode(ciphertext)
- << " actual: "
- << quiche::QuicheTextUtils::HexEncode(
- decrypter_->ciphertext_)
+ << absl::BytesToHexString(ciphertext) << " actual: "
+ << absl::BytesToHexString(decrypter_->ciphertext_)
<< " associated data: "
- << quiche::QuicheTextUtils::HexEncode(associated_data);
+ << absl::BytesToHexString(associated_data);
return false;
}
return true;
diff --git a/quic/core/quic_packets.cc b/quic/core/quic_packets.cc
index 0325909..3d6228e 100644
--- a/quic/core/quic_packets.cc
+++ b/quic/core/quic_packets.cc
@@ -6,6 +6,7 @@
#include <utility>
+#include "absl/strings/escaping.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_types.h"
@@ -263,7 +264,7 @@
}
if (header.nonce != nullptr) {
os << ", diversification_nonce: "
- << quiche::QuicheTextUtils::HexEncode(
+ << absl::BytesToHexString(
absl::string_view(header.nonce->data(), header.nonce->size()));
}
os << ", packet_number: " << header.packet_number << " }\n";
diff --git a/quic/core/quic_tag.cc b/quic/core/quic_tag.cc
index 2858924..ed7ae17 100644
--- a/quic/core/quic_tag.cc
+++ b/quic/core/quic_tag.cc
@@ -8,6 +8,7 @@
#include <string>
#include "absl/base/macros.h"
+#include "absl/strings/escaping.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_text_utils.h"
@@ -60,8 +61,8 @@
return std::string(chars, sizeof(chars));
}
- return quiche::QuicheTextUtils::HexEncode(
- reinterpret_cast<const char*>(&orig_tag), sizeof(orig_tag));
+ return absl::BytesToHexString(absl::string_view(
+ reinterpret_cast<const char*>(&orig_tag), sizeof(orig_tag)));
}
uint32_t MakeQuicTag(char a, char b, char c, char d) {
@@ -78,7 +79,7 @@
quiche::QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(&tag_string);
std::string tag_bytes;
if (tag_string.length() == 8) {
- tag_bytes = quiche::QuicheTextUtils::HexDecode(tag_string);
+ tag_bytes = absl::HexStringToBytes(tag_string);
tag_string = tag_bytes;
}
QuicTag tag = 0;
diff --git a/quic/test_tools/crypto_test_utils.cc b/quic/test_tools/crypto_test_utils.cc
index e8535d8..00f7f1b 100644
--- a/quic/test_tools/crypto_test_utils.cc
+++ b/quic/test_tools/crypto_test_utils.cc
@@ -9,6 +9,7 @@
#include <string>
#include <utility>
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "third_party/boringssl/src/include/openssl/bn.h"
#include "third_party/boringssl/src/include/openssl/ec.h"
@@ -705,7 +706,7 @@
if (value_len > 0 && value[0] == '#') {
// This is ascii encoded hex.
std::string hex_value =
- quiche::QuicheTextUtils::HexDecode(absl::string_view(&value[1]));
+ absl::HexStringToBytes(absl::string_view(&value[1]));
msg.SetStringPiece(quic_tag, hex_value);
continue;
}
@@ -831,14 +832,14 @@
std::string nonce;
CryptoUtils::GenerateNonce(clock->WallNow(), QuicRandom::GetInstance(), orbit,
&nonce);
- return ("#" + quiche::QuicheTextUtils::HexEncode(nonce));
+ return ("#" + absl::BytesToHexString(nonce));
}
std::string GenerateClientPublicValuesHex() {
char public_value[32];
memset(public_value, 42, sizeof(public_value));
- return ("#" + quiche::QuicheTextUtils::HexEncode(public_value,
- sizeof(public_value)));
+ return ("#" + absl::BytesToHexString(
+ absl::string_view(public_value, sizeof(public_value))));
}
void GenerateFullCHLO(
diff --git a/quic/test_tools/crypto_test_utils_test.cc b/quic/test_tools/crypto_test_utils_test.cc
index 45bcec4..0769da4 100644
--- a/quic/test_tools/crypto_test_utils_test.cc
+++ b/quic/test_tools/crypto_test_utils_test.cc
@@ -6,6 +6,7 @@
#include <utility>
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/proto/crypto_server_config_proto.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
@@ -139,12 +140,12 @@
std::string nonce;
CryptoUtils::GenerateNonce(clock.WallNow(), QuicRandom::GetInstance(), orbit,
&nonce);
- std::string nonce_hex = "#" + quiche::QuicheTextUtils::HexEncode(nonce);
+ std::string nonce_hex = "#" + absl::BytesToHexString(nonce);
char public_value[32];
memset(public_value, 42, sizeof(public_value));
- std::string pub_hex = "#" + quiche::QuicheTextUtils::HexEncode(
- public_value, sizeof(public_value));
+ std::string pub_hex = "#" + absl::BytesToHexString(absl::string_view(
+ public_value, sizeof(public_value)));
// The methods below use a PROTOCOL_QUIC_CRYPTO version so we pick the
// first one from the list of supported versions.
diff --git a/quic/tools/quic_packet_printer_bin.cc b/quic/tools/quic_packet_printer_bin.cc
index 6f9a658..cfe0b8d 100644
--- a/quic/tools/quic_packet_printer_bin.cc
+++ b/quic/tools/quic_packet_printer_bin.cc
@@ -33,6 +33,7 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
#include "absl/strings/string_view.h"
+#include "absl/strings/escaping.h"
DEFINE_QUIC_COMMAND_LINE_FLAG(std::string,
quic_version,
@@ -99,16 +100,16 @@
bool OnStreamFrame(const QuicStreamFrame& frame) override {
std::cerr << "OnStreamFrame: " << frame;
std::cerr << " data: { "
- << quiche::QuicheTextUtils::HexEncode(frame.data_buffer,
- frame.data_length)
+ << absl::BytesToHexString(
+ absl::string_view(frame.data_buffer, frame.data_length))
<< " }\n";
return true;
}
bool OnCryptoFrame(const QuicCryptoFrame& frame) override {
std::cerr << "OnCryptoFrame: " << frame;
std::cerr << " data: { "
- << quiche::QuicheTextUtils::HexEncode(frame.data_buffer,
- frame.data_length)
+ << absl::BytesToHexString(
+ absl::string_view(frame.data_buffer, frame.data_length))
<< " }\n";
return true;
}
@@ -263,7 +264,7 @@
quic::QuicPrintCommandLineFlagHelp(usage);
return 1;
}
- std::string hex = quiche::QuicheTextUtils::HexDecode(args[1]);
+ std::string hex = absl::HexStringToBytes(args[1]);
quic::ParsedQuicVersionVector versions = quic::AllSupportedVersions();
// Fake a time since we're not actually generating acks.
quic::QuicTime start(quic::QuicTime::Zero());
diff --git a/quic/tools/quic_toy_client.cc b/quic/tools/quic_toy_client.cc
index c4b36db..0b34e88 100644
--- a/quic/tools/quic_toy_client.cc
+++ b/quic/tools/quic_toy_client.cc
@@ -48,6 +48,7 @@
#include <utility>
#include <vector>
+#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_packets.h"
#include "net/third_party/quiche/src/quic/core/quic_server_id.h"
@@ -321,7 +322,7 @@
if (!GetQuicFlag(FLAGS_body_hex).empty()) {
DCHECK(GetQuicFlag(FLAGS_body).empty())
<< "Only set one of --body and --body_hex.";
- body = QuicheTextUtils::HexDecode(GetQuicFlag(FLAGS_body_hex));
+ body = absl::HexStringToBytes(GetQuicFlag(FLAGS_body_hex));
}
// Construct a GET or POST request for supplied URL.
@@ -358,8 +359,8 @@
if (!GetQuicFlag(FLAGS_body_hex).empty()) {
// Print the user provided hex, rather than binary body.
std::cout << "body:\n"
- << QuicheTextUtils::HexDump(QuicheTextUtils::HexDecode(
- GetQuicFlag(FLAGS_body_hex)))
+ << QuicheTextUtils::HexDump(
+ absl::HexStringToBytes(GetQuicFlag(FLAGS_body_hex)))
<< std::endl;
} else {
std::cout << "body: " << body << std::endl;
