diff --git a/quic/core/crypto/aead_base_decrypter.cc b/quic/core/crypto/aead_base_decrypter.cc
index 53bd0f0..474c443 100644
--- a/quic/core/crypto/aead_base_decrypter.cc
+++ b/quic/core/crypto/aead_base_decrypter.cc
@@ -125,7 +125,7 @@
     return true;
   }
 
-  QuicString key, nonce_prefix;
+  std::string key, nonce_prefix;
   size_t prefix_size = nonce_size_ - sizeof(QuicPacketNumber);
   DiversifyPreliminaryKey(
       QuicStringPiece(reinterpret_cast<const char*>(key_), key_size_),
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 6513e45..d9b2e8d 100644
--- a/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc
+++ b/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc
@@ -232,12 +232,12 @@
       bool has_pt = test_vectors[j].pt;
 
       // Decode the test vector.
-      QuicString key = QuicTextUtils::HexDecode(test_vectors[j].key);
-      QuicString iv = QuicTextUtils::HexDecode(test_vectors[j].iv);
-      QuicString ct = QuicTextUtils::HexDecode(test_vectors[j].ct);
-      QuicString aad = QuicTextUtils::HexDecode(test_vectors[j].aad);
-      QuicString tag = QuicTextUtils::HexDecode(test_vectors[j].tag);
-      QuicString pt;
+      std::string key = QuicTextUtils::HexDecode(test_vectors[j].key);
+      std::string iv = QuicTextUtils::HexDecode(test_vectors[j].iv);
+      std::string ct = QuicTextUtils::HexDecode(test_vectors[j].ct);
+      std::string aad = QuicTextUtils::HexDecode(test_vectors[j].aad);
+      std::string tag = QuicTextUtils::HexDecode(test_vectors[j].tag);
+      std::string pt;
       if (has_pt) {
         pt = QuicTextUtils::HexDecode(test_vectors[j].pt);
       }
@@ -258,7 +258,7 @@
       ASSERT_LE(static_cast<size_t>(Aes128Gcm12Decrypter::kAuthTagSize),
                 tag.length());
       tag.resize(Aes128Gcm12Decrypter::kAuthTagSize);
-      QuicString ciphertext = ct + tag;
+      std::string ciphertext = ct + tag;
 
       Aes128Gcm12Decrypter decrypter;
       ASSERT_TRUE(decrypter.SetKey(key));
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 67660cf..7aa1cf9 100644
--- a/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc
+++ b/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc
@@ -181,12 +181,12 @@
     const TestGroupInfo& test_info = test_group_info[i];
     for (size_t j = 0; test_vectors[j].key != nullptr; j++) {
       // Decode the test vector.
-      QuicString key = QuicTextUtils::HexDecode(test_vectors[j].key);
-      QuicString iv = QuicTextUtils::HexDecode(test_vectors[j].iv);
-      QuicString pt = QuicTextUtils::HexDecode(test_vectors[j].pt);
-      QuicString aad = QuicTextUtils::HexDecode(test_vectors[j].aad);
-      QuicString ct = QuicTextUtils::HexDecode(test_vectors[j].ct);
-      QuicString tag = QuicTextUtils::HexDecode(test_vectors[j].tag);
+      std::string key = QuicTextUtils::HexDecode(test_vectors[j].key);
+      std::string iv = QuicTextUtils::HexDecode(test_vectors[j].iv);
+      std::string pt = QuicTextUtils::HexDecode(test_vectors[j].pt);
+      std::string aad = QuicTextUtils::HexDecode(test_vectors[j].aad);
+      std::string ct = QuicTextUtils::HexDecode(test_vectors[j].ct);
+      std::string tag = QuicTextUtils::HexDecode(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 300e8a2..1ef986f 100644
--- a/quic/core/crypto/aes_128_gcm_decrypter_test.cc
+++ b/quic/core/crypto/aes_128_gcm_decrypter_test.cc
@@ -227,12 +227,12 @@
       bool has_pt = test_vectors[j].pt;
 
       // Decode the test vector.
-      QuicString key = QuicTextUtils::HexDecode(test_vectors[j].key);
-      QuicString iv = QuicTextUtils::HexDecode(test_vectors[j].iv);
-      QuicString ct = QuicTextUtils::HexDecode(test_vectors[j].ct);
-      QuicString aad = QuicTextUtils::HexDecode(test_vectors[j].aad);
-      QuicString tag = QuicTextUtils::HexDecode(test_vectors[j].tag);
-      QuicString pt;
+      std::string key = QuicTextUtils::HexDecode(test_vectors[j].key);
+      std::string iv = QuicTextUtils::HexDecode(test_vectors[j].iv);
+      std::string ct = QuicTextUtils::HexDecode(test_vectors[j].ct);
+      std::string aad = QuicTextUtils::HexDecode(test_vectors[j].aad);
+      std::string tag = QuicTextUtils::HexDecode(test_vectors[j].tag);
+      std::string pt;
       if (has_pt) {
         pt = QuicTextUtils::HexDecode(test_vectors[j].pt);
       }
@@ -247,7 +247,7 @@
       if (has_pt) {
         EXPECT_EQ(test_info.pt_len, pt.length() * 8);
       }
-      QuicString ciphertext = ct + tag;
+      std::string ciphertext = ct + tag;
 
       Aes128GcmDecrypter decrypter;
       ASSERT_TRUE(decrypter.SetKey(key));
diff --git a/quic/core/crypto/aes_128_gcm_encrypter_test.cc b/quic/core/crypto/aes_128_gcm_encrypter_test.cc
index 959cb9d..e2e425e 100644
--- a/quic/core/crypto/aes_128_gcm_encrypter_test.cc
+++ b/quic/core/crypto/aes_128_gcm_encrypter_test.cc
@@ -181,12 +181,12 @@
     const TestGroupInfo& test_info = test_group_info[i];
     for (size_t j = 0; test_vectors[j].key != nullptr; j++) {
       // Decode the test vector.
-      QuicString key = QuicTextUtils::HexDecode(test_vectors[j].key);
-      QuicString iv = QuicTextUtils::HexDecode(test_vectors[j].iv);
-      QuicString pt = QuicTextUtils::HexDecode(test_vectors[j].pt);
-      QuicString aad = QuicTextUtils::HexDecode(test_vectors[j].aad);
-      QuicString ct = QuicTextUtils::HexDecode(test_vectors[j].ct);
-      QuicString tag = QuicTextUtils::HexDecode(test_vectors[j].tag);
+      std::string key = QuicTextUtils::HexDecode(test_vectors[j].key);
+      std::string iv = QuicTextUtils::HexDecode(test_vectors[j].iv);
+      std::string pt = QuicTextUtils::HexDecode(test_vectors[j].pt);
+      std::string aad = QuicTextUtils::HexDecode(test_vectors[j].aad);
+      std::string ct = QuicTextUtils::HexDecode(test_vectors[j].ct);
+      std::string tag = QuicTextUtils::HexDecode(test_vectors[j].tag);
 
       // The test vector's lengths should look sane. Note that the lengths
       // in |test_info| are in bits.
@@ -218,13 +218,14 @@
 }
 
 TEST_F(Aes128GcmEncrypterTest, EncryptPacket) {
-  QuicString key = QuicTextUtils::HexDecode("d95a145250826c25a77b6a84fd4d34fc");
-  QuicString iv = QuicTextUtils::HexDecode("50c4431ebb18283448e276e2");
+  std::string key =
+      QuicTextUtils::HexDecode("d95a145250826c25a77b6a84fd4d34fc");
+  std::string iv = QuicTextUtils::HexDecode("50c4431ebb18283448e276e2");
   uint64_t packet_num = 0x13278f44;
-  QuicString aad =
+  std::string aad =
       QuicTextUtils::HexDecode("875d49f64a70c9cbe713278f44ff000005");
-  QuicString pt = QuicTextUtils::HexDecode("aa0003a250bd000000000001");
-  QuicString ct = QuicTextUtils::HexDecode(
+  std::string pt = QuicTextUtils::HexDecode("aa0003a250bd000000000001");
+  std::string ct = QuicTextUtils::HexDecode(
       "7dd4708b989ee7d38a013e3656e9b37beefd05808fe1ab41e3b4f2c0");
 
   std::vector<char> out(ct.size());
diff --git a/quic/core/crypto/aes_256_gcm_decrypter_test.cc b/quic/core/crypto/aes_256_gcm_decrypter_test.cc
index cb5f702..16e2428 100644
--- a/quic/core/crypto/aes_256_gcm_decrypter_test.cc
+++ b/quic/core/crypto/aes_256_gcm_decrypter_test.cc
@@ -231,12 +231,12 @@
       bool has_pt = test_vectors[j].pt;
 
       // Decode the test vector.
-      QuicString key = QuicTextUtils::HexDecode(test_vectors[j].key);
-      QuicString iv = QuicTextUtils::HexDecode(test_vectors[j].iv);
-      QuicString ct = QuicTextUtils::HexDecode(test_vectors[j].ct);
-      QuicString aad = QuicTextUtils::HexDecode(test_vectors[j].aad);
-      QuicString tag = QuicTextUtils::HexDecode(test_vectors[j].tag);
-      QuicString pt;
+      std::string key = QuicTextUtils::HexDecode(test_vectors[j].key);
+      std::string iv = QuicTextUtils::HexDecode(test_vectors[j].iv);
+      std::string ct = QuicTextUtils::HexDecode(test_vectors[j].ct);
+      std::string aad = QuicTextUtils::HexDecode(test_vectors[j].aad);
+      std::string tag = QuicTextUtils::HexDecode(test_vectors[j].tag);
+      std::string pt;
       if (has_pt) {
         pt = QuicTextUtils::HexDecode(test_vectors[j].pt);
       }
@@ -251,7 +251,7 @@
       if (has_pt) {
         EXPECT_EQ(test_info.pt_len, pt.length() * 8);
       }
-      QuicString ciphertext = ct + tag;
+      std::string ciphertext = ct + tag;
 
       Aes256GcmDecrypter decrypter;
       ASSERT_TRUE(decrypter.SetKey(key));
diff --git a/quic/core/crypto/aes_256_gcm_encrypter_test.cc b/quic/core/crypto/aes_256_gcm_encrypter_test.cc
index 0472986..f70edbc 100644
--- a/quic/core/crypto/aes_256_gcm_encrypter_test.cc
+++ b/quic/core/crypto/aes_256_gcm_encrypter_test.cc
@@ -188,12 +188,12 @@
     const TestGroupInfo& test_info = test_group_info[i];
     for (size_t j = 0; test_vectors[j].key != nullptr; j++) {
       // Decode the test vector.
-      QuicString key = QuicTextUtils::HexDecode(test_vectors[j].key);
-      QuicString iv = QuicTextUtils::HexDecode(test_vectors[j].iv);
-      QuicString pt = QuicTextUtils::HexDecode(test_vectors[j].pt);
-      QuicString aad = QuicTextUtils::HexDecode(test_vectors[j].aad);
-      QuicString ct = QuicTextUtils::HexDecode(test_vectors[j].ct);
-      QuicString tag = QuicTextUtils::HexDecode(test_vectors[j].tag);
+      std::string key = QuicTextUtils::HexDecode(test_vectors[j].key);
+      std::string iv = QuicTextUtils::HexDecode(test_vectors[j].iv);
+      std::string pt = QuicTextUtils::HexDecode(test_vectors[j].pt);
+      std::string aad = QuicTextUtils::HexDecode(test_vectors[j].aad);
+      std::string ct = QuicTextUtils::HexDecode(test_vectors[j].ct);
+      std::string tag = QuicTextUtils::HexDecode(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/cert_compressor.cc b/quic/core/crypto/cert_compressor.cc
index 204539b..53c6117 100644
--- a/quic/core/crypto/cert_compressor.cc
+++ b/quic/core/crypto/cert_compressor.cc
@@ -174,7 +174,7 @@
 // efficiently represent |certs| to a peer who has the common sets identified
 // by |client_common_set_hashes| and who has cached the certificates with the
 // 64-bit, FNV-1a hashes in |client_cached_cert_hashes|.
-std::vector<CertEntry> MatchCerts(const std::vector<QuicString>& certs,
+std::vector<CertEntry> MatchCerts(const std::vector<std::string>& certs,
                                   QuicStringPiece client_common_set_hashes,
                                   QuicStringPiece client_cached_cert_hashes,
                                   const CommonCertSets* common_sets) {
@@ -281,9 +281,9 @@
 // dictionary to use in order to decompress a zlib block following |entries|.
 // |certs| is one-to-one with |entries| and contains the certificates for those
 // entries that are CACHED or COMMON.
-QuicString ZlibDictForEntries(const std::vector<CertEntry>& entries,
-                              const std::vector<QuicString>& certs) {
-  QuicString zlib_dict;
+std::string ZlibDictForEntries(const std::vector<CertEntry>& entries,
+                               const std::vector<std::string>& certs) {
+  std::string zlib_dict;
 
   // The dictionary starts with the common and cached certs in reverse order.
   size_t zlib_dict_size = 0;
@@ -304,8 +304,8 @@
     }
   }
 
-  zlib_dict += QuicString(reinterpret_cast<const char*>(kCommonCertSubstrings),
-                          sizeof(kCommonCertSubstrings));
+  zlib_dict += std::string(reinterpret_cast<const char*>(kCommonCertSubstrings),
+                           sizeof(kCommonCertSubstrings));
 
   DCHECK_EQ(zlib_dict.size(), zlib_dict_size);
 
@@ -313,7 +313,7 @@
 }
 
 // HashCerts returns the FNV-1a hashes of |certs|.
-std::vector<uint64_t> HashCerts(const std::vector<QuicString>& certs) {
+std::vector<uint64_t> HashCerts(const std::vector<std::string>& certs) {
   std::vector<uint64_t> ret;
   ret.reserve(certs.size());
 
@@ -329,10 +329,10 @@
 // resolved using |cached_certs| and |common_sets| and written to |out_certs|.
 // |in_out| is updated to contain the trailing data.
 bool ParseEntries(QuicStringPiece* in_out,
-                  const std::vector<QuicString>& cached_certs,
+                  const std::vector<std::string>& cached_certs,
                   const CommonCertSets* common_sets,
                   std::vector<CertEntry>* out_entries,
-                  std::vector<QuicString>* out_certs) {
+                  std::vector<std::string>* out_certs) {
   QuicStringPiece in = *in_out;
   std::vector<uint64_t> cached_hashes;
 
@@ -355,7 +355,7 @@
 
     switch (entry.type) {
       case CertEntry::COMPRESSED:
-        out_certs->push_back(QuicString());
+        out_certs->push_back(std::string());
         break;
       case CertEntry::CACHED: {
         if (in.size() < sizeof(uint64_t)) {
@@ -397,7 +397,7 @@
         if (cert.empty()) {
           return false;
         }
-        out_certs->push_back(QuicString(cert));
+        out_certs->push_back(std::string(cert));
         break;
       }
       default:
@@ -448,8 +448,8 @@
 }  // anonymous namespace
 
 // static
-QuicString CertCompressor::CompressChain(
-    const std::vector<QuicString>& certs,
+std::string CertCompressor::CompressChain(
+    const std::vector<std::string>& certs,
     QuicStringPiece client_common_set_hashes,
     QuicStringPiece client_cached_cert_hashes,
     const CommonCertSets* common_sets) {
@@ -477,7 +477,7 @@
     }
     scoped_z.reset(&z);
 
-    QuicString zlib_dict = ZlibDictForEntries(entries, certs);
+    std::string zlib_dict = ZlibDictForEntries(entries, certs);
 
     rv = deflateSetDictionary(
         &z, reinterpret_cast<const uint8_t*>(&zlib_dict[0]), zlib_dict.size());
@@ -491,7 +491,7 @@
 
   const size_t entries_size = CertEntriesSize(entries);
 
-  QuicString result;
+  std::string result;
   result.resize(entries_size + (uncompressed_size > 0 ? 4 : 0) +
                 compressed_size);
 
@@ -552,9 +552,9 @@
 // static
 bool CertCompressor::DecompressChain(
     QuicStringPiece in,
-    const std::vector<QuicString>& cached_certs,
+    const std::vector<std::string>& cached_certs,
     const CommonCertSets* common_sets,
-    std::vector<QuicString>* out_certs) {
+    std::vector<std::string>* out_certs) {
   std::vector<CertEntry> entries;
   if (!ParseEntries(&in, cached_certs, common_sets, &entries, out_certs)) {
     return false;
@@ -595,7 +595,7 @@
 
     int rv = inflate(&z, Z_FINISH);
     if (rv == Z_NEED_DICT) {
-      QuicString zlib_dict = ZlibDictForEntries(entries, *out_certs);
+      std::string zlib_dict = ZlibDictForEntries(entries, *out_certs);
       const uint8_t* dict = reinterpret_cast<const uint8_t*>(zlib_dict.data());
       if (Z_OK != inflateSetDictionary(&z, dict, zlib_dict.size())) {
         return false;
@@ -623,7 +623,7 @@
         if (uncompressed.size() < cert_len) {
           return false;
         }
-        (*out_certs)[i] = QuicString(uncompressed.substr(0, cert_len));
+        (*out_certs)[i] = std::string(uncompressed.substr(0, cert_len));
         uncompressed.remove_prefix(cert_len);
         break;
       case CertEntry::CACHED:
diff --git a/quic/core/crypto/cert_compressor.h b/quic/core/crypto/cert_compressor.h
index 624ac71..fd73e6e 100644
--- a/quic/core/crypto/cert_compressor.h
+++ b/quic/core/crypto/cert_compressor.h
@@ -37,19 +37,19 @@
   // sets known locally and |client_common_set_hashes| contains the hashes of
   // the common sets known to the peer. |client_cached_cert_hashes| contains
   // 64-bit, FNV-1a hashes of certificates that the peer already possesses.
-  static QuicString CompressChain(const std::vector<QuicString>& certs,
-                                  QuicStringPiece client_common_set_hashes,
-                                  QuicStringPiece client_cached_cert_hashes,
-                                  const CommonCertSets* common_sets);
+  static std::string CompressChain(const std::vector<std::string>& certs,
+                                   QuicStringPiece client_common_set_hashes,
+                                   QuicStringPiece client_cached_cert_hashes,
+                                   const CommonCertSets* common_sets);
 
   // DecompressChain decompresses the result of |CompressChain|, given in |in|,
   // into a series of certificates that are written to |out_certs|.
   // |cached_certs| contains certificates that the peer may have omitted and
   // |common_sets| contains the common certificate sets known locally.
   static bool DecompressChain(QuicStringPiece in,
-                              const std::vector<QuicString>& cached_certs,
+                              const std::vector<std::string>& cached_certs,
                               const CommonCertSets* common_sets,
-                              std::vector<QuicString>* out_certs);
+                              std::vector<std::string>* out_certs);
 };
 
 }  // namespace quic
diff --git a/quic/core/crypto/cert_compressor_test.cc b/quic/core/crypto/cert_compressor_test.cc
index 87b330a..e3ac2f1 100644
--- a/quic/core/crypto/cert_compressor_test.cc
+++ b/quic/core/crypto/cert_compressor_test.cc
@@ -18,26 +18,26 @@
 class CertCompressorTest : public QuicTest {};
 
 TEST_F(CertCompressorTest, EmptyChain) {
-  std::vector<QuicString> chain;
-  const QuicString compressed = CertCompressor::CompressChain(
+  std::vector<std::string> chain;
+  const std::string compressed = CertCompressor::CompressChain(
       chain, QuicStringPiece(), QuicStringPiece(), nullptr);
   EXPECT_EQ("00", QuicTextUtils::HexEncode(compressed));
 
-  std::vector<QuicString> chain2, cached_certs;
+  std::vector<std::string> chain2, cached_certs;
   ASSERT_TRUE(CertCompressor::DecompressChain(compressed, cached_certs, nullptr,
                                               &chain2));
   EXPECT_EQ(chain.size(), chain2.size());
 }
 
 TEST_F(CertCompressorTest, Compressed) {
-  std::vector<QuicString> chain;
+  std::vector<std::string> chain;
   chain.push_back("testcert");
-  const QuicString compressed = CertCompressor::CompressChain(
+  const std::string compressed = CertCompressor::CompressChain(
       chain, QuicStringPiece(), QuicStringPiece(), nullptr);
   ASSERT_GE(compressed.size(), 2u);
   EXPECT_EQ("0100", QuicTextUtils::HexEncode(compressed.substr(0, 2)));
 
-  std::vector<QuicString> chain2, cached_certs;
+  std::vector<std::string> chain2, cached_certs;
   ASSERT_TRUE(CertCompressor::DecompressChain(compressed, cached_certs, nullptr,
                                               &chain2));
   EXPECT_EQ(chain.size(), chain2.size());
@@ -45,12 +45,12 @@
 }
 
 TEST_F(CertCompressorTest, Common) {
-  std::vector<QuicString> chain;
+  std::vector<std::string> chain;
   chain.push_back("testcert");
   static const uint64_t set_hash = 42;
   std::unique_ptr<CommonCertSets> common_sets(
       crypto_test_utils::MockCommonCertSets(chain[0], set_hash, 1));
-  const QuicString compressed = CertCompressor::CompressChain(
+  const std::string compressed = CertCompressor::CompressChain(
       chain,
       QuicStringPiece(reinterpret_cast<const char*>(&set_hash),
                       sizeof(set_hash)),
@@ -62,7 +62,7 @@
       "00" /* end of list */,
       QuicTextUtils::HexEncode(compressed));
 
-  std::vector<QuicString> chain2, cached_certs;
+  std::vector<std::string> chain2, cached_certs;
   ASSERT_TRUE(CertCompressor::DecompressChain(compressed, cached_certs,
                                               common_sets.get(), &chain2));
   EXPECT_EQ(chain.size(), chain2.size());
@@ -70,18 +70,18 @@
 }
 
 TEST_F(CertCompressorTest, Cached) {
-  std::vector<QuicString> chain;
+  std::vector<std::string> chain;
   chain.push_back("testcert");
   uint64_t hash = QuicUtils::FNV1a_64_Hash(chain[0]);
   QuicStringPiece hash_bytes(reinterpret_cast<char*>(&hash), sizeof(hash));
-  const QuicString compressed = CertCompressor::CompressChain(
+  const std::string compressed = CertCompressor::CompressChain(
       chain, QuicStringPiece(), hash_bytes, nullptr);
 
   EXPECT_EQ("02" /* cached */ + QuicTextUtils::HexEncode(hash_bytes) +
                 "00" /* end of list */,
             QuicTextUtils::HexEncode(compressed));
 
-  std::vector<QuicString> cached_certs, chain2;
+  std::vector<std::string> cached_certs, chain2;
   cached_certs.push_back(chain[0]);
   ASSERT_TRUE(CertCompressor::DecompressChain(compressed, cached_certs, nullptr,
                                               &chain2));
@@ -90,7 +90,7 @@
 }
 
 TEST_F(CertCompressorTest, BadInputs) {
-  std::vector<QuicString> cached_certs, chain;
+  std::vector<std::string> cached_certs, chain;
 
   EXPECT_FALSE(CertCompressor::DecompressChain(
       QuicTextUtils::HexEncode("04") /* bad entry type */, cached_certs,
diff --git a/quic/core/crypto/chacha20_poly1305_decrypter_test.cc b/quic/core/crypto/chacha20_poly1305_decrypter_test.cc
index 5f5ae01..d1c8d74 100644
--- a/quic/core/crypto/chacha20_poly1305_decrypter_test.cc
+++ b/quic/core/crypto/chacha20_poly1305_decrypter_test.cc
@@ -141,12 +141,12 @@
     bool has_pt = test_vectors[i].pt;
 
     // Decode the test vector.
-    QuicString key = QuicTextUtils::HexDecode(test_vectors[i].key);
-    QuicString iv = QuicTextUtils::HexDecode(test_vectors[i].iv);
-    QuicString fixed = QuicTextUtils::HexDecode(test_vectors[i].fixed);
-    QuicString aad = QuicTextUtils::HexDecode(test_vectors[i].aad);
-    QuicString ct = QuicTextUtils::HexDecode(test_vectors[i].ct);
-    QuicString pt;
+    std::string key = QuicTextUtils::HexDecode(test_vectors[i].key);
+    std::string iv = QuicTextUtils::HexDecode(test_vectors[i].iv);
+    std::string fixed = QuicTextUtils::HexDecode(test_vectors[i].fixed);
+    std::string aad = QuicTextUtils::HexDecode(test_vectors[i].aad);
+    std::string ct = QuicTextUtils::HexDecode(test_vectors[i].ct);
+    std::string pt;
     if (has_pt) {
       pt = QuicTextUtils::HexDecode(test_vectors[i].pt);
     }
diff --git a/quic/core/crypto/chacha20_poly1305_encrypter_test.cc b/quic/core/crypto/chacha20_poly1305_encrypter_test.cc
index d8c27bf..05f8274 100644
--- a/quic/core/crypto/chacha20_poly1305_encrypter_test.cc
+++ b/quic/core/crypto/chacha20_poly1305_encrypter_test.cc
@@ -90,15 +90,15 @@
   ChaCha20Poly1305Encrypter encrypter;
   ChaCha20Poly1305Decrypter decrypter;
 
-  QuicString key = QuicTextUtils::HexDecode(test_vectors[0].key);
+  std::string key = QuicTextUtils::HexDecode(test_vectors[0].key);
   ASSERT_TRUE(encrypter.SetKey(key));
   ASSERT_TRUE(decrypter.SetKey(key));
   ASSERT_TRUE(encrypter.SetNoncePrefix("abcd"));
   ASSERT_TRUE(decrypter.SetNoncePrefix("abcd"));
 
   uint64_t packet_number = UINT64_C(0x123456789ABC);
-  QuicString associated_data = "associated_data";
-  QuicString plaintext = "plaintext";
+  std::string associated_data = "associated_data";
+  std::string plaintext = "plaintext";
   char encrypted[1024];
   size_t len;
   ASSERT_TRUE(encrypter.EncryptPacket(packet_number, associated_data, plaintext,
@@ -114,12 +114,12 @@
 TEST_F(ChaCha20Poly1305EncrypterTest, Encrypt) {
   for (size_t i = 0; test_vectors[i].key != nullptr; i++) {
     // Decode the test vector.
-    QuicString key = QuicTextUtils::HexDecode(test_vectors[i].key);
-    QuicString pt = QuicTextUtils::HexDecode(test_vectors[i].pt);
-    QuicString iv = QuicTextUtils::HexDecode(test_vectors[i].iv);
-    QuicString fixed = QuicTextUtils::HexDecode(test_vectors[i].fixed);
-    QuicString aad = QuicTextUtils::HexDecode(test_vectors[i].aad);
-    QuicString ct = QuicTextUtils::HexDecode(test_vectors[i].ct);
+    std::string key = QuicTextUtils::HexDecode(test_vectors[i].key);
+    std::string pt = QuicTextUtils::HexDecode(test_vectors[i].pt);
+    std::string iv = QuicTextUtils::HexDecode(test_vectors[i].iv);
+    std::string fixed = QuicTextUtils::HexDecode(test_vectors[i].fixed);
+    std::string aad = QuicTextUtils::HexDecode(test_vectors[i].aad);
+    std::string ct = QuicTextUtils::HexDecode(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 dd74539..664abe2 100644
--- a/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc
+++ b/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc
@@ -136,12 +136,12 @@
     bool has_pt = test_vectors[i].pt;
 
     // Decode the test vector.
-    QuicString key = QuicTextUtils::HexDecode(test_vectors[i].key);
-    QuicString iv = QuicTextUtils::HexDecode(test_vectors[i].iv);
-    QuicString fixed = QuicTextUtils::HexDecode(test_vectors[i].fixed);
-    QuicString aad = QuicTextUtils::HexDecode(test_vectors[i].aad);
-    QuicString ct = QuicTextUtils::HexDecode(test_vectors[i].ct);
-    QuicString pt;
+    std::string key = QuicTextUtils::HexDecode(test_vectors[i].key);
+    std::string iv = QuicTextUtils::HexDecode(test_vectors[i].iv);
+    std::string fixed = QuicTextUtils::HexDecode(test_vectors[i].fixed);
+    std::string aad = QuicTextUtils::HexDecode(test_vectors[i].aad);
+    std::string ct = QuicTextUtils::HexDecode(test_vectors[i].ct);
+    std::string pt;
     if (has_pt) {
       pt = QuicTextUtils::HexDecode(test_vectors[i].pt);
     }
diff --git a/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc b/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc
index 905472b..6ac4810 100644
--- a/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc
+++ b/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc
@@ -89,15 +89,15 @@
   ChaCha20Poly1305TlsEncrypter encrypter;
   ChaCha20Poly1305TlsDecrypter decrypter;
 
-  QuicString key = QuicTextUtils::HexDecode(test_vectors[0].key);
+  std::string key = QuicTextUtils::HexDecode(test_vectors[0].key);
   ASSERT_TRUE(encrypter.SetKey(key));
   ASSERT_TRUE(decrypter.SetKey(key));
   ASSERT_TRUE(encrypter.SetIV("abcdefghijkl"));
   ASSERT_TRUE(decrypter.SetIV("abcdefghijkl"));
 
   uint64_t packet_number = UINT64_C(0x123456789ABC);
-  QuicString associated_data = "associated_data";
-  QuicString plaintext = "plaintext";
+  std::string associated_data = "associated_data";
+  std::string plaintext = "plaintext";
   char encrypted[1024];
   size_t len;
   ASSERT_TRUE(encrypter.EncryptPacket(packet_number, associated_data, plaintext,
@@ -113,12 +113,12 @@
 TEST_F(ChaCha20Poly1305TlsEncrypterTest, Encrypt) {
   for (size_t i = 0; test_vectors[i].key != nullptr; i++) {
     // Decode the test vector.
-    QuicString key = QuicTextUtils::HexDecode(test_vectors[i].key);
-    QuicString pt = QuicTextUtils::HexDecode(test_vectors[i].pt);
-    QuicString iv = QuicTextUtils::HexDecode(test_vectors[i].iv);
-    QuicString fixed = QuicTextUtils::HexDecode(test_vectors[i].fixed);
-    QuicString aad = QuicTextUtils::HexDecode(test_vectors[i].aad);
-    QuicString ct = QuicTextUtils::HexDecode(test_vectors[i].ct);
+    std::string key = QuicTextUtils::HexDecode(test_vectors[i].key);
+    std::string pt = QuicTextUtils::HexDecode(test_vectors[i].pt);
+    std::string iv = QuicTextUtils::HexDecode(test_vectors[i].iv);
+    std::string fixed = QuicTextUtils::HexDecode(test_vectors[i].fixed);
+    std::string aad = QuicTextUtils::HexDecode(test_vectors[i].aad);
+    std::string ct = QuicTextUtils::HexDecode(test_vectors[i].ct);
 
     ChaCha20Poly1305TlsEncrypter encrypter;
     ASSERT_TRUE(encrypter.SetKey(key));
diff --git a/quic/core/crypto/channel_id.h b/quic/core/crypto/channel_id.h
index a6c8de5..d94293c 100644
--- a/quic/core/crypto/channel_id.h
+++ b/quic/core/crypto/channel_id.h
@@ -24,10 +24,10 @@
   // Sign signs |signed_data| using the ChannelID private key and puts the
   // signature into |out_signature|. It returns true on success.
   virtual bool Sign(QuicStringPiece signed_data,
-                    QuicString* out_signature) const = 0;
+                    std::string* out_signature) const = 0;
 
   // SerializeKey returns the serialized ChannelID public key.
-  virtual QuicString SerializeKey() const = 0;
+  virtual std::string SerializeKey() const = 0;
 };
 
 // ChannelIDSourceCallback provides a generic mechanism for a ChannelIDSource
@@ -58,7 +58,7 @@
   // when complete. In this case, the ChannelIDSource will take ownership of
   // |callback|.
   virtual QuicAsyncStatus GetChannelIDKey(
-      const QuicString& hostname,
+      const std::string& hostname,
       std::unique_ptr<ChannelIDKey>* channel_id_key,
       ChannelIDSourceCallback* callback) = 0;
 };
diff --git a/quic/core/crypto/channel_id_test.cc b/quic/core/crypto/channel_id_test.cc
index 3e03580..d904bcb 100644
--- a/quic/core/crypto/channel_id_test.cc
+++ b/quic/core/crypto/channel_id_test.cc
@@ -286,17 +286,17 @@
   std::unique_ptr<ChannelIDSource> source(
       crypto_test_utils::ChannelIDSourceForTesting());
 
-  const QuicString signed_data = "signed data";
-  const QuicString hostname = "foo.example.com";
+  const std::string signed_data = "signed data";
+  const std::string hostname = "foo.example.com";
   std::unique_ptr<ChannelIDKey> channel_id_key;
   QuicAsyncStatus status =
       source->GetChannelIDKey(hostname, &channel_id_key, nullptr);
   ASSERT_EQ(QUIC_SUCCESS, status);
 
-  QuicString signature;
+  std::string signature;
   ASSERT_TRUE(channel_id_key->Sign(signed_data, &signature));
 
-  QuicString key = channel_id_key->SerializeKey();
+  std::string key = channel_id_key->SerializeKey();
   EXPECT_TRUE(ChannelIDVerifier::Verify(key, signed_data, signature));
 
   EXPECT_FALSE(ChannelIDVerifier::Verify("a" + key, signed_data, signature));
@@ -305,14 +305,14 @@
   std::unique_ptr<char[]> bad_key(new char[key.size()]);
   memcpy(bad_key.get(), key.data(), key.size());
   bad_key[1] ^= 0x80;
-  EXPECT_FALSE(ChannelIDVerifier::Verify(QuicString(bad_key.get(), key.size()),
+  EXPECT_FALSE(ChannelIDVerifier::Verify(std::string(bad_key.get(), key.size()),
                                          signed_data, signature));
 
   std::unique_ptr<char[]> bad_signature(new char[signature.size()]);
   memcpy(bad_signature.get(), signature.data(), signature.size());
   bad_signature[1] ^= 0x80;
   EXPECT_FALSE(ChannelIDVerifier::Verify(
-      key, signed_data, QuicString(bad_signature.get(), signature.size())));
+      key, signed_data, std::string(bad_signature.get(), signature.size())));
 
   EXPECT_FALSE(ChannelIDVerifier::Verify(key, "wrong signed data", signature));
 }
diff --git a/quic/core/crypto/crypto_framer.cc b/quic/core/crypto/crypto_framer.cc
index dfd9eab..d8a32bc 100644
--- a/quic/core/crypto/crypto_framer.cc
+++ b/quic/core/crypto/crypto_framer.cc
@@ -75,7 +75,7 @@
   return error_;
 }
 
-const QuicString& CryptoFramer::error_detail() const {
+const std::string& CryptoFramer::error_detail() const {
   return error_detail_;
 }
 
@@ -329,7 +329,7 @@
       break;
   }
   // Save any remaining data.
-  buffer_ = QuicString(reader.PeekRemainingPayload());
+  buffer_ = std::string(reader.PeekRemainingPayload());
   return QUIC_NO_ERROR;
 }
 
diff --git a/quic/core/crypto/crypto_framer.h b/quic/core/crypto/crypto_framer.h
index e83e6a6..34234e2 100644
--- a/quic/core/crypto/crypto_framer.h
+++ b/quic/core/crypto/crypto_framer.h
@@ -58,7 +58,7 @@
   }
 
   QuicErrorCode error() const override;
-  const QuicString& error_detail() const override;
+  const std::string& error_detail() const override;
 
   // Processes input data, which must be delivered in order. Returns
   // false if there was an error, and true otherwise. ProcessInput optionally
@@ -115,13 +115,13 @@
   // Last error.
   QuicErrorCode error_;
   // Remaining unparsed data.
-  QuicString buffer_;
+  std::string buffer_;
   // Current state of the parsing.
   CryptoFramerState state_;
   // The message currently being parsed.
   CryptoHandshakeMessage message_;
   // The issue which caused |error_|
-  QuicString error_detail_;
+  std::string error_detail_;
   // Number of entires in the message currently being parsed.
   uint16_t num_entries_;
   // tags_and_lengths_ contains the tags that are currently being parsed and
diff --git a/quic/core/crypto/crypto_handshake.h b/quic/core/crypto/crypto_handshake.h
index 9b148c8..1e3d668 100644
--- a/quic/core/crypto/crypto_handshake.h
+++ b/quic/core/crypto/crypto_handshake.h
@@ -104,28 +104,28 @@
 
   QuicTag key_exchange;
   QuicTag aead;
-  QuicString initial_premaster_secret;
-  QuicString forward_secure_premaster_secret;
+  std::string initial_premaster_secret;
+  std::string forward_secure_premaster_secret;
   // initial_subkey_secret is used as the PRK input to the HKDF used when
   // performing key extraction that needs to happen before forward-secure keys
   // are available.
-  QuicString initial_subkey_secret;
+  std::string initial_subkey_secret;
   // subkey_secret is used as the PRK input to the HKDF used for key extraction.
-  QuicString subkey_secret;
+  std::string subkey_secret;
   CrypterPair initial_crypters;
   CrypterPair forward_secure_crypters;
   // Normalized SNI: converted to lower case and trailing '.' removed.
-  QuicString sni;
-  QuicString client_nonce;
-  QuicString server_nonce;
+  std::string sni;
+  std::string client_nonce;
+  std::string server_nonce;
   // hkdf_input_suffix contains the HKDF input following the label: the
   // ConnectionId, client hello and server config. This is only populated in the
   // client because only the client needs to derive the forward secure keys at a
   // later time from the initial keys.
-  QuicString hkdf_input_suffix;
+  std::string hkdf_input_suffix;
   // cached_certs contains the cached certificates that a client used when
   // sending a client hello.
-  std::vector<QuicString> cached_certs;
+  std::vector<std::string> cached_certs;
   // client_key_exchange is used by clients to store the ephemeral KeyExchange
   // for the connection.
   std::unique_ptr<KeyExchange> client_key_exchange;
@@ -133,14 +133,14 @@
   // proves possession of the corresponding private key. It consists of 32
   // bytes of x coordinate, followed by 32 bytes of y coordinate. Both values
   // are big-endian and the pair is a P-256 public key.
-  QuicString channel_id;
+  std::string channel_id;
   QuicTag token_binding_key_param;
 
   // Used when generating proof signature when sending server config updates.
 
   // Used to generate cert chain when sending server config updates.
-  QuicString client_common_set_hashes;
-  QuicString client_cached_cert_hashes;
+  std::string client_common_set_hashes;
+  std::string client_cached_cert_hashes;
 
   // Default to false; set to true if the client indicates that it supports sct
   // by sending CSCT tag with an empty value in client hello.
diff --git a/quic/core/crypto/crypto_handshake_message.cc b/quic/core/crypto/crypto_handshake_message.cc
index a057254..46577b3 100644
--- a/quic/core/crypto/crypto_handshake_message.cc
+++ b/quic/core/crypto/crypto_handshake_message.cc
@@ -85,7 +85,7 @@
 
 void CryptoHandshakeMessage::SetStringPiece(QuicTag tag,
                                             QuicStringPiece value) {
-  tag_value_map_[tag] = QuicString(value);
+  tag_value_map_[tag] = std::string(value);
 }
 
 void CryptoHandshakeMessage::Erase(QuicTag tag) {
@@ -236,7 +236,7 @@
   return minimum_size_;
 }
 
-QuicString CryptoHandshakeMessage::DebugString() const {
+std::string CryptoHandshakeMessage::DebugString() const {
   return DebugStringInternal(0);
 }
 
@@ -261,11 +261,12 @@
   return ret;
 }
 
-QuicString CryptoHandshakeMessage::DebugStringInternal(size_t indent) const {
-  QuicString ret = QuicString(2 * indent, ' ') + QuicTagToString(tag_) + "<\n";
+std::string CryptoHandshakeMessage::DebugStringInternal(size_t indent) const {
+  std::string ret =
+      std::string(2 * indent, ' ') + QuicTagToString(tag_) + "<\n";
   ++indent;
   for (auto it = tag_value_map_.begin(); it != tag_value_map_.end(); ++it) {
-    ret += QuicString(2 * indent, ' ') + QuicTagToString(it->first) + ": ";
+    ret += std::string(2 * indent, ' ') + QuicTagToString(it->first) + ": ";
 
     bool done = false;
     switch (it->first) {
@@ -371,7 +372,7 @@
     ret += "\n";
   }
   --indent;
-  ret += QuicString(2 * indent, ' ') + ">";
+  ret += std::string(2 * indent, ' ') + ">";
   return ret;
 }
 
diff --git a/quic/core/crypto/crypto_handshake_message.h b/quic/core/crypto/crypto_handshake_message.h
index 1f6e8b6..8a75436 100644
--- a/quic/core/crypto/crypto_handshake_message.h
+++ b/quic/core/crypto/crypto_handshake_message.h
@@ -45,7 +45,7 @@
   template <class T>
   void SetValue(QuicTag tag, const T& v) {
     tag_value_map_[tag] =
-        QuicString(reinterpret_cast<const char*>(&v), sizeof(v));
+        std::string(reinterpret_cast<const char*>(&v), sizeof(v));
   }
 
   // SetVector sets an element with the given tag to the raw contents of an
@@ -53,10 +53,10 @@
   template <class T>
   void SetVector(QuicTag tag, const std::vector<T>& v) {
     if (v.empty()) {
-      tag_value_map_[tag] = QuicString();
+      tag_value_map_[tag] = std::string();
     } else {
-      tag_value_map_[tag] = QuicString(reinterpret_cast<const char*>(&v[0]),
-                                       v.size() * sizeof(T));
+      tag_value_map_[tag] = std::string(reinterpret_cast<const char*>(&v[0]),
+                                        v.size() * sizeof(T));
     }
   }
 
@@ -126,7 +126,7 @@
 
   // DebugString returns a multi-line, string representation of the message
   // suitable for including in debug output.
-  QuicString DebugString() const;
+  std::string DebugString() const;
 
  private:
   // GetPOD is a utility function for extracting a plain-old-data value. If
@@ -138,7 +138,7 @@
   // little-endian.
   QuicErrorCode GetPOD(QuicTag tag, void* out, size_t len) const;
 
-  QuicString DebugStringInternal(size_t indent) const;
+  std::string DebugStringInternal(size_t indent) const;
 
   QuicTag tag_;
   QuicTagValueMap tag_value_map_;
diff --git a/quic/core/crypto/crypto_message_parser.h b/quic/core/crypto/crypto_message_parser.h
index 8b9fa4a..3c70e6e 100644
--- a/quic/core/crypto/crypto_message_parser.h
+++ b/quic/core/crypto/crypto_message_parser.h
@@ -17,7 +17,7 @@
   virtual ~CryptoMessageParser() {}
 
   virtual QuicErrorCode error() const = 0;
-  virtual const QuicString& error_detail() const = 0;
+  virtual const std::string& error_detail() const = 0;
 
   // Processes input data, which must be delivered in order. The input data
   // being processed was received at encryption level |level|. Returns
diff --git a/quic/core/crypto/crypto_message_printer_bin.cc b/quic/core/crypto/crypto_message_printer_bin.cc
index f14abb0..66fa7e4 100644
--- a/quic/core/crypto/crypto_message_printer_bin.cc
+++ b/quic/core/crypto/crypto_message_printer_bin.cc
@@ -16,7 +16,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
 
 using quic::Perspective;
-using quic::QuicString;
 using std::cerr;
 using std::cout;
 using std::endl;
@@ -44,7 +43,7 @@
   quic::CryptoFramer framer;
   framer.set_visitor(&printer);
   framer.set_process_truncated_messages(true);
-  QuicString input = quic::QuicTextUtils::HexDecode(argv[1]);
+  std::string input = quic::QuicTextUtils::HexDecode(argv[1]);
   if (!framer.ProcessInput(input)) {
     return 1;
   }
diff --git a/quic/core/crypto/crypto_protocol.h b/quic/core/crypto/crypto_protocol.h
index e5a4048..d3304ba 100644
--- a/quic/core/crypto/crypto_protocol.h
+++ b/quic/core/crypto/crypto_protocol.h
@@ -24,7 +24,7 @@
 
 namespace quic {
 
-typedef QuicString ServerConfigID;
+typedef std::string ServerConfigID;
 
 // clang-format off
 const QuicTag kCHLO = TAG('C', 'H', 'L', 'O');   // Client hello
diff --git a/quic/core/crypto/crypto_secret_boxer.cc b/quic/core/crypto/crypto_secret_boxer.cc
index ada12ad..16e9d0c 100644
--- a/quic/core/crypto/crypto_secret_boxer.cc
+++ b/quic/core/crypto/crypto_secret_boxer.cc
@@ -43,12 +43,12 @@
 // kAEAD is the AEAD used for boxing: AES-256-GCM-SIV.
 static const EVP_AEAD* (*const kAEAD)() = EVP_aead_aes_256_gcm_siv;
 
-void CryptoSecretBoxer::SetKeys(const std::vector<QuicString>& keys) {
+void CryptoSecretBoxer::SetKeys(const std::vector<std::string>& keys) {
   DCHECK(!keys.empty());
   const EVP_AEAD* const aead = kAEAD();
   std::unique_ptr<State> new_state(new State);
 
-  for (const QuicString& key : keys) {
+  for (const std::string& key : keys) {
     DCHECK_EQ(kBoxKeySize, key.size());
     bssl::UniquePtr<EVP_AEAD_CTX> ctx(
         EVP_AEAD_CTX_new(aead, reinterpret_cast<const uint8_t*>(key.data()),
@@ -66,8 +66,8 @@
   state_ = std::move(new_state);
 }
 
-QuicString CryptoSecretBoxer::Box(QuicRandom* rand,
-                                  QuicStringPiece plaintext) const {
+std::string CryptoSecretBoxer::Box(QuicRandom* rand,
+                                   QuicStringPiece plaintext) const {
   // The box is formatted as:
   //   12 bytes of random nonce
   //   n bytes of ciphertext
@@ -75,7 +75,7 @@
   size_t out_len =
       kSIVNonceSize + plaintext.size() + EVP_AEAD_max_overhead(kAEAD());
 
-  QuicString ret;
+  std::string ret;
   ret.resize(out_len);
   uint8_t* out = reinterpret_cast<uint8_t*>(const_cast<char*>(ret.data()));
 
@@ -104,7 +104,7 @@
 }
 
 bool CryptoSecretBoxer::Unbox(QuicStringPiece in_ciphertext,
-                              QuicString* out_storage,
+                              std::string* out_storage,
                               QuicStringPiece* out) const {
   if (in_ciphertext.size() < kSIVNonceSize) {
     return false;
diff --git a/quic/core/crypto/crypto_secret_boxer.h b/quic/core/crypto/crypto_secret_boxer.h
index de470b1..13e0469 100644
--- a/quic/core/crypto/crypto_secret_boxer.h
+++ b/quic/core/crypto/crypto_secret_boxer.h
@@ -36,13 +36,13 @@
   // used by |Box|, but all supplied keys will be tried by |Unbox|, to handle
   // key skew across the fleet. This must be called before |Box| or |Unbox|.
   // Keys must be |GetKeySize()| bytes long.
-  void SetKeys(const std::vector<QuicString>& keys);
+  void SetKeys(const std::vector<std::string>& keys);
 
   // Box encrypts |plaintext| using a random nonce generated from |rand| and
   // returns the resulting ciphertext. Since an authenticator and nonce are
   // included, the result will be slightly larger than |plaintext|. The first
   // key in the vector supplied to |SetKeys| will be used.
-  QuicString Box(QuicRandom* rand, QuicStringPiece plaintext) const;
+  std::string Box(QuicRandom* rand, QuicStringPiece plaintext) const;
 
   // Unbox takes the result of a previous call to |Box| in |ciphertext| and
   // authenticates+decrypts it. If |ciphertext| cannot be decrypted with any of
@@ -50,7 +50,7 @@
   // used to store the result and |out| is set to point into |out_storage| and
   // contains the original plaintext.
   bool Unbox(QuicStringPiece ciphertext,
-             QuicString* out_storage,
+             std::string* out_storage,
              QuicStringPiece* out) const;
 
  private:
diff --git a/quic/core/crypto/crypto_secret_boxer_test.cc b/quic/core/crypto/crypto_secret_boxer_test.cc
index d060051..8739977 100644
--- a/quic/core/crypto/crypto_secret_boxer_test.cc
+++ b/quic/core/crypto/crypto_secret_boxer_test.cc
@@ -17,29 +17,30 @@
   QuicStringPiece message("hello world");
 
   CryptoSecretBoxer boxer;
-  boxer.SetKeys({QuicString(CryptoSecretBoxer::GetKeySize(), 0x11)});
+  boxer.SetKeys({std::string(CryptoSecretBoxer::GetKeySize(), 0x11)});
 
-  const QuicString box = boxer.Box(QuicRandom::GetInstance(), message);
+  const std::string box = boxer.Box(QuicRandom::GetInstance(), message);
 
-  QuicString storage;
+  std::string storage;
   QuicStringPiece result;
   EXPECT_TRUE(boxer.Unbox(box, &storage, &result));
   EXPECT_EQ(result, message);
 
-  EXPECT_FALSE(boxer.Unbox(QuicString(1, 'X') + box, &storage, &result));
-  EXPECT_FALSE(boxer.Unbox(box.substr(1, QuicString::npos), &storage, &result));
-  EXPECT_FALSE(boxer.Unbox(QuicString(), &storage, &result));
+  EXPECT_FALSE(boxer.Unbox(std::string(1, 'X') + box, &storage, &result));
+  EXPECT_FALSE(
+      boxer.Unbox(box.substr(1, std::string::npos), &storage, &result));
+  EXPECT_FALSE(boxer.Unbox(std::string(), &storage, &result));
   EXPECT_FALSE(boxer.Unbox(
-      QuicString(1, box[0] ^ 0x80) + box.substr(1, QuicString::npos), &storage,
-      &result));
+      std::string(1, box[0] ^ 0x80) + box.substr(1, std::string::npos),
+      &storage, &result));
 }
 
 // Helper function to test whether one boxer can decode the output of another.
 static bool CanDecode(const CryptoSecretBoxer& decoder,
                       const CryptoSecretBoxer& encoder) {
   QuicStringPiece message("hello world");
-  const QuicString boxed = encoder.Box(QuicRandom::GetInstance(), message);
-  QuicString storage;
+  const std::string boxed = encoder.Box(QuicRandom::GetInstance(), message);
+  std::string storage;
   QuicStringPiece result;
   bool ok = decoder.Unbox(boxed, &storage, &result);
   if (ok) {
@@ -49,8 +50,8 @@
 }
 
 TEST_F(CryptoSecretBoxerTest, MultipleKeys) {
-  QuicString key_11(CryptoSecretBoxer::GetKeySize(), 0x11);
-  QuicString key_12(CryptoSecretBoxer::GetKeySize(), 0x12);
+  std::string key_11(CryptoSecretBoxer::GetKeySize(), 0x11);
+  std::string key_12(CryptoSecretBoxer::GetKeySize(), 0x12);
 
   CryptoSecretBoxer boxer_11, boxer_12, boxer;
   boxer_11.SetKeys({key_11});
diff --git a/quic/core/crypto/crypto_server_test.cc b/quic/core/crypto/crypto_server_test.cc
index 11615c2..b6740e9 100644
--- a/quic/core/crypto/crypto_server_test.cc
+++ b/quic/core/crypto/crypto_server_test.cc
@@ -46,7 +46,7 @@
   ~DummyProofVerifierCallback() override {}
 
   void Run(bool ok,
-           const QuicString& error_details,
+           const std::string& error_details,
            std::unique_ptr<ProofVerifyDetails>* details) override {
     DCHECK(false);
   }
@@ -279,7 +279,7 @@
 
     void Run(
         QuicErrorCode error,
-        const QuicString& error_details,
+        const std::string& error_details,
         std::unique_ptr<CryptoHandshakeMessage> message,
         std::unique_ptr<DiversificationNonce> diversification_nonce,
         std::unique_ptr<ProofSource::Details> proof_source_details) override {
@@ -291,7 +291,7 @@
         ASSERT_NE(error, QUIC_NO_ERROR)
             << "Message didn't fail: " << result_->client_hello.DebugString();
 
-        EXPECT_TRUE(error_details.find(error_substr_) != QuicString::npos)
+        EXPECT_TRUE(error_details.find(error_substr_) != std::string::npos)
             << error_substr_ << " not in " << error_details;
       }
       if (message != nullptr) {
@@ -328,8 +328,8 @@
     EXPECT_TRUE(called);
   }
 
-  QuicString GenerateNonce() {
-    QuicString nonce;
+  std::string GenerateNonce() {
+    std::string nonce;
     CryptoUtils::GenerateNonce(
         clock_.WallNow(), rand_,
         QuicStringPiece(reinterpret_cast<const char*>(orbit_), sizeof(orbit_)),
@@ -384,7 +384,7 @@
            GetParam().use_stateless_rejects;
   }
 
-  QuicString XlctHexString() {
+  std::string XlctHexString() {
     uint64_t xlct = crypto_test_utils::LeafCertHashForTesting();
     return "#" + QuicTextUtils::HexEncode(reinterpret_cast<char*>(&xlct),
                                           sizeof(xlct));
@@ -397,7 +397,7 @@
   QuicSocketAddress client_address_;
   ParsedQuicVersionVector supported_versions_;
   ParsedQuicVersion client_version_;
-  QuicString client_version_string_;
+  std::string client_version_string_;
   QuicCryptoServerConfig config_;
   QuicCryptoServerConfigPeer peer_;
   QuicCompressedCertsCache compressed_certs_cache_;
@@ -411,11 +411,12 @@
 
   // These strings contain hex escaped values from the server suitable for using
   // when constructing client hello messages.
-  QuicString nonce_hex_, pub_hex_, srct_hex_, scid_hex_;
+  std::string nonce_hex_, pub_hex_, srct_hex_, scid_hex_;
   std::unique_ptr<CryptoHandshakeMessage> server_config_;
 };
 
-INSTANTIATE_TEST_SUITE_P(CryptoServerTests, CryptoServerTest,
+INSTANTIATE_TEST_SUITE_P(CryptoServerTests,
+                         CryptoServerTest,
                          ::testing::ValuesIn(GetTestParams()));
 
 TEST_P(CryptoServerTest, BadSNI) {
@@ -669,7 +670,7 @@
   }
   // Set the client's preferred version to a supported version that
   // is not the "current" version (supported_versions_.front()).
-  QuicString bad_version =
+  std::string bad_version =
       ParsedQuicVersionToString(supported_versions_.back());
 
   CryptoHandshakeMessage msg = crypto_test_utils::CreateCHLO(
@@ -683,16 +684,16 @@
 
 TEST_P(CryptoServerTest, CorruptServerConfig) {
   // This tests corrupted server config.
-  CryptoHandshakeMessage msg =
-      crypto_test_utils::CreateCHLO({{"PDMD", "X509"},
-                                     {"AEAD", "AESG"},
-                                     {"KEXS", "C255"},
-                                     {"SCID", (QuicString(1, 'X') + scid_hex_)},
-                                     {"#004b5453", srct_hex_},
-                                     {"PUBS", pub_hex_},
-                                     {"NONC", nonce_hex_},
-                                     {"VER\0", client_version_string_}},
-                                    kClientHelloMinimumSize);
+  CryptoHandshakeMessage msg = crypto_test_utils::CreateCHLO(
+      {{"PDMD", "X509"},
+       {"AEAD", "AESG"},
+       {"KEXS", "C255"},
+       {"SCID", (std::string(1, 'X') + scid_hex_)},
+       {"#004b5453", srct_hex_},
+       {"PUBS", pub_hex_},
+       {"NONC", nonce_hex_},
+       {"VER\0", client_version_string_}},
+      kClientHelloMinimumSize);
 
   ShouldSucceed(msg);
   CheckRejectTag();
@@ -708,7 +709,7 @@
        {"AEAD", "AESG"},
        {"KEXS", "C255"},
        {"SCID", scid_hex_},
-       {"#004b5453", (QuicString(1, 'X') + srct_hex_)},
+       {"#004b5453", (std::string(1, 'X') + srct_hex_)},
        {"PUBS", pub_hex_},
        {"NONC", nonce_hex_},
        {"XLCT", XlctHexString()},
@@ -729,7 +730,7 @@
        {"AEAD", "AESG"},
        {"KEXS", "C255"},
        {"SCID", scid_hex_},
-       {"#004b5453", (QuicString(1, 'X') + srct_hex_)},
+       {"#004b5453", (std::string(1, 'X') + srct_hex_)},
        {"PUBS", pub_hex_},
        {"NONC", nonce_hex_},
        {"XLCT", XlctHexString()},
@@ -749,9 +750,9 @@
        {"AEAD", "AESG"},
        {"KEXS", "C255"},
        {"SCID", scid_hex_},
-       {"#004b5453", (QuicString(1, 'X') + srct_hex_)},
+       {"#004b5453", (std::string(1, 'X') + srct_hex_)},
        {"PUBS", pub_hex_},
-       {"NONC", (QuicString(1, 'X') + nonce_hex_)},
+       {"NONC", (std::string(1, 'X') + nonce_hex_)},
        {"XLCT", XlctHexString()},
        {"VER\0", client_version_string_}},
       kClientHelloMinimumSize);
@@ -770,11 +771,11 @@
        {"AEAD", "AESG"},
        {"KEXS", "C255"},
        {"SCID", scid_hex_},
-       {"#004b5453", (QuicString(1, 'X') + srct_hex_)},
+       {"#004b5453", (std::string(1, 'X') + srct_hex_)},
        {"PUBS", pub_hex_},
-       {"NONC", (QuicString(1, 'X') + nonce_hex_)},
-       {"NONP", (QuicString(1, 'X') + nonce_hex_)},
-       {"SNO\0", (QuicString(1, 'X') + nonce_hex_)},
+       {"NONC", (std::string(1, 'X') + nonce_hex_)},
+       {"NONP", (std::string(1, 'X') + nonce_hex_)},
+       {"SNO\0", (std::string(1, 'X') + nonce_hex_)},
        {"XLCT", XlctHexString()},
        {"VER\0", client_version_string_}},
       kClientHelloMinimumSize);
@@ -847,9 +848,9 @@
 
   // Get certs from compressed certs.
   const CommonCertSets* common_cert_sets(CommonCertSets::GetInstanceQUIC());
-  std::vector<QuicString> cached_certs;
+  std::vector<std::string> cached_certs;
 
-  std::vector<QuicString> certs;
+  std::vector<std::string> certs;
   ASSERT_TRUE(CertCompressor::DecompressChain(cert, cached_certs,
                                               common_cert_sets, &certs));
 
@@ -859,16 +860,16 @@
   std::unique_ptr<ProofVerifyContext> verify_context(
       crypto_test_utils::ProofVerifyContextForTesting());
   std::unique_ptr<ProofVerifyDetails> details;
-  QuicString error_details;
+  std::string error_details;
   std::unique_ptr<ProofVerifierCallback> callback(
       new DummyProofVerifierCallback());
-  QuicString chlo_hash;
+  std::string chlo_hash;
   CryptoUtils::HashHandshakeMessage(msg, &chlo_hash, Perspective::IS_SERVER);
   EXPECT_EQ(QUIC_SUCCESS,
             proof_verifier->VerifyProof(
-                "test.example.com", 443, (QuicString(scfg_str)),
+                "test.example.com", 443, (std::string(scfg_str)),
                 client_version_.transport_version, chlo_hash, certs, "",
-                (QuicString(proof)), verify_context.get(), &error_details,
+                (std::string(proof)), verify_context.get(), &error_details,
                 &details, std::move(callback)));
 }
 
@@ -980,7 +981,7 @@
   QuicStringPiece certs_compressed;
   ASSERT_TRUE(out_.GetStringPiece(kCertificateTag, &certs_compressed));
   ASSERT_NE(0u, certs_compressed.size());
-  std::vector<QuicString> certs;
+  std::vector<std::string> certs;
   ASSERT_TRUE(CertCompressor::DecompressChain(
       certs_compressed, /*cached_certs=*/{}, /*common_sets=*/nullptr, &certs));
 
@@ -1084,7 +1085,7 @@
   QuicStringPiece scid;
   EXPECT_TRUE(scfg->GetStringPiece(kSCID, &scid));
   // Need to take a copy of |scid| has we're about to call |Erase|.
-  const QuicString scid_str(scid);
+  const std::string scid_str(scid);
 
   scfg->Erase(kSCID);
   scfg->MarkDirty();
diff --git a/quic/core/crypto/crypto_utils.cc b/quic/core/crypto/crypto_utils.cc
index 4f6a61d..ff682b3 100644
--- a/quic/core/crypto/crypto_utils.cc
+++ b/quic/core/crypto/crypto_utils.cc
@@ -37,7 +37,7 @@
 std::vector<uint8_t> CryptoUtils::HkdfExpandLabel(
     const EVP_MD* prf,
     const std::vector<uint8_t>& secret,
-    const QuicString& label,
+    const std::string& label,
     size_t out_len) {
   bssl::ScopedCBB quic_hkdf_label;
   CBB inner_label;
@@ -115,9 +115,9 @@
       << "HKDF_extract failed when creating initial crypters";
   handshake_secret.resize(handshake_secret_len);
 
-  const QuicString client_label = "client in";
-  const QuicString server_label = "server in";
-  QuicString encryption_label, decryption_label;
+  const std::string client_label = "client in";
+  const std::string server_label = "server in";
+  std::string encryption_label, decryption_label;
   if (perspective == Perspective::IS_CLIENT) {
     encryption_label = client_label;
     decryption_label = server_label;
@@ -140,7 +140,7 @@
 void CryptoUtils::GenerateNonce(QuicWallTime now,
                                 QuicRandom* random_generator,
                                 QuicStringPiece orbit,
-                                QuicString* nonce) {
+                                std::string* nonce) {
   // a 4-byte timestamp + 28 random bytes.
   nonce->reserve(kNonceSize);
   nonce->resize(kNonceSize);
@@ -169,11 +169,11 @@
                              QuicStringPiece client_nonce,
                              QuicStringPiece server_nonce,
                              QuicStringPiece pre_shared_key,
-                             const QuicString& hkdf_input,
+                             const std::string& hkdf_input,
                              Perspective perspective,
                              Diversification diversification,
                              CrypterPair* crypters,
-                             QuicString* subkey_secret) {
+                             std::string* subkey_secret) {
   // If the connection is using PSK, concatenate it with the pre-master secret.
   std::unique_ptr<char[]> psk_premaster_secret;
   if (!pre_shared_key.empty()) {
@@ -207,9 +207,9 @@
       subkey_secret == nullptr ? 0 : premaster_secret.length();
 
   QuicStringPiece nonce = client_nonce;
-  QuicString nonce_storage;
+  std::string nonce_storage;
   if (!server_nonce.empty()) {
-    nonce_storage = QuicString(client_nonce) + QuicString(server_nonce);
+    nonce_storage = std::string(client_nonce) + std::string(server_nonce);
     nonce = nonce_storage;
   }
 
@@ -259,7 +259,7 @@
         return false;
       }
 
-      QuicString key, nonce_prefix;
+      std::string key, nonce_prefix;
       QuicDecrypter::DiversifyPreliminaryKey(
           hkdf.server_write_key(), hkdf.server_write_iv(),
           *diversification.nonce(), key_bytes, nonce_prefix_bytes, &key,
@@ -277,7 +277,7 @@
   }
 
   if (subkey_secret != nullptr) {
-    *subkey_secret = QuicString(hkdf.subkey_secret());
+    *subkey_secret = std::string(hkdf.subkey_secret());
   }
 
   return true;
@@ -288,7 +288,7 @@
                                        QuicStringPiece label,
                                        QuicStringPiece context,
                                        size_t result_len,
-                                       QuicString* result) {
+                                       std::string* result) {
   for (size_t i = 0; i < label.length(); i++) {
     if (label[i] == '\0') {
       QUIC_LOG(ERROR) << "ExportKeyingMaterial label may not contain NULs";
@@ -301,14 +301,14 @@
     return false;
   }
   uint32_t context_length = static_cast<uint32_t>(context.length());
-  QuicString info = QuicString(label);
+  std::string info = std::string(label);
   info.push_back('\0');
   info.append(reinterpret_cast<char*>(&context_length), sizeof(context_length));
   info.append(context.data(), context.length());
 
   QuicHKDF hkdf(subkey_secret, QuicStringPiece() /* no salt */, info,
                 result_len, 0 /* no fixed IV */, 0 /* no subkey secret */);
-  *result = QuicString(hkdf.client_write_key());
+  *result = std::string(hkdf.client_write_key());
   return true;
 }
 
@@ -320,7 +320,7 @@
 QuicErrorCode CryptoUtils::ValidateServerHello(
     const CryptoHandshakeMessage& server_hello,
     const ParsedQuicVersionVector& negotiated_versions,
-    QuicString* error_details) {
+    std::string* error_details) {
   DCHECK(error_details != nullptr);
 
   if (server_hello.tag() != kSHLO) {
@@ -342,7 +342,7 @@
 QuicErrorCode CryptoUtils::ValidateServerHelloVersions(
     const QuicVersionLabelVector& server_versions,
     const ParsedQuicVersionVector& negotiated_versions,
-    QuicString* error_details) {
+    std::string* error_details) {
   if (!negotiated_versions.empty()) {
     bool mismatch = server_versions.size() != negotiated_versions.size();
     for (size_t i = 0; i < server_versions.size() && !mismatch; ++i) {
@@ -368,7 +368,7 @@
     const CryptoHandshakeMessage& client_hello,
     ParsedQuicVersion version,
     const ParsedQuicVersionVector& supported_versions,
-    QuicString* error_details) {
+    std::string* error_details) {
   if (client_hello.tag() != kCHLO) {
     *error_details = "Bad tag";
     return QUIC_INVALID_CRYPTO_MESSAGE_TYPE;
@@ -392,7 +392,7 @@
     QuicVersionLabel client_version,
     ParsedQuicVersion connection_version,
     const ParsedQuicVersionVector& supported_versions,
-    QuicString* error_details) {
+    std::string* error_details) {
   if (client_version != CreateQuicVersionLabel(connection_version)) {
     // Check to see if |client_version| is actually on the supported versions
     // list. If not, the server doesn't support that version and it's not a
@@ -456,7 +456,7 @@
 
 // static
 void CryptoUtils::HashHandshakeMessage(const CryptoHandshakeMessage& message,
-                                       QuicString* output,
+                                       std::string* output,
                                        Perspective perspective) {
   const QuicData& serialized = message.GetSerialized();
   uint8_t digest[SHA256_DIGEST_LENGTH];
diff --git a/quic/core/crypto/crypto_utils.h b/quic/core/crypto/crypto_utils.h
index 511bae9..f340bf4 100644
--- a/quic/core/crypto/crypto_utils.h
+++ b/quic/core/crypto/crypto_utils.h
@@ -101,7 +101,7 @@
   static void GenerateNonce(QuicWallTime now,
                             QuicRandom* random_generator,
                             QuicStringPiece orbit,
-                            QuicString* nonce);
+                            std::string* nonce);
 
   // DeriveKeys populates |crypters->encrypter|, |crypters->decrypter|, and
   // |subkey_secret| (optional -- may be null) given the contents of
@@ -127,11 +127,11 @@
                          QuicStringPiece client_nonce,
                          QuicStringPiece server_nonce,
                          QuicStringPiece pre_shared_key,
-                         const QuicString& hkdf_input,
+                         const std::string& hkdf_input,
                          Perspective perspective,
                          Diversification diversification,
                          CrypterPair* crypters,
-                         QuicString* subkey_secret);
+                         std::string* subkey_secret);
 
   // Performs key extraction to derive a new secret of |result_len| bytes
   // dependent on |subkey_secret|, |label|, and |context|. Returns false if the
@@ -141,7 +141,7 @@
                                    QuicStringPiece label,
                                    QuicStringPiece context,
                                    size_t result_len,
-                                   QuicString* result);
+                                   std::string* result);
 
   // Computes the FNV-1a hash of the provided DER-encoded cert for use in the
   // XLCT tag.
@@ -155,7 +155,7 @@
   static QuicErrorCode ValidateServerHello(
       const CryptoHandshakeMessage& server_hello,
       const ParsedQuicVersionVector& negotiated_versions,
-      QuicString* error_details);
+      std::string* error_details);
 
   // Validates that the |server_versions| received do not indicate that the
   // ServerHello is part of a downgrade attack. |negotiated_versions| must
@@ -167,7 +167,7 @@
   static QuicErrorCode ValidateServerHelloVersions(
       const QuicVersionLabelVector& server_versions,
       const ParsedQuicVersionVector& negotiated_versions,
-      QuicString* error_details);
+      std::string* error_details);
 
   // Validates that |client_hello| is actually a CHLO and that this is not part
   // of a downgrade attack.
@@ -179,7 +179,7 @@
       const CryptoHandshakeMessage& client_hello,
       ParsedQuicVersion version,
       const ParsedQuicVersionVector& supported_versions,
-      QuicString* error_details);
+      std::string* error_details);
 
   // Validates that the |client_version| received does not indicate that a
   // downgrade attack has occurred. |connection_version| is the version of the
@@ -192,7 +192,7 @@
       QuicVersionLabel client_version,
       ParsedQuicVersion connection_version,
       const ParsedQuicVersionVector& supported_versions,
-      QuicString* error_details);
+      std::string* error_details);
 
   // Returns the name of the HandshakeFailureReason as a char*
   static const char* HandshakeFailureReasonToString(
@@ -200,7 +200,7 @@
 
   // Writes a hash of the serialized |message| into |output|.
   static void HashHandshakeMessage(const CryptoHandshakeMessage& message,
-                                   QuicString* output,
+                                   std::string* output,
                                    Perspective perspective);
 
  private:
@@ -221,7 +221,7 @@
   static std::vector<uint8_t> HkdfExpandLabel(
       const EVP_MD* prf,
       const std::vector<uint8_t>& secret,
-      const QuicString& label,
+      const std::string& label,
       size_t out_len);
 };
 
diff --git a/quic/core/crypto/crypto_utils_test.cc b/quic/core/crypto/crypto_utils_test.cc
index 90a37af..c76337d 100644
--- a/quic/core/crypto/crypto_utils_test.cc
+++ b/quic/core/crypto/crypto_utils_test.cc
@@ -50,18 +50,18 @@
 
   for (size_t i = 0; i < QUIC_ARRAYSIZE(test_vector); i++) {
     // Decode the test vector.
-    QuicString subkey_secret =
+    std::string subkey_secret =
         QuicTextUtils::HexDecode(test_vector[i].subkey_secret);
-    QuicString label = QuicTextUtils::HexDecode(test_vector[i].label);
-    QuicString context = QuicTextUtils::HexDecode(test_vector[i].context);
+    std::string label = QuicTextUtils::HexDecode(test_vector[i].label);
+    std::string context = QuicTextUtils::HexDecode(test_vector[i].context);
     size_t result_len = test_vector[i].result_len;
     bool expect_ok = test_vector[i].expected != nullptr;
-    QuicString expected;
+    std::string expected;
     if (expect_ok) {
       expected = QuicTextUtils::HexDecode(test_vector[i].expected);
     }
 
-    QuicString result;
+    std::string result;
     bool ok = CryptoUtils::ExportKeyingMaterial(subkey_secret, label, context,
                                                 result_len, &result);
     EXPECT_EQ(expect_ok, ok);
diff --git a/quic/core/crypto/curve25519_key_exchange.cc b/quic/core/crypto/curve25519_key_exchange.cc
index 368b453..9c8e5ed 100644
--- a/quic/core/crypto/curve25519_key_exchange.cc
+++ b/quic/core/crypto/curve25519_key_exchange.cc
@@ -20,7 +20,8 @@
   ~Curve25519KeyExchangeFactory() override = default;
 
   std::unique_ptr<KeyExchange> Create(QuicRandom* rand) const override {
-    const QuicString private_value = Curve25519KeyExchange::NewPrivateKey(rand);
+    const std::string private_value =
+        Curve25519KeyExchange::NewPrivateKey(rand);
     return Curve25519KeyExchange::New(private_value);
   }
 
@@ -58,10 +59,10 @@
 }
 
 // static
-QuicString Curve25519KeyExchange::NewPrivateKey(QuicRandom* rand) {
+std::string Curve25519KeyExchange::NewPrivateKey(QuicRandom* rand) {
   uint8_t private_key[X25519_PRIVATE_KEY_LEN];
   rand->RandBytes(private_key, sizeof(private_key));
-  return QuicString(reinterpret_cast<char*>(private_key), sizeof(private_key));
+  return std::string(reinterpret_cast<char*>(private_key), sizeof(private_key));
 }
 
 const Curve25519KeyExchange::Factory& Curve25519KeyExchange::GetFactory()
@@ -72,7 +73,7 @@
 
 bool Curve25519KeyExchange::CalculateSharedKey(
     QuicStringPiece peer_public_value,
-    QuicString* out_result) const {
+    std::string* out_result) const {
   if (peer_public_value.size() != X25519_PUBLIC_VALUE_LEN) {
     return false;
   }
@@ -89,7 +90,7 @@
 
 void Curve25519KeyExchange::CalculateSharedKey(
     QuicStringPiece peer_public_value,
-    QuicString* shared_key,
+    std::string* shared_key,
     std::unique_ptr<Callback> callback) const {
   callback->Run(CalculateSharedKey(peer_public_value, shared_key));
 }
diff --git a/quic/core/crypto/curve25519_key_exchange.h b/quic/core/crypto/curve25519_key_exchange.h
index a715e3e..115789c 100644
--- a/quic/core/crypto/curve25519_key_exchange.h
+++ b/quic/core/crypto/curve25519_key_exchange.h
@@ -29,14 +29,14 @@
 
   // NewPrivateKey returns a private key, generated from |rand|, suitable for
   // passing to |New|.
-  static QuicString NewPrivateKey(QuicRandom* rand);
+  static std::string NewPrivateKey(QuicRandom* rand);
 
   // KeyExchange interface.
   const Factory& GetFactory() const override;
   bool CalculateSharedKey(QuicStringPiece peer_public_value,
-                          QuicString* shared_key) const override;
+                          std::string* shared_key) const override;
   void CalculateSharedKey(QuicStringPiece peer_public_value,
-                          QuicString* shared_key,
+                          std::string* shared_key,
                           std::unique_ptr<Callback> callback) const override;
   QuicStringPiece public_value() const override;
 
diff --git a/quic/core/crypto/curve25519_key_exchange_test.cc b/quic/core/crypto/curve25519_key_exchange_test.cc
index e5ed6e0..0c4f735 100644
--- a/quic/core/crypto/curve25519_key_exchange_test.cc
+++ b/quic/core/crypto/curve25519_key_exchange_test.cc
@@ -46,8 +46,8 @@
   QuicRandom* const rand = QuicRandom::GetInstance();
 
   for (int i = 0; i < 5; i++) {
-    const QuicString alice_key(Curve25519KeyExchange::NewPrivateKey(rand));
-    const QuicString bob_key(Curve25519KeyExchange::NewPrivateKey(rand));
+    const std::string alice_key(Curve25519KeyExchange::NewPrivateKey(rand));
+    const std::string bob_key(Curve25519KeyExchange::NewPrivateKey(rand));
 
     std::unique_ptr<Curve25519KeyExchange> alice(
         Curve25519KeyExchange::New(alice_key));
@@ -57,7 +57,7 @@
     const QuicStringPiece alice_public(alice->public_value());
     const QuicStringPiece bob_public(bob->public_value());
 
-    QuicString alice_shared, bob_shared;
+    std::string alice_shared, bob_shared;
     ASSERT_TRUE(alice->CalculateSharedKey(bob_public, &alice_shared));
     ASSERT_TRUE(bob->CalculateSharedKey(alice_public, &bob_shared));
     ASSERT_EQ(alice_shared, bob_shared);
@@ -70,8 +70,8 @@
   QuicRandom* const rand = QuicRandom::GetInstance();
 
   for (int i = 0; i < 5; i++) {
-    const QuicString alice_key(Curve25519KeyExchange::NewPrivateKey(rand));
-    const QuicString bob_key(Curve25519KeyExchange::NewPrivateKey(rand));
+    const std::string alice_key(Curve25519KeyExchange::NewPrivateKey(rand));
+    const std::string bob_key(Curve25519KeyExchange::NewPrivateKey(rand));
 
     std::unique_ptr<Curve25519KeyExchange> alice(
         Curve25519KeyExchange::New(alice_key));
@@ -81,7 +81,7 @@
     const QuicStringPiece alice_public(alice->public_value());
     const QuicStringPiece bob_public(bob->public_value());
 
-    QuicString alice_shared, bob_shared;
+    std::string alice_shared, bob_shared;
     TestCallbackResult alice_result;
     ASSERT_FALSE(alice_result.ok());
     alice->CalculateSharedKey(bob_public, &alice_shared,
diff --git a/quic/core/crypto/key_exchange.h b/quic/core/crypto/key_exchange.h
index 84ca626..8970b62 100644
--- a/quic/core/crypto/key_exchange.h
+++ b/quic/core/crypto/key_exchange.h
@@ -65,14 +65,14 @@
   // (which is implicitly known by a KeyExchange object) and a public value
   // from the peer.
   virtual bool CalculateSharedKey(QuicStringPiece peer_public_value,
-                                  QuicString* shared_key) const = 0;
+                                  std::string* shared_key) const = 0;
 
   // CalculateSharedKey computes the shared key between the local private key
   // (which is may not be locally known to a KeyExchange object) and a public
   // value from the peer.
   // Callers should expect that |callback| might be invoked synchronously.
   virtual void CalculateSharedKey(QuicStringPiece peer_public_value,
-                                  QuicString* shared_key,
+                                  std::string* shared_key,
                                   std::unique_ptr<Callback> callback) const = 0;
 
   // public_value returns the local public key which can be sent to a peer in
diff --git a/quic/core/crypto/p256_key_exchange.cc b/quic/core/crypto/p256_key_exchange.cc
index 2bfbd09..a53efe5 100644
--- a/quic/core/crypto/p256_key_exchange.cc
+++ b/quic/core/crypto/p256_key_exchange.cc
@@ -26,7 +26,7 @@
 
   std::unique_ptr<KeyExchange> Create(QuicRandom* /* rand */) const override {
     // TODO(agl): avoid the serialisation/deserialisation in this function.
-    const QuicString private_value = P256KeyExchange::NewPrivateKey();
+    const std::string private_value = P256KeyExchange::NewPrivateKey();
     return P256KeyExchange::New(private_value);
   }
 
@@ -72,25 +72,25 @@
 }
 
 // static
-QuicString P256KeyExchange::NewPrivateKey() {
+std::string P256KeyExchange::NewPrivateKey() {
   bssl::UniquePtr<EC_KEY> key(EC_KEY_new_by_curve_name(NID_X9_62_prime256v1));
   if (!key.get() || !EC_KEY_generate_key(key.get())) {
     QUIC_DLOG(INFO) << "Can't generate a new private key.";
-    return QuicString();
+    return std::string();
   }
 
   int key_len = i2d_ECPrivateKey(key.get(), nullptr);
   if (key_len <= 0) {
     QUIC_DLOG(INFO) << "Can't convert private key to string";
-    return QuicString();
+    return std::string();
   }
   std::unique_ptr<uint8_t[]> private_key(new uint8_t[key_len]);
   uint8_t* keyp = private_key.get();
   if (!i2d_ECPrivateKey(key.get(), &keyp)) {
     QUIC_DLOG(INFO) << "Can't convert private key to string.";
-    return QuicString();
+    return std::string();
   }
-  return QuicString(reinterpret_cast<char*>(private_key.get()), key_len);
+  return std::string(reinterpret_cast<char*>(private_key.get()), key_len);
 }
 
 const KeyExchange::Factory& P256KeyExchange::GetFactory() const {
@@ -99,7 +99,7 @@
 }
 
 bool P256KeyExchange::CalculateSharedKey(QuicStringPiece peer_public_value,
-                                         QuicString* out_result) const {
+                                         std::string* out_result) const {
   if (peer_public_value.size() != kUncompressedP256PointBytes) {
     QUIC_DLOG(INFO) << "Peer public value is invalid";
     return false;
@@ -130,7 +130,7 @@
 
 void P256KeyExchange::CalculateSharedKey(
     QuicStringPiece peer_public_value,
-    QuicString* shared_key,
+    std::string* shared_key,
     std::unique_ptr<Callback> callback) const {
   callback->Run(CalculateSharedKey(peer_public_value, shared_key));
 }
diff --git a/quic/core/crypto/p256_key_exchange.h b/quic/core/crypto/p256_key_exchange.h
index d70d9cc..04301e4 100644
--- a/quic/core/crypto/p256_key_exchange.h
+++ b/quic/core/crypto/p256_key_exchange.h
@@ -29,14 +29,14 @@
   // |NewPrivateKey| returns a private key, suitable for passing to |New|.
   // If |NewPrivateKey| can't generate a private key, it returns an empty
   // string.
-  static QuicString NewPrivateKey();
+  static std::string NewPrivateKey();
 
   // KeyExchange interface.
   const Factory& GetFactory() const override;
   bool CalculateSharedKey(QuicStringPiece peer_public_value,
-                          QuicString* shared_key) const override;
+                          std::string* shared_key) const override;
   void CalculateSharedKey(QuicStringPiece peer_public_value,
-                          QuicString* shared_key,
+                          std::string* shared_key,
                           std::unique_ptr<Callback> callback) const override;
   QuicStringPiece public_value() const override;
 
diff --git a/quic/core/crypto/p256_key_exchange_test.cc b/quic/core/crypto/p256_key_exchange_test.cc
index 5deee9d..32d6bf1 100644
--- a/quic/core/crypto/p256_key_exchange_test.cc
+++ b/quic/core/crypto/p256_key_exchange_test.cc
@@ -43,8 +43,8 @@
 // holds: that both parties end up with the same key.
 TEST_F(P256KeyExchangeTest, SharedKey) {
   for (int i = 0; i < 5; i++) {
-    QuicString alice_private(P256KeyExchange::NewPrivateKey());
-    QuicString bob_private(P256KeyExchange::NewPrivateKey());
+    std::string alice_private(P256KeyExchange::NewPrivateKey());
+    std::string bob_private(P256KeyExchange::NewPrivateKey());
 
     ASSERT_FALSE(alice_private.empty());
     ASSERT_FALSE(bob_private.empty());
@@ -59,7 +59,7 @@
     const QuicStringPiece alice_public(alice->public_value());
     const QuicStringPiece bob_public(bob->public_value());
 
-    QuicString alice_shared, bob_shared;
+    std::string alice_shared, bob_shared;
     ASSERT_TRUE(alice->CalculateSharedKey(bob_public, &alice_shared));
     ASSERT_TRUE(bob->CalculateSharedKey(alice_public, &bob_shared));
     ASSERT_EQ(alice_shared, bob_shared);
@@ -70,8 +70,8 @@
 // parties end up with the same key.
 TEST_F(P256KeyExchangeTest, AsyncSharedKey) {
   for (int i = 0; i < 5; i++) {
-    QuicString alice_private(P256KeyExchange::NewPrivateKey());
-    QuicString bob_private(P256KeyExchange::NewPrivateKey());
+    std::string alice_private(P256KeyExchange::NewPrivateKey());
+    std::string bob_private(P256KeyExchange::NewPrivateKey());
 
     ASSERT_FALSE(alice_private.empty());
     ASSERT_FALSE(bob_private.empty());
@@ -86,7 +86,7 @@
     const QuicStringPiece alice_public(alice->public_value());
     const QuicStringPiece bob_public(bob->public_value());
 
-    QuicString alice_shared, bob_shared;
+    std::string alice_shared, bob_shared;
     TestCallbackResult alice_result;
     ASSERT_FALSE(alice_result.ok());
     alice->CalculateSharedKey(bob_public, &alice_shared,
diff --git a/quic/core/crypto/proof_source.cc b/quic/core/crypto/proof_source.cc
index ce77d8b..4edb40d 100644
--- a/quic/core/crypto/proof_source.cc
+++ b/quic/core/crypto/proof_source.cc
@@ -7,7 +7,7 @@
 
 namespace quic {
 
-ProofSource::Chain::Chain(const std::vector<QuicString>& certs)
+ProofSource::Chain::Chain(const std::vector<std::string>& certs)
     : certs(certs) {}
 
 ProofSource::Chain::~Chain() {}
diff --git a/quic/core/crypto/proof_source.h b/quic/core/crypto/proof_source.h
index 3fec32b..0f293be 100644
--- a/quic/core/crypto/proof_source.h
+++ b/quic/core/crypto/proof_source.h
@@ -25,11 +25,11 @@
   // Chain is a reference-counted wrapper for a vector of stringified
   // certificates.
   struct QUIC_EXPORT_PRIVATE Chain : public QuicReferenceCounted {
-    explicit Chain(const std::vector<QuicString>& certs);
+    explicit Chain(const std::vector<std::string>& certs);
     Chain(const Chain&) = delete;
     Chain& operator=(const Chain&) = delete;
 
-    const std::vector<QuicString> certs;
+    const std::vector<std::string> certs;
 
    protected:
     ~Chain() override;
@@ -85,7 +85,7 @@
     //
     // |signature| contains the signature of the data provided to
     // ComputeTlsSignature. Its value is undefined if |ok| is false.
-    virtual void Run(bool ok, QuicString signature) = 0;
+    virtual void Run(bool ok, std::string signature) = 0;
 
    private:
     SignatureCallback(const SignatureCallback&) = delete;
@@ -113,8 +113,8 @@
   //
   // Callers should expect that |callback| might be invoked synchronously.
   virtual void GetProof(const QuicSocketAddress& server_address,
-                        const QuicString& hostname,
-                        const QuicString& server_config,
+                        const std::string& hostname,
+                        const std::string& server_config,
                         QuicTransportVersion transport_version,
                         QuicStringPiece chlo_hash,
                         std::unique_ptr<Callback> callback) = 0;
@@ -122,7 +122,7 @@
   // Returns the certificate chain for |hostname| in leaf-first order.
   virtual QuicReferenceCountedPointer<Chain> GetCertChain(
       const QuicSocketAddress& server_address,
-      const QuicString& hostname) = 0;
+      const std::string& hostname) = 0;
 
   // Computes a signature using the private key of the certificate for
   // |hostname|. The value in |in| is signed using the algorithm specified by
@@ -134,7 +134,7 @@
   // Callers should expect that |callback| might be invoked synchronously.
   virtual void ComputeTlsSignature(
       const QuicSocketAddress& server_address,
-      const QuicString& hostname,
+      const std::string& hostname,
       uint16_t signature_algorithm,
       QuicStringPiece in,
       std::unique_ptr<SignatureCallback> callback) = 0;
diff --git a/quic/core/crypto/proof_verifier.h b/quic/core/crypto/proof_verifier.h
index 3219203..9178942 100644
--- a/quic/core/crypto/proof_verifier.h
+++ b/quic/core/crypto/proof_verifier.h
@@ -48,7 +48,7 @@
   // details of the verification. |Run| may take ownership of |details| by
   // calling |release| on it.
   virtual void Run(bool ok,
-                   const QuicString& error_details,
+                   const std::string& error_details,
                    std::unique_ptr<ProofVerifyDetails>* details) = 0;
 };
 
@@ -75,16 +75,16 @@
   // The signature uses SHA-256 as the hash function and PSS padding in the
   // case of RSA.
   virtual QuicAsyncStatus VerifyProof(
-      const QuicString& hostname,
+      const std::string& hostname,
       const uint16_t port,
-      const QuicString& server_config,
+      const std::string& server_config,
       QuicTransportVersion transport_version,
       QuicStringPiece chlo_hash,
-      const std::vector<QuicString>& certs,
-      const QuicString& cert_sct,
-      const QuicString& signature,
+      const std::vector<std::string>& certs,
+      const std::string& cert_sct,
+      const std::string& signature,
       const ProofVerifyContext* context,
-      QuicString* error_details,
+      std::string* error_details,
       std::unique_ptr<ProofVerifyDetails>* details,
       std::unique_ptr<ProofVerifierCallback> callback) = 0;
 
@@ -101,10 +101,10 @@
   // will call back, on the original thread, via |callback| when complete.
   // In this case, the ProofVerifier will take ownership of |callback|.
   virtual QuicAsyncStatus VerifyCertChain(
-      const QuicString& hostname,
-      const std::vector<QuicString>& certs,
+      const std::string& hostname,
+      const std::vector<std::string>& certs,
       const ProofVerifyContext* context,
-      QuicString* error_details,
+      std::string* error_details,
       std::unique_ptr<ProofVerifyDetails>* details,
       std::unique_ptr<ProofVerifierCallback> callback) = 0;
 
diff --git a/quic/core/crypto/quic_compressed_certs_cache.cc b/quic/core/crypto/quic_compressed_certs_cache.cc
index 595ac31..e07e924 100644
--- a/quic/core/crypto/quic_compressed_certs_cache.cc
+++ b/quic/core/crypto/quic_compressed_certs_cache.cc
@@ -26,8 +26,8 @@
 
 QuicCompressedCertsCache::UncompressedCerts::UncompressedCerts(
     const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
-    const QuicString* client_common_set_hashes,
-    const QuicString* client_cached_cert_hashes)
+    const std::string* client_common_set_hashes,
+    const std::string* client_cached_cert_hashes)
     : chain(chain),
       client_common_set_hashes(client_common_set_hashes),
       client_cached_cert_hashes(client_cached_cert_hashes) {}
@@ -38,7 +38,7 @@
 
 QuicCompressedCertsCache::CachedCerts::CachedCerts(
     const UncompressedCerts& uncompressed_certs,
-    const QuicString& compressed_cert)
+    const std::string& compressed_cert)
     : chain_(uncompressed_certs.chain),
       client_common_set_hashes_(*uncompressed_certs.client_common_set_hashes),
       client_cached_cert_hashes_(*uncompressed_certs.client_cached_cert_hashes),
@@ -58,7 +58,7 @@
           chain_ == uncompressed_certs.chain);
 }
 
-const QuicString* QuicCompressedCertsCache::CachedCerts::compressed_cert()
+const std::string* QuicCompressedCertsCache::CachedCerts::compressed_cert()
     const {
   return &compressed_cert_;
 }
@@ -71,10 +71,10 @@
   certs_cache_.Clear();
 }
 
-const QuicString* QuicCompressedCertsCache::GetCompressedCert(
+const std::string* QuicCompressedCertsCache::GetCompressedCert(
     const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
-    const QuicString& client_common_set_hashes,
-    const QuicString& client_cached_cert_hashes) {
+    const std::string& client_common_set_hashes,
+    const std::string& client_cached_cert_hashes) {
   UncompressedCerts uncompressed_certs(chain, &client_common_set_hashes,
                                        &client_cached_cert_hashes);
 
@@ -90,9 +90,9 @@
 
 void QuicCompressedCertsCache::Insert(
     const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
-    const QuicString& client_common_set_hashes,
-    const QuicString& client_cached_cert_hashes,
-    const QuicString& compressed_cert) {
+    const std::string& client_common_set_hashes,
+    const std::string& client_cached_cert_hashes,
+    const std::string& compressed_cert) {
   UncompressedCerts uncompressed_certs(chain, &client_common_set_hashes,
                                        &client_cached_cert_hashes);
 
@@ -115,9 +115,9 @@
 uint64_t QuicCompressedCertsCache::ComputeUncompressedCertsHash(
     const UncompressedCerts& uncompressed_certs) {
   uint64_t hash =
-      std::hash<QuicString>()(*uncompressed_certs.client_common_set_hashes);
+      std::hash<std::string>()(*uncompressed_certs.client_common_set_hashes);
   uint64_t h =
-      std::hash<QuicString>()(*uncompressed_certs.client_cached_cert_hashes);
+      std::hash<std::string>()(*uncompressed_certs.client_cached_cert_hashes);
   hash_combine(&hash, h);
 
   hash_combine(&hash,
diff --git a/quic/core/crypto/quic_compressed_certs_cache.h b/quic/core/crypto/quic_compressed_certs_cache.h
index 418bdb9..340542a 100644
--- a/quic/core/crypto/quic_compressed_certs_cache.h
+++ b/quic/core/crypto/quic_compressed_certs_cache.h
@@ -24,10 +24,10 @@
   // |chain, client_common_set_hashes, client_cached_cert_hashes| hits cache.
   // Otherwise, return nullptr.
   // Returned pointer might become invalid on the next call to Insert().
-  const QuicString* GetCompressedCert(
+  const std::string* GetCompressedCert(
       const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
-      const QuicString& client_common_set_hashes,
-      const QuicString& client_cached_cert_hashes);
+      const std::string& client_common_set_hashes,
+      const std::string& client_cached_cert_hashes);
 
   // Inserts the specified
   // |chain, client_common_set_hashes,
@@ -35,9 +35,9 @@
   // If the insertion causes the cache to become overfull, entries will
   // be deleted in an LRU order to make room.
   void Insert(const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
-              const QuicString& client_common_set_hashes,
-              const QuicString& client_cached_cert_hashes,
-              const QuicString& compressed_cert);
+              const std::string& client_common_set_hashes,
+              const std::string& client_cached_cert_hashes,
+              const std::string& compressed_cert);
 
   // Returns max number of cache entries the cache can carry.
   size_t MaxSize();
@@ -56,13 +56,13 @@
     UncompressedCerts();
     UncompressedCerts(
         const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
-        const QuicString* client_common_set_hashes,
-        const QuicString* client_cached_cert_hashes);
+        const std::string* client_common_set_hashes,
+        const std::string* client_cached_cert_hashes);
     ~UncompressedCerts();
 
     const QuicReferenceCountedPointer<ProofSource::Chain> chain;
-    const QuicString* client_common_set_hashes;
-    const QuicString* client_cached_cert_hashes;
+    const std::string* client_common_set_hashes;
+    const std::string* client_cached_cert_hashes;
   };
 
   // Certs stored by QuicCompressedCertsCache where uncompressed certs data is
@@ -72,7 +72,7 @@
    public:
     CachedCerts();
     CachedCerts(const UncompressedCerts& uncompressed_certs,
-                const QuicString& compressed_cert);
+                const std::string& compressed_cert);
     CachedCerts(const CachedCerts& other);
     ~CachedCerts();
 
@@ -81,16 +81,16 @@
     bool MatchesUncompressedCerts(
         const UncompressedCerts& uncompressed_certs) const;
 
-    const QuicString* compressed_cert() const;
+    const std::string* compressed_cert() const;
 
    private:
     // Uncompressed certs data.
     QuicReferenceCountedPointer<ProofSource::Chain> chain_;
-    const QuicString client_common_set_hashes_;
-    const QuicString client_cached_cert_hashes_;
+    const std::string client_common_set_hashes_;
+    const std::string client_cached_cert_hashes_;
 
     // Cached compressed representation derived from uncompressed certs.
-    const QuicString compressed_cert_;
+    const std::string compressed_cert_;
   };
 
   // Computes a uint64_t hash for |uncompressed_certs|.
diff --git a/quic/core/crypto/quic_compressed_certs_cache_test.cc b/quic/core/crypto/quic_compressed_certs_cache_test.cc
index 432a8c0..788f1d7 100644
--- a/quic/core/crypto/quic_compressed_certs_cache_test.cc
+++ b/quic/core/crypto/quic_compressed_certs_cache_test.cc
@@ -27,31 +27,31 @@
 };
 
 TEST_F(QuicCompressedCertsCacheTest, CacheHit) {
-  std::vector<QuicString> certs = {"leaf cert", "intermediate cert",
-                                   "root cert"};
+  std::vector<std::string> certs = {"leaf cert", "intermediate cert",
+                                    "root cert"};
   QuicReferenceCountedPointer<ProofSource::Chain> chain(
       new ProofSource::Chain(certs));
-  QuicString common_certs = "common certs";
-  QuicString cached_certs = "cached certs";
-  QuicString compressed = "compressed cert";
+  std::string common_certs = "common certs";
+  std::string cached_certs = "cached certs";
+  std::string compressed = "compressed cert";
 
   certs_cache_.Insert(chain, common_certs, cached_certs, compressed);
 
-  const QuicString* cached_value =
+  const std::string* cached_value =
       certs_cache_.GetCompressedCert(chain, common_certs, cached_certs);
   ASSERT_NE(nullptr, cached_value);
   EXPECT_EQ(*cached_value, compressed);
 }
 
 TEST_F(QuicCompressedCertsCacheTest, CacheMiss) {
-  std::vector<QuicString> certs = {"leaf cert", "intermediate cert",
-                                   "root cert"};
+  std::vector<std::string> certs = {"leaf cert", "intermediate cert",
+                                    "root cert"};
   QuicReferenceCountedPointer<ProofSource::Chain> chain(
       new ProofSource::Chain(certs));
 
-  QuicString common_certs = "common certs";
-  QuicString cached_certs = "cached certs";
-  QuicString compressed = "compressed cert";
+  std::string common_certs = "common certs";
+  std::string cached_certs = "cached certs";
+  std::string compressed = "compressed cert";
 
   certs_cache_.Insert(chain, common_certs, cached_certs, compressed);
 
@@ -70,14 +70,14 @@
 TEST_F(QuicCompressedCertsCacheTest, CacheMissDueToEviction) {
   // Test cache returns a miss when a queried uncompressed certs was cached but
   // then evicted.
-  std::vector<QuicString> certs = {"leaf cert", "intermediate cert",
-                                   "root cert"};
+  std::vector<std::string> certs = {"leaf cert", "intermediate cert",
+                                    "root cert"};
   QuicReferenceCountedPointer<ProofSource::Chain> chain(
       new ProofSource::Chain(certs));
 
-  QuicString common_certs = "common certs";
-  QuicString cached_certs = "cached certs";
-  QuicString compressed = "compressed cert";
+  std::string common_certs = "common certs";
+  std::string cached_certs = "cached certs";
+  std::string compressed = "compressed cert";
   certs_cache_.Insert(chain, common_certs, cached_certs, compressed);
 
   // Insert another kQuicCompressedCertsCacheSize certs to evict the first
diff --git a/quic/core/crypto/quic_crypto_client_config.cc b/quic/core/crypto/quic_crypto_client_config.cc
index 0bf1b41..8d34173 100644
--- a/quic/core/crypto/quic_crypto_client_config.cc
+++ b/quic/core/crypto/quic_crypto_client_config.cc
@@ -138,7 +138,7 @@
 }
 
 void QuicCryptoClientConfig::CachedState::add_server_nonce(
-    const QuicString& server_nonce) {
+    const std::string& server_nonce) {
   server_nonces_.push(server_nonce);
 }
 
@@ -151,7 +151,7 @@
     QuicStringPiece server_config,
     QuicWallTime now,
     QuicWallTime expiry_time,
-    QuicString* error_details) {
+    std::string* error_details) {
   const bool matches_existing = server_config == server_config_;
 
   // Even if the new server config matches the existing one, we still wish to
@@ -188,7 +188,7 @@
   }
 
   if (!matches_existing) {
-    server_config_ = QuicString(server_config);
+    server_config_ = std::string(server_config);
     SetProofInvalid();
     scfg_ = std::move(new_scfg_storage);
   }
@@ -205,7 +205,7 @@
 }
 
 void QuicCryptoClientConfig::CachedState::SetProof(
-    const std::vector<QuicString>& certs,
+    const std::vector<std::string>& certs,
     QuicStringPiece cert_sct,
     QuicStringPiece chlo_hash,
     QuicStringPiece signature) {
@@ -228,9 +228,9 @@
   // If the proof has changed then it needs to be revalidated.
   SetProofInvalid();
   certs_ = certs;
-  cert_sct_ = QuicString(cert_sct);
-  chlo_hash_ = QuicString(chlo_hash);
-  server_config_sig_ = QuicString(signature);
+  cert_sct_ = std::string(cert_sct);
+  chlo_hash_ = std::string(chlo_hash);
+  server_config_sig_ = std::string(signature);
 }
 
 void QuicCryptoClientConfig::CachedState::Clear() {
@@ -269,8 +269,8 @@
 bool QuicCryptoClientConfig::CachedState::Initialize(
     QuicStringPiece server_config,
     QuicStringPiece source_address_token,
-    const std::vector<QuicString>& certs,
-    const QuicString& cert_sct,
+    const std::vector<std::string>& certs,
+    const std::string& cert_sct,
     QuicStringPiece chlo_hash,
     QuicStringPiece signature,
     QuicWallTime now,
@@ -282,7 +282,7 @@
     return false;
   }
 
-  QuicString error_details;
+  std::string error_details;
   ServerConfigState state =
       SetServerConfig(server_config, now, expiration_time, &error_details);
   RecordDiskCacheServerConfigState(state);
@@ -300,29 +300,29 @@
   return true;
 }
 
-const QuicString& QuicCryptoClientConfig::CachedState::server_config() const {
+const std::string& QuicCryptoClientConfig::CachedState::server_config() const {
   return server_config_;
 }
 
-const QuicString& QuicCryptoClientConfig::CachedState::source_address_token()
+const std::string& QuicCryptoClientConfig::CachedState::source_address_token()
     const {
   return source_address_token_;
 }
 
-const std::vector<QuicString>& QuicCryptoClientConfig::CachedState::certs()
+const std::vector<std::string>& QuicCryptoClientConfig::CachedState::certs()
     const {
   return certs_;
 }
 
-const QuicString& QuicCryptoClientConfig::CachedState::cert_sct() const {
+const std::string& QuicCryptoClientConfig::CachedState::cert_sct() const {
   return cert_sct_;
 }
 
-const QuicString& QuicCryptoClientConfig::CachedState::chlo_hash() const {
+const std::string& QuicCryptoClientConfig::CachedState::chlo_hash() const {
   return chlo_hash_;
 }
 
-const QuicString& QuicCryptoClientConfig::CachedState::signature() const {
+const std::string& QuicCryptoClientConfig::CachedState::signature() const {
   return server_config_sig_;
 }
 
@@ -341,12 +341,12 @@
 
 void QuicCryptoClientConfig::CachedState::set_source_address_token(
     QuicStringPiece token) {
-  source_address_token_ = QuicString(token);
+  source_address_token_ = std::string(token);
 }
 
 void QuicCryptoClientConfig::CachedState::set_cert_sct(
     QuicStringPiece cert_sct) {
-  cert_sct_ = QuicString(cert_sct);
+  cert_sct_ = std::string(cert_sct);
 }
 
 void QuicCryptoClientConfig::CachedState::SetProofVerifyDetails(
@@ -385,13 +385,13 @@
   return next_id;
 }
 
-QuicString QuicCryptoClientConfig::CachedState::GetNextServerNonce() {
+std::string QuicCryptoClientConfig::CachedState::GetNextServerNonce() {
   if (server_nonces_.empty()) {
     QUIC_BUG
         << "Attempting to consume a server nonce that was never designated.";
     return "";
   }
-  const QuicString server_nonce = server_nonces_.front();
+  const std::string server_nonce = server_nonces_.front();
   server_nonces_.pop();
   return server_nonce;
 }
@@ -494,7 +494,7 @@
 
   out->SetStringPiece(kCertificateSCTTag, "");
 
-  const std::vector<QuicString>& certs = cached->certs();
+  const std::vector<std::string>& certs = cached->certs();
   // We save |certs| in the QuicCryptoNegotiatedParameters so that, if the
   // client config is being used for multiple connections, another connection
   // doesn't update the cached certificates and cause us to be unable to
@@ -520,7 +520,7 @@
     const ChannelIDKey* channel_id_key,
     QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
     CryptoHandshakeMessage* out,
-    QuicString* error_details) const {
+    std::string* error_details) const {
   DCHECK(error_details != nullptr);
   QUIC_BUG_IF(!QuicUtils::IsConnectionIdValidForVersion(
       connection_id, preferred_version.transport_version))
@@ -636,7 +636,7 @@
   }
   out->SetStringPiece(kPUBS, out_params->client_key_exchange->public_value());
 
-  const std::vector<QuicString>& certs = cached->certs();
+  const std::vector<std::string>& certs = cached->certs();
   if (certs.empty()) {
     *error_details = "No certs to calculate XLCT";
     return QUIC_CRYPTO_INTERNAL_ERROR;
@@ -653,17 +653,17 @@
     CryptoHandshakeMessage cetv;
     cetv.set_tag(kCETV);
 
-    QuicString hkdf_input;
+    std::string hkdf_input;
     const QuicData& client_hello_serialized = out->GetSerialized();
     hkdf_input.append(QuicCryptoConfig::kCETVLabel,
                       strlen(QuicCryptoConfig::kCETVLabel) + 1);
-      hkdf_input.append(connection_id.data(), connection_id.length());
+    hkdf_input.append(connection_id.data(), connection_id.length());
     hkdf_input.append(client_hello_serialized.data(),
                       client_hello_serialized.length());
     hkdf_input.append(cached->server_config());
 
-    QuicString key = channel_id_key->SerializeKey();
-    QuicString signature;
+    std::string key = channel_id_key->SerializeKey();
+    std::string signature;
     if (!channel_id_key->Sign(hkdf_input, &signature)) {
       *error_details = "Channel ID signature failed";
       return QUIC_INVALID_CHANNEL_ID_SIGNATURE;
@@ -707,8 +707,8 @@
   //   out_params->hkdf_input_suffix
   //   out_params->initial_crypters
   out_params->hkdf_input_suffix.clear();
-    out_params->hkdf_input_suffix.append(connection_id.data(),
-                                         connection_id.length());
+  out_params->hkdf_input_suffix.append(connection_id.data(),
+                                       connection_id.length());
   const QuicData& client_hello_serialized = out->GetSerialized();
   out_params->hkdf_input_suffix.append(client_hello_serialized.data(),
                                        client_hello_serialized.length());
@@ -719,13 +719,13 @@
   }
   out_params->hkdf_input_suffix.append(certs[0]);
 
-  QuicString hkdf_input;
+  std::string hkdf_input;
   const size_t label_len = strlen(QuicCryptoConfig::kInitialLabel) + 1;
   hkdf_input.reserve(label_len + out_params->hkdf_input_suffix.size());
   hkdf_input.append(QuicCryptoConfig::kInitialLabel, label_len);
   hkdf_input.append(out_params->hkdf_input_suffix);
 
-  QuicString* subkey_secret = &out_params->initial_subkey_secret;
+  std::string* subkey_secret = &out_params->initial_subkey_secret;
 
   if (!CryptoUtils::DeriveKeys(out_params->initial_premaster_secret,
                                out_params->aead, out_params->client_nonce,
@@ -745,9 +745,9 @@
     QuicWallTime now,
     QuicTransportVersion version,
     QuicStringPiece chlo_hash,
-    const std::vector<QuicString>& cached_certs,
+    const std::vector<std::string>& cached_certs,
     CachedState* cached,
-    QuicString* error_details) {
+    std::string* error_details) {
   DCHECK(error_details != nullptr);
 
   QuicStringPiece scfg;
@@ -784,7 +784,7 @@
   bool has_proof = message.GetStringPiece(kPROF, &proof);
   bool has_cert = message.GetStringPiece(kCertificateTag, &cert_bytes);
   if (has_proof && has_cert) {
-    std::vector<QuicString> certs;
+    std::vector<std::string> certs;
     if (!CertCompressor::DecompressChain(cert_bytes, cached_certs,
                                          common_cert_sets, &certs)) {
       *error_details = "Certificate data invalid";
@@ -819,7 +819,7 @@
     QuicStringPiece chlo_hash,
     CachedState* cached,
     QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
-    QuicString* error_details) {
+    std::string* error_details) {
   DCHECK(error_details != nullptr);
 
   if ((rej.tag() != kREJ) && (rej.tag() != kSREJ)) {
@@ -836,29 +836,29 @@
 
   QuicStringPiece nonce;
   if (rej.GetStringPiece(kServerNonceTag, &nonce)) {
-    out_params->server_nonce = QuicString(nonce);
+    out_params->server_nonce = std::string(nonce);
   }
 
   if (rej.tag() == kSREJ) {
     QuicConnectionId connection_id;
 
-      QuicStringPiece connection_id_bytes;
-      if (!rej.GetStringPiece(kRCID, &connection_id_bytes)) {
-        *error_details = "Missing kRCID";
-        return QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND;
-      }
-      connection_id = QuicConnectionId(connection_id_bytes.data(),
-                                       connection_id_bytes.length());
-      if (!QuicUtils::IsConnectionIdValidForVersion(connection_id, version)) {
-        QUIC_PEER_BUG << "Received server-designated connection ID "
-                      << connection_id << " which is invalid with version "
-                      << QuicVersionToString(version);
-        *error_details = "Bad kRCID length";
-        return QUIC_CRYPTO_INTERNAL_ERROR;
-      }
+    QuicStringPiece connection_id_bytes;
+    if (!rej.GetStringPiece(kRCID, &connection_id_bytes)) {
+      *error_details = "Missing kRCID";
+      return QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND;
+    }
+    connection_id = QuicConnectionId(connection_id_bytes.data(),
+                                     connection_id_bytes.length());
+    if (!QuicUtils::IsConnectionIdValidForVersion(connection_id, version)) {
+      QUIC_PEER_BUG << "Received server-designated connection ID "
+                    << connection_id << " which is invalid with version "
+                    << QuicVersionToString(version);
+      *error_details = "Bad kRCID length";
+      return QUIC_CRYPTO_INTERNAL_ERROR;
+    }
     cached->add_server_designated_connection_id(connection_id);
     if (!nonce.empty()) {
-      cached->add_server_nonce(QuicString(nonce));
+      cached->add_server_nonce(std::string(nonce));
     }
     return QUIC_NO_ERROR;
   }
@@ -873,7 +873,7 @@
     const ParsedQuicVersionVector& negotiated_versions,
     CachedState* cached,
     QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
-    QuicString* error_details) {
+    std::string* error_details) {
   DCHECK(error_details != nullptr);
 
   QuicErrorCode valid = CryptoUtils::ValidateServerHello(
@@ -909,7 +909,7 @@
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
   }
 
-  QuicString hkdf_input;
+  std::string hkdf_input;
   const size_t label_len = strlen(QuicCryptoConfig::kForwardSecureLabel) + 1;
   hkdf_input.reserve(label_len + out_params->hkdf_input_suffix.size());
   hkdf_input.append(QuicCryptoConfig::kForwardSecureLabel, label_len);
@@ -936,7 +936,7 @@
     QuicStringPiece chlo_hash,
     CachedState* cached,
     QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
-    QuicString* error_details) {
+    std::string* error_details) {
   DCHECK(error_details != nullptr);
 
   if (server_config_update.tag() != kSCUP) {
@@ -976,7 +976,7 @@
   cached->InitializeFrom(*canonical_cached);
 }
 
-void QuicCryptoClientConfig::AddCanonicalSuffix(const QuicString& suffix) {
+void QuicCryptoClientConfig::AddCanonicalSuffix(const std::string& suffix) {
   canonical_suffixes_.push_back(suffix);
 }
 
diff --git a/quic/core/crypto/quic_crypto_client_config.h b/quic/core/crypto/quic_crypto_client_config.h
index 32df726..4c2004d 100644
--- a/quic/core/crypto/quic_crypto_client_config.h
+++ b/quic/core/crypto/quic_crypto_client_config.h
@@ -82,13 +82,13 @@
     ServerConfigState SetServerConfig(QuicStringPiece server_config,
                                       QuicWallTime now,
                                       QuicWallTime expiry_time,
-                                      QuicString* error_details);
+                                      std::string* error_details);
 
     // InvalidateServerConfig clears the cached server config (if any).
     void InvalidateServerConfig();
 
     // SetProof stores a cert chain, cert signed timestamp and signature.
-    void SetProof(const std::vector<QuicString>& certs,
+    void SetProof(const std::vector<std::string>& certs,
                   QuicStringPiece cert_sct,
                   QuicStringPiece chlo_hash,
                   QuicStringPiece signature);
@@ -109,12 +109,12 @@
     // generation_counter_ in sync.
     void SetProofInvalid();
 
-    const QuicString& server_config() const;
-    const QuicString& source_address_token() const;
-    const std::vector<QuicString>& certs() const;
-    const QuicString& cert_sct() const;
-    const QuicString& chlo_hash() const;
-    const QuicString& signature() const;
+    const std::string& server_config() const;
+    const std::string& source_address_token() const;
+    const std::vector<std::string>& certs() const;
+    const std::string& cert_sct() const;
+    const std::string& chlo_hash() const;
+    const std::string& signature() const;
     bool proof_valid() const;
     uint64_t generation_counter() const;
     const ProofVerifyDetails* proof_verify_details() const;
@@ -138,7 +138,7 @@
     QuicConnectionId GetNextServerDesignatedConnectionId();
 
     // Adds the servernonce to the queue of server nonces.
-    void add_server_nonce(const QuicString& server_nonce);
+    void add_server_nonce(const std::string& server_nonce);
 
     // If true, the crypto config contains at least one server nonce, and the
     // client should use one of these nonces.
@@ -147,7 +147,7 @@
     // This function should only be called when has_server_nonce is true.
     // Returns the next server_nonce specified by the server and removes it
     // from the queue of nonces.
-    QuicString GetNextServerNonce();
+    std::string GetNextServerNonce();
 
     // SetProofVerifyDetails takes ownership of |details|.
     void SetProofVerifyDetails(ProofVerifyDetails* details);
@@ -162,22 +162,22 @@
     // Returns false if there is a problem parsing the server config.
     bool Initialize(QuicStringPiece server_config,
                     QuicStringPiece source_address_token,
-                    const std::vector<QuicString>& certs,
-                    const QuicString& cert_sct,
+                    const std::vector<std::string>& certs,
+                    const std::string& cert_sct,
                     QuicStringPiece chlo_hash,
                     QuicStringPiece signature,
                     QuicWallTime now,
                     QuicWallTime expiration_time);
 
    private:
-    QuicString server_config_;         // A serialized handshake message.
-    QuicString source_address_token_;  // An opaque proof of IP ownership.
-    std::vector<QuicString> certs_;    // A list of certificates in leaf-first
-                                       // order.
-    QuicString cert_sct_;              // Signed timestamp of the leaf cert.
-    QuicString chlo_hash_;             // Hash of the CHLO message.
-    QuicString server_config_sig_;     // A signature of |server_config_|.
-    bool server_config_valid_;         // True if |server_config_| is correctly
+    std::string server_config_;         // A serialized handshake message.
+    std::string source_address_token_;  // An opaque proof of IP ownership.
+    std::vector<std::string> certs_;    // A list of certificates in leaf-first
+                                        // order.
+    std::string cert_sct_;              // Signed timestamp of the leaf cert.
+    std::string chlo_hash_;             // Hash of the CHLO message.
+    std::string server_config_sig_;     // A signature of |server_config_|.
+    bool server_config_valid_;          // True if |server_config_| is correctly
                                 // signed and |certs_| has been validated.
     QuicWallTime expiration_time_;  // Time when the config is no longer valid.
     // Generation counter associated with the |server_config_|, |certs_| and
@@ -194,7 +194,7 @@
     // that no connection-id is added twice.  Also, consider keeping the server
     // nonces and connection_ids together in one queue.
     QuicQueue<QuicConnectionId> server_designated_connection_ids_;
-    QuicQueue<QuicString> server_nonces_;
+    QuicQueue<std::string> server_nonces_;
   };
 
   // Used to filter server ids for partial config deletion.
@@ -262,7 +262,7 @@
       const ChannelIDKey* channel_id_key,
       QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
       CryptoHandshakeMessage* out,
-      QuicString* error_details) const;
+      std::string* error_details) const;
 
   // ProcessRejection processes a REJ message from a server and updates the
   // cached information about that server. After this, |IsComplete| may return
@@ -277,7 +277,7 @@
       QuicStringPiece chlo_hash,
       CachedState* cached,
       QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
-      QuicString* error_details);
+      std::string* error_details);
 
   // ProcessServerHello processes the message in |server_hello|, updates the
   // cached information about that server, writes the negotiated parameters to
@@ -295,7 +295,7 @@
       const ParsedQuicVersionVector& negotiated_versions,
       CachedState* cached,
       QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
-      QuicString* error_details);
+      std::string* error_details);
 
   // Processes the message in |server_update|, updating the cached source
   // address token, and server config.
@@ -309,7 +309,7 @@
       QuicStringPiece chlo_hash,
       CachedState* cached,
       QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
-      QuicString* error_details);
+      std::string* error_details);
 
   ProofVerifier* proof_verifier() const;
 
@@ -334,22 +334,22 @@
   // is expected to be shared among servers with the domain suffix. If a server
   // matches this suffix, then the server config from another server with the
   // suffix will be used to initialize the cached state for this server.
-  void AddCanonicalSuffix(const QuicString& suffix);
+  void AddCanonicalSuffix(const std::string& suffix);
 
   // Saves the |user_agent_id| that will be passed in QUIC's CHLO message.
-  void set_user_agent_id(const QuicString& user_agent_id) {
+  void set_user_agent_id(const std::string& user_agent_id) {
     user_agent_id_ = user_agent_id;
   }
 
   // Returns the user_agent_id that will be provided in the client hello
   // handshake message.
-  const QuicString& user_agent_id() const { return user_agent_id_; }
+  const std::string& user_agent_id() const { return user_agent_id_; }
 
   // Saves the |alpn| that will be passed in QUIC's CHLO message.
-  void set_alpn(const QuicString& alpn) { alpn_ = alpn; }
+  void set_alpn(const std::string& alpn) { alpn_ = alpn; }
 
   void set_pre_shared_key(QuicStringPiece psk) {
-    pre_shared_key_ = QuicString(psk);
+    pre_shared_key_ = std::string(psk);
   }
 
   bool pad_inchoate_hello() const { return pad_inchoate_hello_; }
@@ -373,9 +373,9 @@
       QuicWallTime now,
       QuicTransportVersion version,
       QuicStringPiece chlo_hash,
-      const std::vector<QuicString>& cached_certs,
+      const std::vector<std::string>& cached_certs,
       CachedState* cached,
-      QuicString* error_details);
+      std::string* error_details);
 
   // If the suffix of the hostname in |server_id| is in |canonical_suffixes_|,
   // then populate |cached| with the canonical cached state from
@@ -396,21 +396,21 @@
 
   // Contains list of suffixes (for exmaple ".c.youtube.com",
   // ".googlevideo.com") of canonical hostnames.
-  std::vector<QuicString> canonical_suffixes_;
+  std::vector<std::string> canonical_suffixes_;
 
   std::unique_ptr<ProofVerifier> proof_verifier_;
   std::unique_ptr<ChannelIDSource> channel_id_source_;
   bssl::UniquePtr<SSL_CTX> ssl_ctx_;
 
   // The |user_agent_id_| passed in QUIC's CHLO message.
-  QuicString user_agent_id_;
+  std::string user_agent_id_;
 
   // The |alpn_| passed in QUIC's CHLO message.
-  QuicString alpn_;
+  std::string alpn_;
 
   // If non-empty, the client will operate in the pre-shared key mode by
   // incorporating |pre_shared_key_| into the key schedule.
-  QuicString pre_shared_key_;
+  std::string pre_shared_key_;
 
   // In QUIC, technically, client hello should be fully padded.
   // However, fully padding on slow network connection (e.g. 50kbps) can add
diff --git a/quic/core/crypto/quic_crypto_client_config_test.cc b/quic/core/crypto/quic_crypto_client_config_test.cc
index 5e0ca6e..097f455 100644
--- a/quic/core/crypto/quic_crypto_client_config_test.cc
+++ b/quic/core/crypto/quic_crypto_client_config_test.cc
@@ -124,7 +124,7 @@
   QuicCryptoClientConfig::CachedState state;
   EXPECT_FALSE(state.has_server_nonce());
 
-  QuicString server_nonce = "nonce_1";
+  std::string server_nonce = "nonce_1";
   state.add_server_nonce(server_nonce);
   EXPECT_TRUE(state.has_server_nonce());
   EXPECT_EQ(server_nonce, state.GetNextServerNonce());
@@ -142,8 +142,8 @@
   EXPECT_FALSE(state.has_server_nonce());
 
   // Test FIFO behavior.
-  const QuicString first_nonce = "first_nonce";
-  const QuicString second_nonce = "second_nonce";
+  const std::string first_nonce = "first_nonce";
+  const std::string second_nonce = "second_nonce";
   state.add_server_nonce(first_nonce);
   state.add_server_nonce(second_nonce);
   EXPECT_TRUE(state.has_server_nonce());
@@ -194,7 +194,7 @@
   EXPECT_EQ(CreateQuicVersionLabel(QuicVersionMax()), cver);
   QuicStringPiece proof_nonce;
   EXPECT_TRUE(msg.GetStringPiece(kNONP, &proof_nonce));
-  EXPECT_EQ(QuicString(32, 'r'), proof_nonce);
+  EXPECT_EQ(std::string(32, 'r'), proof_nonce);
   QuicStringPiece user_agent_id;
   EXPECT_TRUE(msg.GetStringPiece(kUAID, &user_agent_id));
   EXPECT_EQ("quic-tester", user_agent_id);
@@ -261,7 +261,7 @@
   CryptoHandshakeMessage scfg;
   scfg.set_tag(kSCFG);
   scfg.SetStringPiece(kSCID, "12345678");
-  QuicString details;
+  std::string details;
   QuicWallTime now = QuicWallTime::FromUNIXSeconds(1);
   QuicWallTime expiry = QuicWallTime::FromUNIXSeconds(2);
   state.SetServerConfig(scfg.GetSerialized().AsStringPiece(), now, expiry,
@@ -289,7 +289,7 @@
   uint64_t future = 1;
   scfg.SetValue(kEXPY, future);
   scfg.SetStringPiece(kSCID, "12345678");
-  QuicString details;
+  std::string details;
   state.SetServerConfig(scfg.GetSerialized().AsStringPiece(),
                         QuicWallTime::FromUNIXSeconds(1),
                         QuicWallTime::FromUNIXSeconds(0), &details);
@@ -316,7 +316,7 @@
   QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params(
       new QuicCryptoNegotiatedParameters);
   QuicConnectionId kConnectionId = TestConnectionId(1234);
-  QuicString error_details;
+  std::string error_details;
   MockRandom rand;
   CryptoHandshakeMessage chlo;
   QuicServerId server_id("www.google.com", 443, false);
@@ -339,7 +339,7 @@
   QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params(
       new QuicCryptoNegotiatedParameters);
   QuicConnectionId kConnectionId = TestConnectionId(1234);
-  QuicString error_details;
+  std::string error_details;
   MockRandom rand;
   CryptoHandshakeMessage chlo;
   QuicServerId server_id("www.google.com", 443, false);
@@ -374,7 +374,7 @@
   QuicCryptoClientConfig::CachedState cached;
   QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params(
       new QuicCryptoNegotiatedParameters);
-  QuicString error;
+  std::string error;
   QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting(),
                                 TlsClientHandshaker::CreateSslCtx());
   EXPECT_EQ(QUIC_VERSION_NEGOTIATION_MISMATCH,
@@ -452,7 +452,7 @@
 
   // Create two states on different origins.
   struct TestCase {
-    TestCase(const QuicString& host, QuicCryptoClientConfig* config)
+    TestCase(const std::string& host, QuicCryptoClientConfig* config)
         : server_id(host, 443, false),
           state(config->LookupOrCreate(server_id)) {
       // TODO(rch): Populate other fields of |state|.
@@ -461,12 +461,12 @@
       uint64_t future = 1;
       scfg.SetValue(kEXPY, future);
       scfg.SetStringPiece(kSCID, "12345678");
-      QuicString details;
+      std::string details;
       state->SetServerConfig(scfg.GetSerialized().AsStringPiece(),
                              QuicWallTime::FromUNIXSeconds(0),
                              QuicWallTime::FromUNIXSeconds(future), &details);
 
-      std::vector<QuicString> certs(1);
+      std::vector<std::string> certs(1);
       certs[0] = "Hello Cert for " + host;
       state->SetProof(certs, "cert_sct", "chlo_hash", "signature");
       state->set_source_address_token("TOKEN");
@@ -542,7 +542,7 @@
   QuicCryptoClientConfig::CachedState cached;
   QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params(
       new QuicCryptoNegotiatedParameters);
-  QuicString error;
+  std::string error;
   QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting(),
                                 TlsClientHandshaker::CreateSslCtx());
   EXPECT_EQ(QUIC_NO_ERROR,
@@ -564,7 +564,7 @@
   QuicCryptoClientConfig::CachedState cached;
   QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params(
       new QuicCryptoNegotiatedParameters);
-  QuicString error;
+  std::string error;
   QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting(),
                                 TlsClientHandshaker::CreateSslCtx());
   EXPECT_EQ(QUIC_NO_ERROR,
@@ -584,7 +584,7 @@
   CryptoHandshakeMessage rej;
   crypto_test_utils::FillInDummyReject(&rej, /* stateless */ true);
   const QuicConnectionId kConnectionId = TestConnectionId(0xdeadbeef);
-  const QuicString server_nonce = "SERVER_NONCE";
+  const std::string server_nonce = "SERVER_NONCE";
   const uint64_t kConnectionId64 = TestConnectionIdToUInt64(kConnectionId);
   rej.SetValue(kRCID, kConnectionId64);
   rej.SetStringPiece(kServerNonceTag, server_nonce);
@@ -593,7 +593,7 @@
   QuicCryptoClientConfig::CachedState cached;
   QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params(
       new QuicCryptoNegotiatedParameters);
-  QuicString error;
+  std::string error;
   QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting(),
                                 TlsClientHandshaker::CreateSslCtx());
   EXPECT_EQ(QUIC_NO_ERROR,
@@ -617,7 +617,7 @@
   QuicCryptoClientConfig::CachedState cached;
   QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params(
       new QuicCryptoNegotiatedParameters);
-  QuicString error;
+  std::string error;
   QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting(),
                                 TlsClientHandshaker::CreateSslCtx());
   EXPECT_EQ(QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND,
@@ -643,7 +643,7 @@
   QuicCryptoClientConfig::CachedState cached;
   QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params(
       new QuicCryptoNegotiatedParameters);
-  QuicString error_details;
+  std::string error_details;
   EXPECT_EQ(QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER,
             config.ProcessServerHello(msg, EmptyQuicConnectionId(), version,
                                       supported_versions, &cached, out_params,
diff --git a/quic/core/crypto/quic_crypto_proof.h b/quic/core/crypto/quic_crypto_proof.h
index d70ad50..88255dc 100644
--- a/quic/core/crypto/quic_crypto_proof.h
+++ b/quic/core/crypto/quic_crypto_proof.h
@@ -15,9 +15,9 @@
   QuicCryptoProof();
 
   // Signature generated by ProofSource
-  QuicString signature;
+  std::string signature;
   // SCTList (RFC6962) to be sent to the client, if it supports receiving it.
-  QuicString leaf_cert_scts;
+  std::string leaf_cert_scts;
   // Should the Expect-CT header be sent on the connection where the
   // certificate is used.
   bool send_expect_ct_header;
diff --git a/quic/core/crypto/quic_crypto_server_config.cc b/quic/core/crypto/quic_crypto_server_config.cc
index 1cb0266..2b54c73 100644
--- a/quic/core/crypto/quic_crypto_server_config.cc
+++ b/quic/core/crypto/quic_crypto_server_config.cc
@@ -60,13 +60,13 @@
 
 const int kMaxTokenAddresses = 4;
 
-QuicString DeriveSourceAddressTokenKey(
+std::string DeriveSourceAddressTokenKey(
     QuicStringPiece source_address_token_secret) {
   QuicHKDF hkdf(source_address_token_secret, QuicStringPiece() /* no salt */,
                 "QUIC source address token key",
                 CryptoSecretBoxer::GetKeySize(), 0 /* no fixed IV needed */,
                 0 /* no subkey secret */);
-  return QuicString(hkdf.server_write_key());
+  return std::string(hkdf.server_write_key());
 }
 
 // Default source for creating KeyExchange objects.
@@ -75,7 +75,7 @@
   DefaultKeyExchangeSource() = default;
   ~DefaultKeyExchangeSource() override = default;
 
-  std::unique_ptr<KeyExchange> Create(QuicString /*server_config_id*/,
+  std::unique_ptr<KeyExchange> Create(std::string /*server_config_id*/,
                                       QuicTag type,
                                       QuicStringPiece private_key) override {
     if (private_key.empty()) {
@@ -237,7 +237,7 @@
   server_nonce_entropy->RandBytes(key_bytes.get(), key_size);
 
   server_nonce_boxer_.SetKeys(
-      {QuicString(reinterpret_cast<char*>(key_bytes.get()), key_size)});
+      {std::string(reinterpret_cast<char*>(key_bytes.get()), key_size)});
 }
 
 QuicCryptoServerConfig::~QuicCryptoServerConfig() {}
@@ -249,13 +249,13 @@
                                        const ConfigOptions& options) {
   CryptoHandshakeMessage msg;
 
-  const QuicString curve25519_private_key =
+  const std::string curve25519_private_key =
       Curve25519KeyExchange::NewPrivateKey(rand);
   std::unique_ptr<Curve25519KeyExchange> curve25519(
       Curve25519KeyExchange::New(curve25519_private_key));
   QuicStringPiece curve25519_public_value = curve25519->public_value();
 
-  QuicString encoded_public_values;
+  std::string encoded_public_values;
   // First three bytes encode the length of the public value.
   DCHECK_LT(curve25519_public_value.size(), (1U << 24));
   encoded_public_values.push_back(
@@ -267,7 +267,7 @@
   encoded_public_values.append(curve25519_public_value.data(),
                                curve25519_public_value.size());
 
-  QuicString p256_private_key;
+  std::string p256_private_key;
   if (options.p256) {
     p256_private_key = P256KeyExchange::NewPrivateKey();
     std::unique_ptr<P256KeyExchange> p256(
@@ -346,7 +346,7 @@
 
   std::unique_ptr<QuicServerConfigProtobuf> config(
       new QuicServerConfigProtobuf);
-  config->set_config(QuicString(serialized->AsStringPiece()));
+  config->set_config(std::string(serialized->AsStringPiece()));
   QuicServerConfigProtobuf::PrivateKey* curve25519_key = config->add_key();
   curve25519_key->set_tag(kC255);
   curve25519_key->set_private_key(curve25519_private_key);
@@ -478,12 +478,12 @@
 }
 
 void QuicCryptoServerConfig::SetSourceAddressTokenKeys(
-    const std::vector<QuicString>& keys) {
+    const std::vector<std::string>& keys) {
   source_address_token_boxer_.SetKeys(keys);
 }
 
 void QuicCryptoServerConfig::GetConfigIds(
-    std::vector<QuicString>* scids) const {
+    std::vector<std::string>* scids) const {
   QuicReaderMutexLock locked(&configs_lock_);
   for (auto it = configs_.begin(); it != configs_.end(); ++it) {
     scids->push_back(it->first);
@@ -556,7 +556,7 @@
         << "Deleting ProcessClientHelloHelper with a pending callback.";
   }
 
-  void Fail(QuicErrorCode error, const QuicString& error_details) {
+  void Fail(QuicErrorCode error, const std::string& error_details) {
     (*done_cb_)->Run(error, error_details, nullptr, nullptr, nullptr);
     DetachCallback();
   }
@@ -564,7 +564,7 @@
   void Succeed(std::unique_ptr<CryptoHandshakeMessage> message,
                std::unique_ptr<DiversificationNonce> diversification_nonce,
                std::unique_ptr<ProofSource::Details> proof_source_details) {
-    (*done_cb_)->Run(QUIC_NO_ERROR, QuicString(), std::move(message),
+    (*done_cb_)->Run(QUIC_NO_ERROR, std::string(), std::move(message),
                      std::move(diversification_nonce),
                      std::move(proof_source_details));
     DetachCallback();
@@ -721,7 +721,7 @@
   std::unique_ptr<ProofSource::Details> proof_source_details_;
   const KeyExchange::Factory& key_exchange_factory_;
   std::unique_ptr<CryptoHandshakeMessage> out_;
-  QuicString public_value_;
+  std::string public_value_;
   QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
       validate_chlo_result_;
   QuicConnectionId connection_id_;
@@ -764,7 +764,7 @@
       validate_chlo_result->client_hello;
   const ClientHelloInfo& info = validate_chlo_result->info;
 
-  QuicString error_details;
+  std::string error_details;
   QuicErrorCode valid = CryptoUtils::ValidateClientHello(
       client_hello, version, supported_versions, &error_details);
   if (valid != QUIC_NO_ERROR) {
@@ -818,7 +818,7 @@
     return;
   }
   DCHECK(proof_source_.get());
-  QuicString chlo_hash;
+  std::string chlo_hash;
   CryptoUtils::HashHandshakeMessage(client_hello, &chlo_hash,
                                     Perspective::IS_SERVER);
 
@@ -833,7 +833,7 @@
             total_framing_overhead, chlo_packet_size, requested_config,
             primary_config, std::move(done_cb)));
     proof_source_->GetProof(
-        server_address, QuicString(info.sni), primary_config->serialized,
+        server_address, std::string(info.sni), primary_config->serialized,
         version.transport_version, chlo_hash, std::move(cb));
     helper.DetachCallback();
     return;
@@ -1014,12 +1014,12 @@
     params->sni = QuicHostnameUtils::NormalizeHostname(info.sni);
   }
 
-  QuicString hkdf_suffix;
+  std::string hkdf_suffix;
   const QuicData& client_hello_serialized = client_hello.GetSerialized();
-    hkdf_suffix.reserve(connection_id.length() +
-                        client_hello_serialized.length() +
-                        requested_config->serialized.size());
-    hkdf_suffix.append(connection_id.data(), connection_id.length());
+  hkdf_suffix.reserve(connection_id.length() +
+                      client_hello_serialized.length() +
+                      requested_config->serialized.size());
+  hkdf_suffix.append(connection_id.data(), connection_id.length());
   hkdf_suffix.append(client_hello_serialized.data(),
                      client_hello_serialized.length());
   hkdf_suffix.append(requested_config->serialized);
@@ -1039,7 +1039,7 @@
 
     const QuicData& client_hello_copy_serialized =
         client_hello_copy.GetSerialized();
-    QuicString hkdf_input;
+    std::string hkdf_input;
     hkdf_input.append(QuicCryptoConfig::kCETVLabel,
                       strlen(QuicCryptoConfig::kCETVLabel) + 1);
     hkdf_input.append(connection_id.data(), connection_id.length());
@@ -1084,11 +1084,11 @@
         return;
       }
 
-      params->channel_id = QuicString(key);
+      params->channel_id = std::string(key);
     }
   }
 
-  QuicString hkdf_input;
+  std::string hkdf_input;
   size_t label_len = strlen(QuicCryptoConfig::kInitialLabel) + 1;
   hkdf_input.reserve(label_len + hkdf_suffix.size());
   hkdf_input.append(QuicCryptoConfig::kInitialLabel, label_len);
@@ -1108,25 +1108,25 @@
     return;
   }
 
-  QuicString forward_secure_public_value;
+  std::string forward_secure_public_value;
   std::unique_ptr<KeyExchange> forward_secure_key_exchange =
       key_exchange_factory.Create(rand);
   forward_secure_public_value =
-      QuicString(forward_secure_key_exchange->public_value());
+      std::string(forward_secure_key_exchange->public_value());
   if (!forward_secure_key_exchange->CalculateSharedKey(
           public_value, &params->forward_secure_premaster_secret)) {
     helper.Fail(QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER, "Invalid public value");
     return;
   }
 
-  QuicString forward_secure_hkdf_input;
+  std::string forward_secure_hkdf_input;
   label_len = strlen(QuicCryptoConfig::kForwardSecureLabel) + 1;
   forward_secure_hkdf_input.reserve(label_len + hkdf_suffix.size());
   forward_secure_hkdf_input.append(QuicCryptoConfig::kForwardSecureLabel,
                                    label_len);
   forward_secure_hkdf_input.append(hkdf_suffix);
 
-  QuicString shlo_nonce;
+  std::string shlo_nonce;
   shlo_nonce = NewServerNonce(rand, info.now);
   out->SetStringPiece(kServerNonceTag, shlo_nonce);
 
@@ -1162,7 +1162,7 @@
   configs_lock_.AssertReaderHeld();
 
   if (!requested_scid.empty()) {
-    auto it = configs_.find((QuicString(requested_scid)));
+    auto it = configs_.find((std::string(requested_scid)));
     if (it != configs_.end()) {
       // We'll use the config that the client requested in order to do
       // key-agreement.
@@ -1406,7 +1406,7 @@
   }
 
   QuicReferenceCountedPointer<ProofSource::Chain> chain =
-      proof_source_->GetCertChain(server_address, QuicString(info->sni));
+      proof_source_->GetCertChain(server_address, std::string(info->sni));
   if (!chain) {
     info->reject_reasons.push_back(SERVER_CONFIG_UNKNOWN_CONFIG_FAILURE);
   } else if (!ValidateExpectedLeafCertificate(client_hello, chain->certs)) {
@@ -1467,8 +1467,8 @@
     const QuicCryptoNegotiatedParameters& params,
     const CachedNetworkParameters* cached_network_params,
     std::unique_ptr<BuildServerConfigUpdateMessageResultCallback> cb) const {
-  QuicString serialized;
-  QuicString source_address_token;
+  std::string serialized;
+  std::string source_address_token;
   const CommonCertSets* common_cert_sets;
   {
     QuicReaderMutexLock locked(&configs_lock_);
@@ -1533,14 +1533,14 @@
     QuicTransportVersion version,
     QuicCompressedCertsCache* compressed_certs_cache,
     const CommonCertSets* common_cert_sets,
-    const QuicString& client_common_set_hashes,
-    const QuicString& client_cached_cert_hashes,
+    const std::string& client_common_set_hashes,
+    const std::string& client_cached_cert_hashes,
     bool sct_supported_by_client,
-    const QuicString& sni,
+    const std::string& sni,
     bool ok,
     const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
-    const QuicString& signature,
-    const QuicString& leaf_cert_sct,
+    const std::string& signature,
+    const std::string& leaf_cert_sct,
     std::unique_ptr<ProofSource::Details> details,
     CryptoHandshakeMessage message,
     std::unique_ptr<BuildServerConfigUpdateMessageResultCallback> cb) const {
@@ -1549,7 +1549,7 @@
     return;
   }
 
-  const QuicString compressed =
+  const std::string compressed =
       CompressChain(compressed_certs_cache, chain, client_common_set_hashes,
                     client_cached_cert_hashes, common_cert_sets);
 
@@ -1589,17 +1589,17 @@
                   << "with server-designated connection ID "
                   << server_designated_connection_id;
     out->set_tag(kSREJ);
-      if (!QuicUtils::IsConnectionIdValidForVersion(
-              server_designated_connection_id, version)) {
-        QUIC_BUG << "Tried to send server designated connection ID "
-                 << server_designated_connection_id
-                 << " which is invalid with version "
-                 << QuicVersionToString(version);
-        return;
-      }
-      out->SetStringPiece(
-          kRCID, QuicStringPiece(server_designated_connection_id.data(),
-                                 server_designated_connection_id.length()));
+    if (!QuicUtils::IsConnectionIdValidForVersion(
+            server_designated_connection_id, version)) {
+      QUIC_BUG << "Tried to send server designated connection ID "
+               << server_designated_connection_id
+               << " which is invalid with version "
+               << QuicVersionToString(version);
+      return;
+    }
+    out->SetStringPiece(
+        kRCID, QuicStringPiece(server_designated_connection_id.data(),
+                               server_designated_connection_id.length()));
   } else {
     out->set_tag(kREJ);
   }
@@ -1625,17 +1625,17 @@
 
   QuicStringPiece client_common_set_hashes;
   if (client_hello.GetStringPiece(kCCS, &client_common_set_hashes)) {
-    params->client_common_set_hashes = QuicString(client_common_set_hashes);
+    params->client_common_set_hashes = std::string(client_common_set_hashes);
   }
 
   QuicStringPiece client_cached_cert_hashes;
   if (client_hello.GetStringPiece(kCCRT, &client_cached_cert_hashes)) {
-    params->client_cached_cert_hashes = QuicString(client_cached_cert_hashes);
+    params->client_cached_cert_hashes = std::string(client_cached_cert_hashes);
   } else {
     params->client_cached_cert_hashes.clear();
   }
 
-  const QuicString compressed =
+  const std::string compressed =
       CompressChain(compressed_certs_cache, signed_config.chain,
                     params->client_common_set_hashes,
                     params->client_cached_cert_hashes, config.common_cert_sets);
@@ -1659,7 +1659,7 @@
                 "overhead calculation may underflow");
   bool should_return_sct =
       params->sct_supported_by_client && enable_serving_sct_;
-  const QuicString& cert_sct = signed_config.proof.leaf_cert_scts;
+  const std::string& cert_sct = signed_config.proof.leaf_cert_scts;
   const size_t sct_size = should_return_sct ? cert_sct.size() : 0;
   const size_t total_size =
       signed_config.proof.signature.size() + compressed.size() + sct_size;
@@ -1674,8 +1674,7 @@
         } else {
           // Log SNI and subject name for the leaf cert if its SCT is empty.
           // This is for debugging b/28342827.
-          const std::vector<quic::QuicString>& certs =
-              signed_config.chain->certs;
+          const std::vector<std::string>& certs = signed_config.chain->certs;
           QuicStringPiece ca_subject;
           if (!certs.empty()) {
             QuicCertUtils::ExtractSubjectNameFromDERCert(certs[0], &ca_subject);
@@ -1697,20 +1696,20 @@
   }
 }
 
-QuicString QuicCryptoServerConfig::CompressChain(
+std::string QuicCryptoServerConfig::CompressChain(
     QuicCompressedCertsCache* compressed_certs_cache,
     const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
-    const QuicString& client_common_set_hashes,
-    const QuicString& client_cached_cert_hashes,
+    const std::string& client_common_set_hashes,
+    const std::string& client_cached_cert_hashes,
     const CommonCertSets* common_sets) {
   // Check whether the compressed certs is available in the cache.
   DCHECK(compressed_certs_cache);
-  const QuicString* cached_value = compressed_certs_cache->GetCompressedCert(
+  const std::string* cached_value = compressed_certs_cache->GetCompressedCert(
       chain, client_common_set_hashes, client_cached_cert_hashes);
   if (cached_value) {
     return *cached_value;
   }
-  QuicString compressed =
+  std::string compressed =
       CertCompressor::CompressChain(chain->certs, client_common_set_hashes,
                                     client_cached_cert_hashes, common_sets);
   // Insert the newly compressed cert to cache.
@@ -1747,7 +1746,7 @@
     QUIC_LOG(WARNING) << "Server config message is missing SCID";
     return nullptr;
   }
-  config->id = QuicString(scid);
+  config->id = std::string(scid);
 
   if (msg->GetTaglist(kAEAD, &config->aead) != QUIC_NO_ERROR) {
     QUIC_LOG(WARNING) << "Server config message is missing AEAD";
@@ -1802,7 +1801,7 @@
 
   for (size_t i = 0; i < kexs_tags.size(); i++) {
     const QuicTag tag = kexs_tags[i];
-    QuicString private_key;
+    std::string private_key;
 
     config->kexs.push_back(tag);
 
@@ -1867,7 +1866,7 @@
   primary_config_changed_cb_ = std::move(cb);
 }
 
-QuicString QuicCryptoServerConfig::NewSourceAddressToken(
+std::string QuicCryptoServerConfig::NewSourceAddressToken(
     const Config& config,
     const SourceAddressTokens& previous_tokens,
     const QuicIpAddress& ip,
@@ -1922,7 +1921,7 @@
     const Config& config,
     QuicStringPiece token,
     SourceAddressTokens* tokens) const {
-  QuicString storage;
+  std::string storage;
   QuicStringPiece plaintext;
   if (!config.source_address_token_boxer->Unbox(token, &storage, &plaintext)) {
     return SOURCE_ADDRESS_TOKEN_DECRYPTION_FAILURE;
@@ -1999,8 +1998,8 @@
 static const size_t kServerNoncePlaintextSize =
     4 /* timestamp */ + 20 /* random bytes */;
 
-QuicString QuicCryptoServerConfig::NewServerNonce(QuicRandom* rand,
-                                                  QuicWallTime now) const {
+std::string QuicCryptoServerConfig::NewServerNonce(QuicRandom* rand,
+                                                   QuicWallTime now) const {
   const uint32_t timestamp = static_cast<uint32_t>(now.ToUNIXSeconds());
 
   uint8_t server_nonce[kServerNoncePlaintextSize];
@@ -2019,7 +2018,7 @@
 
 bool QuicCryptoServerConfig::ValidateExpectedLeafCertificate(
     const CryptoHandshakeMessage& client_hello,
-    const std::vector<QuicString>& certs) const {
+    const std::vector<std::string>& certs) const {
   if (certs.empty()) {
     return false;
   }
diff --git a/quic/core/crypto/quic_crypto_server_config.h b/quic/core/crypto/quic_crypto_server_config.h
index 9f91c9a..858c95e 100644
--- a/quic/core/crypto/quic_crypto_server_config.h
+++ b/quic/core/crypto/quic_crypto_server_config.h
@@ -76,7 +76,7 @@
   PrimaryConfigChangedCallback& operator=(const PrimaryConfigChangedCallback&) =
       delete;
   virtual ~PrimaryConfigChangedCallback();
-  virtual void Run(const QuicString& scid) = 0;
+  virtual void Run(const std::string& scid) = 0;
 };
 
 // Callback used to accept the result of the |client_hello| validation step.
@@ -92,7 +92,7 @@
     CryptoHandshakeMessage client_hello;
     ClientHelloInfo info;
     QuicErrorCode error_code;
-    QuicString error_details;
+    std::string error_details;
 
     // Populated if the CHLO STK contained a CachedNetworkParameters proto.
     CachedNetworkParameters cached_network_params;
@@ -121,7 +121,7 @@
       const ProcessClientHelloResultCallback&) = delete;
   virtual ~ProcessClientHelloResultCallback();
   virtual void Run(QuicErrorCode error,
-                   const QuicString& error_details,
+                   const std::string& error_details,
                    std::unique_ptr<CryptoHandshakeMessage> message,
                    std::unique_ptr<DiversificationNonce> diversification_nonce,
                    std::unique_ptr<ProofSource::Details> details) = 0;
@@ -163,7 +163,7 @@
 
   // Create a new KeyExchange of the specified type using the specified
   // private key.
-  virtual std::unique_ptr<KeyExchange> Create(QuicString /*server_config_id*/,
+  virtual std::unique_ptr<KeyExchange> Create(std::string /*server_config_id*/,
                                               QuicTag type,
                                               QuicStringPiece private_key) = 0;
 };
@@ -192,10 +192,10 @@
     QuicTagVector token_binding_params;
     // id contains the server config id for the resulting config. If empty, a
     // random id is generated.
-    QuicString id;
+    std::string id;
     // orbit contains the kOrbitSize bytes of the orbit value for the server
     // config. If |orbit| is empty then a random orbit is generated.
-    QuicString orbit;
+    std::string orbit;
     // p256 determines whether a P-256 public key will be included in the
     // server config. Note that this breaks deterministic server-config
     // generation since P-256 key generation doesn't use the QuicRandom given
@@ -262,10 +262,10 @@
   // decrypting a source address token.  Note that these keys are used *without*
   // passing them through a KDF, in contradistinction to the
   // |source_address_token_secret| argument to the constructor.
-  void SetSourceAddressTokenKeys(const std::vector<QuicString>& keys);
+  void SetSourceAddressTokenKeys(const std::vector<std::string>& keys);
 
   // Get the server config ids for all known configs.
-  void GetConfigIds(std::vector<QuicString>* scids) const;
+  void GetConfigIds(std::vector<std::string>* scids) const;
 
   // Checks |client_hello| for gross errors and determines whether it can be
   // shown to be fresh (i.e. not a replay).  The result of the validation step
@@ -429,7 +429,7 @@
   SSL_CTX* ssl_ctx() const;
 
   void set_pre_shared_key(QuicStringPiece psk) {
-    pre_shared_key_ = QuicString(psk);
+    pre_shared_key_ = std::string(psk);
   }
 
   bool pad_rej() const { return pad_rej_; }
@@ -455,9 +455,9 @@
     // getters/setters here.
     // |serialized| contains the bytes of this server config, suitable for
     // sending on the wire.
-    QuicString serialized;
+    std::string serialized;
     // id contains the SCID of this server config.
-    QuicString id;
+    std::string id;
     // orbit contains the orbit value for this config: an opaque identifier
     // used to identify clusters of server frontends.
     unsigned char orbit[kOrbitSize];
@@ -636,11 +636,11 @@
   // sets known locally and |client_common_set_hashes| contains the hashes of
   // the common sets known to the peer. |client_cached_cert_hashes| contains
   // 64-bit, FNV-1a hashes of certificates that the peer already possesses.
-  static QuicString CompressChain(
+  static std::string CompressChain(
       QuicCompressedCertsCache* compressed_certs_cache,
       const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
-      const QuicString& client_common_set_hashes,
-      const QuicString& client_cached_cert_hashes,
+      const std::string& client_common_set_hashes,
+      const std::string& client_cached_cert_hashes,
       const CommonCertSets* common_sets);
 
   // ParseConfigProtobuf parses the given config protobuf and returns a
@@ -651,7 +651,7 @@
 
   // NewSourceAddressToken returns a fresh source address token for the given
   // IP address. |cached_network_params| is optional, and can be nullptr.
-  QuicString NewSourceAddressToken(
+  std::string NewSourceAddressToken(
       const Config& config,
       const SourceAddressTokens& previous_tokens,
       const QuicIpAddress& ip,
@@ -696,7 +696,7 @@
       QuicWallTime now) const;
 
   // NewServerNonce generates and encrypts a random nonce.
-  QuicString NewServerNonce(QuicRandom* rand, QuicWallTime now) const;
+  std::string NewServerNonce(QuicRandom* rand, QuicWallTime now) const;
 
   // ValidateExpectedLeafCertificate checks the |client_hello| to see if it has
   // an XLCT tag, and if so, verifies that its value matches the hash of the
@@ -705,7 +705,7 @@
   // XLCT tag is present and valid. It returns false otherwise.
   bool ValidateExpectedLeafCertificate(
       const CryptoHandshakeMessage& client_hello,
-      const std::vector<QuicString>& certs) const;
+      const std::vector<std::string>& certs) const;
 
   // Returns true if the PDMD field from the client hello demands an X509
   // certificate.
@@ -742,10 +742,10 @@
     const QuicTransportVersion version_;
     QuicCompressedCertsCache* compressed_certs_cache_;
     const CommonCertSets* common_cert_sets_;
-    const QuicString client_common_set_hashes_;
-    const QuicString client_cached_cert_hashes_;
+    const std::string client_common_set_hashes_;
+    const std::string client_cached_cert_hashes_;
     const bool sct_supported_by_client_;
-    const QuicString sni_;
+    const std::string sni_;
     CryptoHandshakeMessage message_;
     std::unique_ptr<BuildServerConfigUpdateMessageResultCallback> cb_;
   };
@@ -757,14 +757,14 @@
       QuicTransportVersion version,
       QuicCompressedCertsCache* compressed_certs_cache,
       const CommonCertSets* common_cert_sets,
-      const QuicString& client_common_set_hashes,
-      const QuicString& client_cached_cert_hashes,
+      const std::string& client_common_set_hashes,
+      const std::string& client_cached_cert_hashes,
       bool sct_supported_by_client,
-      const QuicString& sni,
+      const std::string& sni,
       bool ok,
       const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
-      const QuicString& signature,
-      const QuicString& leaf_cert_sct,
+      const std::string& signature,
+      const std::string& leaf_cert_sct,
       std::unique_ptr<ProofSource::Details> details,
       CryptoHandshakeMessage message,
       std::unique_ptr<BuildServerConfigUpdateMessageResultCallback> cb) const;
@@ -837,7 +837,7 @@
 
   // If non-empty, the server will operate in the pre-shared key mode by
   // incorporating |pre_shared_key_| into the key schedule.
-  QuicString pre_shared_key_;
+  std::string pre_shared_key_;
 
   // Whether REJ message should be padded to max packet size.
   bool pad_rej_;
@@ -866,7 +866,7 @@
   // The server config that is used for this proof (and the rest of the
   // request).
   QuicReferenceCountedPointer<QuicCryptoServerConfig::Config> config;
-  QuicString primary_scid;
+  std::string primary_scid;
 
  protected:
   ~QuicSignedServerConfig() override;
diff --git a/quic/core/crypto/quic_crypto_server_config_test.cc b/quic/core/crypto/quic_crypto_server_config_test.cc
index 101be1d..6d38bde 100644
--- a/quic/core/crypto/quic_crypto_server_config_test.cc
+++ b/quic/core/crypto/quic_crypto_server_config_test.cc
@@ -58,11 +58,11 @@
                                 TlsServerHandshaker::CreateSslCtx());
   QuicCryptoServerConfigPeer peer(&server);
 
-  std::vector<QuicString> certs = {"testcert"};
+  std::vector<std::string> certs = {"testcert"};
   QuicReferenceCountedPointer<ProofSource::Chain> chain(
       new ProofSource::Chain(certs));
 
-  QuicString compressed = QuicCryptoServerConfigPeer::CompressChain(
+  std::string compressed = QuicCryptoServerConfigPeer::CompressChain(
       &compressed_certs_cache, chain, "", "", nullptr);
 
   EXPECT_EQ(compressed_certs_cache.Size(), 1u);
@@ -80,18 +80,18 @@
   QuicCryptoServerConfigPeer peer(&server);
 
   // Compress the certs for the first time.
-  std::vector<QuicString> certs = {"testcert"};
+  std::vector<std::string> certs = {"testcert"};
   QuicReferenceCountedPointer<ProofSource::Chain> chain(
       new ProofSource::Chain(certs));
-  QuicString common_certs = "";
-  QuicString cached_certs = "";
+  std::string common_certs = "";
+  std::string cached_certs = "";
 
-  QuicString compressed = QuicCryptoServerConfigPeer::CompressChain(
+  std::string compressed = QuicCryptoServerConfigPeer::CompressChain(
       &compressed_certs_cache, chain, common_certs, cached_certs, nullptr);
   EXPECT_EQ(compressed_certs_cache.Size(), 1u);
 
   // Compress the same certs, should use cache if available.
-  QuicString compressed2 = QuicCryptoServerConfigPeer::CompressChain(
+  std::string compressed2 = QuicCryptoServerConfigPeer::CompressChain(
       &compressed_certs_cache, chain, common_certs, cached_certs, nullptr);
   EXPECT_EQ(compressed, compressed2);
   EXPECT_EQ(compressed_certs_cache.Size(), 1u);
@@ -110,13 +110,13 @@
                                 TlsServerHandshaker::CreateSslCtx());
   QuicCryptoServerConfigPeer peer(&server);
 
-  std::vector<QuicString> certs = {"testcert"};
+  std::vector<std::string> certs = {"testcert"};
   QuicReferenceCountedPointer<ProofSource::Chain> chain(
       new ProofSource::Chain(certs));
-  QuicString common_certs = "";
-  QuicString cached_certs = "";
+  std::string common_certs = "";
+  std::string cached_certs = "";
 
-  QuicString compressed = QuicCryptoServerConfigPeer::CompressChain(
+  std::string compressed = QuicCryptoServerConfigPeer::CompressChain(
       &compressed_certs_cache, chain, common_certs, cached_certs, nullptr);
   EXPECT_EQ(compressed_certs_cache.Size(), 1u);
 
@@ -124,7 +124,7 @@
   QuicReferenceCountedPointer<ProofSource::Chain> chain2(
       new ProofSource::Chain(certs));
 
-  QuicString compressed2 = QuicCryptoServerConfigPeer::CompressChain(
+  std::string compressed2 = QuicCryptoServerConfigPeer::CompressChain(
       &compressed_certs_cache, chain2, common_certs, cached_certs, nullptr);
   EXPECT_EQ(compressed_certs_cache.Size(), 2u);
 
@@ -134,8 +134,8 @@
       crypto_test_utils::MockCommonCertSets(certs[0], set_hash, 1));
   QuicStringPiece different_common_certs(
       reinterpret_cast<const char*>(&set_hash), sizeof(set_hash));
-  QuicString compressed3 = QuicCryptoServerConfigPeer::CompressChain(
-      &compressed_certs_cache, chain, QuicString(different_common_certs),
+  std::string compressed3 = QuicCryptoServerConfigPeer::CompressChain(
+      &compressed_certs_cache, chain, std::string(different_common_certs),
       cached_certs, common_sets.get());
   EXPECT_EQ(compressed_certs_cache.Size(), 3u);
 }
@@ -162,20 +162,21 @@
         rand_, &clock_, QuicCryptoServerConfig::ConfigOptions()));
   }
 
-  QuicString NewSourceAddressToken(QuicString config_id,
-                                   const QuicIpAddress& ip) {
+  std::string NewSourceAddressToken(std::string config_id,
+                                    const QuicIpAddress& ip) {
     return NewSourceAddressToken(config_id, ip, nullptr);
   }
 
-  QuicString NewSourceAddressToken(QuicString config_id,
-                                   const QuicIpAddress& ip,
-                                   const SourceAddressTokens& previous_tokens) {
+  std::string NewSourceAddressToken(
+      std::string config_id,
+      const QuicIpAddress& ip,
+      const SourceAddressTokens& previous_tokens) {
     return peer_.NewSourceAddressToken(config_id, previous_tokens, ip, rand_,
                                        clock_.WallNow(), nullptr);
   }
 
-  QuicString NewSourceAddressToken(
-      QuicString config_id,
+  std::string NewSourceAddressToken(
+      std::string config_id,
       const QuicIpAddress& ip,
       CachedNetworkParameters* cached_network_params) {
     SourceAddressTokens previous_tokens;
@@ -183,14 +184,14 @@
                                        clock_.WallNow(), cached_network_params);
   }
 
-  HandshakeFailureReason ValidateSourceAddressTokens(QuicString config_id,
+  HandshakeFailureReason ValidateSourceAddressTokens(std::string config_id,
                                                      QuicStringPiece srct,
                                                      const QuicIpAddress& ip) {
     return ValidateSourceAddressTokens(config_id, srct, ip, nullptr);
   }
 
   HandshakeFailureReason ValidateSourceAddressTokens(
-      QuicString config_id,
+      std::string config_id,
       QuicStringPiece srct,
       const QuicIpAddress& ip,
       CachedNetworkParameters* cached_network_params) {
@@ -198,8 +199,8 @@
         config_id, srct, ip, clock_.WallNow(), cached_network_params);
   }
 
-  const QuicString kPrimary = "<primary>";
-  const QuicString kOverride = "Config with custom source address token key";
+  const std::string kPrimary = "<primary>";
+  const std::string kOverride = "Config with custom source address token key";
 
   QuicIpAddress ip4_;
   QuicIpAddress ip4_dual_;
@@ -219,9 +220,9 @@
 // to a single IP address and server config.
 TEST_F(SourceAddressTokenTest, SourceAddressToken) {
   // Primary config generates configs that validate successfully.
-  const QuicString token4 = NewSourceAddressToken(kPrimary, ip4_);
-  const QuicString token4d = NewSourceAddressToken(kPrimary, ip4_dual_);
-  const QuicString token6 = NewSourceAddressToken(kPrimary, ip6_);
+  const std::string token4 = NewSourceAddressToken(kPrimary, ip4_);
+  const std::string token4d = NewSourceAddressToken(kPrimary, ip4_dual_);
+  const std::string token6 = NewSourceAddressToken(kPrimary, ip6_);
   EXPECT_EQ(HANDSHAKE_OK, ValidateSourceAddressTokens(kPrimary, token4, ip4_));
   ASSERT_EQ(HANDSHAKE_OK,
             ValidateSourceAddressTokens(kPrimary, token4, ip4_dual_));
@@ -236,7 +237,7 @@
 }
 
 TEST_F(SourceAddressTokenTest, SourceAddressTokenExpiration) {
-  const QuicString token = NewSourceAddressToken(kPrimary, ip4_);
+  const std::string token = NewSourceAddressToken(kPrimary, ip4_);
 
   // Validation fails if the token is from the future.
   clock_.AdvanceTime(QuicTime::Delta::FromSeconds(-3600 * 2));
@@ -254,7 +255,7 @@
   // that this gets written to ValidateSourceAddressToken output argument.
   CachedNetworkParameters cached_network_params_input;
   cached_network_params_input.set_bandwidth_estimate_bytes_per_second(1234);
-  const QuicString token4_with_cached_network_params =
+  const std::string token4_with_cached_network_params =
       NewSourceAddressToken(kPrimary, ip4_, &cached_network_params_input);
 
   CachedNetworkParameters cached_network_params_output;
@@ -277,7 +278,7 @@
   previous_token.set_timestamp(now.ToUNIXSeconds());
   SourceAddressTokens previous_tokens;
   (*previous_tokens.add_tokens()) = previous_token;
-  const QuicString token4or6 =
+  const std::string token4or6 =
       NewSourceAddressToken(kPrimary, ip4_, previous_tokens);
 
   EXPECT_EQ(HANDSHAKE_OK,
@@ -346,7 +347,7 @@
           QuicCryptoServerConfig::GenerateConfig(rand_, &clock_, options);
       protobuf->set_primary_time(primary_time);
       protobuf->set_priority(priority);
-      if (QuicString(server_config_id).find("INVALID") == 0) {
+      if (std::string(server_config_id).find("INVALID") == 0) {
         protobuf->clear_key();
         has_invalid = true;
       }
@@ -365,7 +366,7 @@
 };
 
 TEST_F(CryptoServerConfigsTest, NoConfigs) {
-  test_peer_.CheckConfigs(std::vector<std::pair<QuicString, bool>>());
+  test_peer_.CheckConfigs(std::vector<std::pair<std::string, bool>>());
 }
 
 TEST_F(CryptoServerConfigsTest, MakePrimaryFirst) {
diff --git a/quic/core/crypto/quic_decrypter.cc b/quic/core/crypto/quic_decrypter.cc
index d2aa28d..1ab67ba 100644
--- a/quic/core/crypto/quic_decrypter.cc
+++ b/quic/core/crypto/quic_decrypter.cc
@@ -55,14 +55,14 @@
                                             const DiversificationNonce& nonce,
                                             size_t key_size,
                                             size_t nonce_prefix_size,
-                                            QuicString* out_key,
-                                            QuicString* out_nonce_prefix) {
-  QuicHKDF hkdf((QuicString(preliminary_key)) + (QuicString(nonce_prefix)),
+                                            std::string* out_key,
+                                            std::string* out_nonce_prefix) {
+  QuicHKDF hkdf((std::string(preliminary_key)) + (std::string(nonce_prefix)),
                 QuicStringPiece(nonce.data(), nonce.size()),
                 "QUIC key diversification", 0, key_size, 0, nonce_prefix_size,
                 0);
-  *out_key = QuicString(hkdf.server_write_key());
-  *out_nonce_prefix = QuicString(hkdf.server_write_iv());
+  *out_key = std::string(hkdf.server_write_key());
+  *out_nonce_prefix = std::string(hkdf.server_write_iv());
 }
 
 }  // namespace quic
diff --git a/quic/core/crypto/quic_decrypter.h b/quic/core/crypto/quic_decrypter.h
index c7c2ccc..f55b00b 100644
--- a/quic/core/crypto/quic_decrypter.h
+++ b/quic/core/crypto/quic_decrypter.h
@@ -73,8 +73,8 @@
                                       const DiversificationNonce& nonce,
                                       size_t key_size,
                                       size_t nonce_prefix_size,
-                                      QuicString* out_key,
-                                      QuicString* out_nonce_prefix);
+                                      std::string* out_key,
+                                      std::string* out_nonce_prefix);
 };
 
 }  // namespace quic
diff --git a/quic/core/crypto/quic_hkdf_test.cc b/quic/core/crypto/quic_hkdf_test.cc
index f8c53c6..fbf2860 100644
--- a/quic/core/crypto/quic_hkdf_test.cc
+++ b/quic/core/crypto/quic_hkdf_test.cc
@@ -70,10 +70,10 @@
     const HKDFInput& test(kHKDFInputs[i]);
     SCOPED_TRACE(i);
 
-    const QuicString key = QuicTextUtils::HexDecode(test.key_hex);
-    const QuicString salt = QuicTextUtils::HexDecode(test.salt_hex);
-    const QuicString info = QuicTextUtils::HexDecode(test.info_hex);
-    const QuicString expected = QuicTextUtils::HexDecode(test.output_hex);
+    const std::string key = QuicTextUtils::HexDecode(test.key_hex);
+    const std::string salt = QuicTextUtils::HexDecode(test.salt_hex);
+    const std::string info = QuicTextUtils::HexDecode(test.info_hex);
+    const std::string expected = QuicTextUtils::HexDecode(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_test.cc b/quic/core/crypto/transport_parameters_test.cc
index 8a81841..23b18e5 100644
--- a/quic/core/crypto/transport_parameters_test.cc
+++ b/quic/core/crypto/transport_parameters_test.cc
@@ -412,7 +412,7 @@
   orig_params.idle_timeout = 56;
 
   orig_params.google_quic_params = QuicMakeUnique<CryptoHandshakeMessage>();
-  const QuicString kTestString = "test string";
+  const std::string kTestString = "test string";
   orig_params.google_quic_params->SetStringPiece(42, kTestString);
   const uint32_t kTestValue = 12;
   orig_params.google_quic_params->SetValue(1337, kTestValue);