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;