Replace QuicString with std::string, pass 1
This replaces QuicString with std::string in all of the "QUIC proper". I will
delete QuicString once all code using it is gone.
gfe-relnote: n/a (no functional change)
PiperOrigin-RevId: 237872023
Change-Id: I82de62c9855516b15039734d05155917e68ff4ee
diff --git a/quic/core/chlo_extractor_test.cc b/quic/core/chlo_extractor_test.cc
index 1e0b6f5..cb5fd59 100644
--- a/quic/core/chlo_extractor_test.cc
+++ b/quic/core/chlo_extractor_test.cc
@@ -35,12 +35,12 @@
QuicConnectionId connection_id() const { return connection_id_; }
QuicTransportVersion transport_version() const { return version_; }
- const QuicString& chlo() const { return chlo_; }
+ const std::string& chlo() const { return chlo_; }
private:
QuicConnectionId connection_id_;
QuicTransportVersion version_;
- QuicString chlo_;
+ std::string chlo_;
};
class ChloExtractorTest : public QuicTest {
@@ -105,7 +105,7 @@
CryptoHandshakeMessage client_hello;
client_hello.set_tag(kCHLO);
- QuicString client_hello_str(client_hello.GetSerialized().AsStringPiece());
+ std::string client_hello_str(client_hello.GetSerialized().AsStringPiece());
// Construct a CHLO with each supported version
for (ParsedQuicVersion version : AllSupportedVersions()) {
SCOPED_TRACE(version);
@@ -135,7 +135,7 @@
CryptoHandshakeMessage client_hello;
client_hello.set_tag(kCHLO);
- QuicString client_hello_str(client_hello.GetSerialized().AsStringPiece());
+ std::string client_hello_str(client_hello.GetSerialized().AsStringPiece());
MakePacket(AllSupportedVersions()[0], client_hello_str,
/*munge_offset*/ false, /*munge_stream_id*/ true);
EXPECT_FALSE(ChloExtractor::Extract(*packet_, AllSupportedVersions(), {},
@@ -147,7 +147,7 @@
CryptoHandshakeMessage client_hello;
client_hello.set_tag(kCHLO);
- QuicString client_hello_str(client_hello.GetSerialized().AsStringPiece());
+ std::string client_hello_str(client_hello.GetSerialized().AsStringPiece());
MakePacket(AllSupportedVersions()[0], client_hello_str, /*munge_offset*/ true,
/*munge_stream_id*/ false);
EXPECT_FALSE(ChloExtractor::Extract(*packet_, AllSupportedVersions(), {},
diff --git a/quic/core/congestion_control/bbr_sender.cc b/quic/core/congestion_control/bbr_sender.cc
index 6a7fe2b..c119135 100644
--- a/quic/core/congestion_control/bbr_sender.cc
+++ b/quic/core/congestion_control/bbr_sender.cc
@@ -851,7 +851,7 @@
recovery_window_ = std::max(min_congestion_window_, recovery_window_);
}
-QuicString BbrSender::GetDebugState() const {
+std::string BbrSender::GetDebugState() const {
std::ostringstream stream;
stream << ExportDebugState();
return stream.str();
@@ -875,7 +875,7 @@
return DebugState(*this);
}
-static QuicString ModeToString(BbrSender::Mode mode) {
+static std::string ModeToString(BbrSender::Mode mode) {
switch (mode) {
case BbrSender::STARTUP:
return "STARTUP";
diff --git a/quic/core/congestion_control/bbr_sender.h b/quic/core/congestion_control/bbr_sender.h
index 37e2695..efde0e5 100644
--- a/quic/core/congestion_control/bbr_sender.h
+++ b/quic/core/congestion_control/bbr_sender.h
@@ -129,7 +129,7 @@
QuicByteCount GetCongestionWindow() const override;
QuicByteCount GetSlowStartThreshold() const override;
CongestionControlType GetCongestionControlType() const override;
- QuicString GetDebugState() const override;
+ std::string GetDebugState() const override;
void OnApplicationLimited(QuicByteCount bytes_in_flight) override;
// End implementation of SendAlgorithmInterface.
diff --git a/quic/core/congestion_control/send_algorithm_interface.h b/quic/core/congestion_control/send_algorithm_interface.h
index 5df9a93..333a085 100644
--- a/quic/core/congestion_control/send_algorithm_interface.h
+++ b/quic/core/congestion_control/send_algorithm_interface.h
@@ -124,7 +124,7 @@
// Retrieves debugging information about the current state of the
// send algorithm.
- virtual QuicString GetDebugState() const = 0;
+ virtual std::string GetDebugState() const = 0;
// Called when the connection has no outstanding data to send. Specifically,
// this means that none of the data streams are write-blocked, there are no
diff --git a/quic/core/congestion_control/send_algorithm_test.cc b/quic/core/congestion_control/send_algorithm_test.cc
index d7bfd85..3b93696 100644
--- a/quic/core/congestion_control/send_algorithm_test.cc
+++ b/quic/core/congestion_control/send_algorithm_test.cc
@@ -132,7 +132,8 @@
const CongestionControlType congestion_control_type;
};
-QuicString TestParamToString(const testing::TestParamInfo<TestParams>& params) {
+std::string TestParamToString(
+ const testing::TestParamInfo<TestParams>& params) {
return QuicStrCat(
CongestionControlTypeToString(params.param.congestion_control_type), "_");
}
@@ -268,7 +269,8 @@
SendAlgorithmInterface* sender_;
};
-INSTANTIATE_TEST_SUITE_P(SendAlgorithmTests, SendAlgorithmTest,
+INSTANTIATE_TEST_SUITE_P(SendAlgorithmTests,
+ SendAlgorithmTest,
::testing::ValuesIn(GetTestParams()),
TestParamToString);
diff --git a/quic/core/congestion_control/tcp_cubic_sender_bytes.cc b/quic/core/congestion_control/tcp_cubic_sender_bytes.cc
index 5b843eb..4eefb46 100644
--- a/quic/core/congestion_control/tcp_cubic_sender_bytes.cc
+++ b/quic/core/congestion_control/tcp_cubic_sender_bytes.cc
@@ -260,7 +260,7 @@
HandleRetransmissionTimeout();
}
-QuicString TcpCubicSenderBytes::GetDebugState() const {
+std::string TcpCubicSenderBytes::GetDebugState() const {
return "";
}
diff --git a/quic/core/congestion_control/tcp_cubic_sender_bytes.h b/quic/core/congestion_control/tcp_cubic_sender_bytes.h
index 0ecb6f4..080a92d 100644
--- a/quic/core/congestion_control/tcp_cubic_sender_bytes.h
+++ b/quic/core/congestion_control/tcp_cubic_sender_bytes.h
@@ -73,7 +73,7 @@
bool InSlowStart() const override;
bool InRecovery() const override;
bool ShouldSendProbingPacket() const override;
- QuicString GetDebugState() const override;
+ std::string GetDebugState() const override;
void OnApplicationLimited(QuicByteCount bytes_in_flight) override;
// End implementation of SendAlgorithmInterface.
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, ¶ms->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);
diff --git a/quic/core/frames/quic_application_close_frame.h b/quic/core/frames/quic_application_close_frame.h
index b9b84dd..6a85265 100644
--- a/quic/core/frames/quic_application_close_frame.h
+++ b/quic/core/frames/quic_application_close_frame.h
@@ -21,7 +21,7 @@
const QuicApplicationCloseFrame& frame);
QuicErrorCode error_code;
- QuicString error_details;
+ std::string error_details;
};
} // namespace quic
diff --git a/quic/core/frames/quic_connection_close_frame.cc b/quic/core/frames/quic_connection_close_frame.cc
index 51969c6..55d356b 100644
--- a/quic/core/frames/quic_connection_close_frame.cc
+++ b/quic/core/frames/quic_connection_close_frame.cc
@@ -10,14 +10,14 @@
: error_code(QUIC_NO_ERROR), frame_type(0) {}
QuicConnectionCloseFrame::QuicConnectionCloseFrame(QuicErrorCode error_code,
- QuicString error_details)
+ std::string error_details)
: error_code(error_code),
error_details(std::move(error_details)),
frame_type(0) {}
QuicConnectionCloseFrame::QuicConnectionCloseFrame(
QuicIetfTransportErrorCodes ietf_error_code,
- QuicString error_details,
+ std::string error_details,
uint64_t frame_type)
: ietf_error_code(ietf_error_code),
error_details(std::move(error_details)),
diff --git a/quic/core/frames/quic_connection_close_frame.h b/quic/core/frames/quic_connection_close_frame.h
index 2bbbe73..1b909ce 100644
--- a/quic/core/frames/quic_connection_close_frame.h
+++ b/quic/core/frames/quic_connection_close_frame.h
@@ -16,9 +16,9 @@
struct QUIC_EXPORT_PRIVATE QuicConnectionCloseFrame {
QuicConnectionCloseFrame();
- QuicConnectionCloseFrame(QuicErrorCode error_code, QuicString error_details);
+ QuicConnectionCloseFrame(QuicErrorCode error_code, std::string error_details);
QuicConnectionCloseFrame(QuicIetfTransportErrorCodes ietf_error_code,
- QuicString error_details,
+ std::string error_details,
uint64_t frame_type);
friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
@@ -33,7 +33,7 @@
QuicErrorCode error_code;
QuicIetfTransportErrorCodes ietf_error_code;
};
- QuicString error_details;
+ std::string error_details;
// Contains the type of frame that triggered the connection close. Made a
// uint64, as opposed to the QuicIetfFrameType, to support possible
diff --git a/quic/core/frames/quic_goaway_frame.cc b/quic/core/frames/quic_goaway_frame.cc
index ff034f0..53dca54 100644
--- a/quic/core/frames/quic_goaway_frame.cc
+++ b/quic/core/frames/quic_goaway_frame.cc
@@ -16,7 +16,7 @@
QuicGoAwayFrame::QuicGoAwayFrame(QuicControlFrameId control_frame_id,
QuicErrorCode error_code,
QuicStreamId last_good_stream_id,
- const QuicString& reason)
+ const std::string& reason)
: control_frame_id(control_frame_id),
error_code(error_code),
last_good_stream_id(last_good_stream_id),
diff --git a/quic/core/frames/quic_goaway_frame.h b/quic/core/frames/quic_goaway_frame.h
index 085e915..03d6273 100644
--- a/quic/core/frames/quic_goaway_frame.h
+++ b/quic/core/frames/quic_goaway_frame.h
@@ -18,7 +18,7 @@
QuicGoAwayFrame(QuicControlFrameId control_frame_id,
QuicErrorCode error_code,
QuicStreamId last_good_stream_id,
- const QuicString& reason);
+ const std::string& reason);
friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
const QuicGoAwayFrame& g);
@@ -28,7 +28,7 @@
QuicControlFrameId control_frame_id;
QuicErrorCode error_code;
QuicStreamId last_good_stream_id;
- QuicString reason_phrase;
+ std::string reason_phrase;
};
} // namespace quic
diff --git a/quic/core/frames/quic_new_token_frame.cc b/quic/core/frames/quic_new_token_frame.cc
index c2f4e74..6e36866 100644
--- a/quic/core/frames/quic_new_token_frame.cc
+++ b/quic/core/frames/quic_new_token_frame.cc
@@ -12,7 +12,7 @@
: control_frame_id(kInvalidControlFrameId) {}
QuicNewTokenFrame::QuicNewTokenFrame(QuicControlFrameId control_frame_id,
- QuicString token)
+ std::string token)
: control_frame_id(control_frame_id), token(token) {}
std::ostream& operator<<(std::ostream& os, const QuicNewTokenFrame& s) {
diff --git a/quic/core/frames/quic_new_token_frame.h b/quic/core/frames/quic_new_token_frame.h
index 6fb0ea4..5a063a3 100644
--- a/quic/core/frames/quic_new_token_frame.h
+++ b/quic/core/frames/quic_new_token_frame.h
@@ -17,7 +17,7 @@
struct QUIC_EXPORT_PRIVATE QuicNewTokenFrame {
QuicNewTokenFrame();
- QuicNewTokenFrame(QuicControlFrameId control_frame_id, QuicString token);
+ QuicNewTokenFrame(QuicControlFrameId control_frame_id, std::string token);
friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
std::ostream& os,
@@ -27,7 +27,7 @@
// and non-zero when sent.
QuicControlFrameId control_frame_id;
- QuicString token;
+ std::string token;
};
static_assert(sizeof(QuicNewTokenFrame) <= 64,
"Keep the QuicNewTokenFrame size to a cacheline.");
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index c26ffa6..d439e95 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -622,7 +622,7 @@
// Default is true.
bool connect_to_server_on_initialize_;
QuicSocketAddress server_address_;
- QuicString server_hostname_;
+ std::string server_hostname_;
QuicMemoryCacheBackend memory_cache_backend_;
std::unique_ptr<ServerThread> server_thread_;
std::unique_ptr<QuicTestClient> client_;
@@ -637,8 +637,8 @@
size_t chlo_multiplier_;
QuicTestServer::StreamFactory* stream_factory_;
bool support_server_push_;
- QuicString pre_shared_key_client_;
- QuicString pre_shared_key_server_;
+ std::string pre_shared_key_client_;
+ std::string pre_shared_key_server_;
QuicConnectionId* override_connection_id_;
};
@@ -854,8 +854,8 @@
TEST_P(EndToEndTestWithTls, RequestOverMultiplePackets) {
// Send a large enough request to guarantee fragmentation.
- QuicString huge_request =
- "/some/path?query=" + QuicString(kMaxPacketSize, '.');
+ std::string huge_request =
+ "/some/path?query=" + std::string(kMaxPacketSize, '.');
AddToCache(huge_request, 200, kBarResponseBody);
ASSERT_TRUE(Initialize());
@@ -866,8 +866,8 @@
TEST_P(EndToEndTestWithTls, MultiplePacketsRandomOrder) {
// Send a large enough request to guarantee fragmentation.
- QuicString huge_request =
- "/some/path?query=" + QuicString(kMaxPacketSize, '.');
+ std::string huge_request =
+ "/some/path?query=" + std::string(kMaxPacketSize, '.');
AddToCache(huge_request, 200, kBarResponseBody);
ASSERT_TRUE(Initialize());
@@ -903,7 +903,7 @@
EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
// 1 MB body.
- QuicString body(1024 * 1024, 'a');
+ std::string body(1024 * 1024, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
headers[":path"] = "/foo";
@@ -924,7 +924,7 @@
EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
// 100 KB body.
- QuicString body(100 * 1024, 'a');
+ std::string body(100 * 1024, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
headers[":path"] = "/foo";
@@ -952,7 +952,7 @@
SetPacketLossPercentage(30);
// 10 KB body.
- QuicString body(1024 * 10, 'a');
+ std::string body(1024 * 10, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
headers[":path"] = "/foo";
@@ -983,7 +983,7 @@
SetPacketLossPercentage(30);
// 10 KB body.
- QuicString body(1024 * 10, 'a');
+ std::string body(1024 * 10, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
headers[":path"] = "/foo";
@@ -1011,7 +1011,7 @@
client_writer_->set_fake_blocked_socket_percentage(10);
// 10 KB body.
- QuicString body(1024 * 10, 'a');
+ std::string body(1024 * 10, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
headers[":path"] = "/foo";
@@ -1031,7 +1031,7 @@
SetReorderPercentage(30);
// 1 MB body.
- QuicString body(1024 * 1024, 'a');
+ std::string body(1024 * 1024, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
headers[":path"] = "/foo";
@@ -1047,7 +1047,7 @@
// a 0-RTT handshake for the next request.
ASSERT_TRUE(Initialize());
- QuicString body(20480, 'a');
+ std::string body(20480, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
headers[":path"] = "/foo";
@@ -1187,7 +1187,7 @@
// a 0-RTT handshake for the next request.
ASSERT_TRUE(Initialize());
- QuicString body(20480, 'a');
+ std::string body(20480, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
headers[":path"] = "/foo";
@@ -1302,7 +1302,7 @@
EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
// 1 MB body.
- QuicString body(1024 * 1024, 'a');
+ std::string body(1024 * 1024, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
headers[":path"] = "/foo";
@@ -1363,7 +1363,7 @@
ASSERT_TRUE(Initialize());
EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
- QuicString body(kMaxPacketSize, 'a');
+ std::string body(kMaxPacketSize, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
headers[":path"] = "/foo";
@@ -1387,15 +1387,15 @@
ASSERT_TRUE(Initialize());
EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
- QuicString body(kMaxPacketSize, 'a');
+ std::string body(kMaxPacketSize, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
headers[":path"] = "/foo";
headers[":scheme"] = "https";
headers[":authority"] = server_hostname_;
- headers["key1"] = QuicString(15 * 1024, 'a');
- headers["key2"] = QuicString(15 * 1024, 'a');
- headers["key3"] = QuicString(15 * 1024, 'a');
+ headers["key1"] = std::string(15 * 1024, 'a');
+ headers["key2"] = std::string(15 * 1024, 'a');
+ headers["key3"] = std::string(15 * 1024, 'a');
client_->SendCustomSynchronousRequest(headers, body);
EXPECT_EQ(QUIC_HEADERS_TOO_LARGE, client_->stream_error());
@@ -1406,7 +1406,7 @@
ASSERT_TRUE(Initialize());
EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
- QuicString large_body(1024 * 1024, 'a');
+ std::string large_body(1024 * 1024, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
headers[":path"] = "/foo";
@@ -1765,7 +1765,7 @@
SetPacketLossPercentage(1);
}
ASSERT_TRUE(Initialize());
- QuicString large_body(10240, 'a');
+ std::string large_body(10240, 'a');
int max_streams = 100;
AddToCache("/large_response", 200, large_body);
@@ -1785,7 +1785,7 @@
TEST_P(EndToEndTestWithTls, StreamCancelErrorTest) {
ASSERT_TRUE(Initialize());
- QuicString small_body(256, 'a');
+ std::string small_body(256, 'a');
AddToCache("/small_response", 200, small_body);
@@ -2166,7 +2166,7 @@
public:
void OnCompleteResponse(QuicStreamId id,
const SpdyHeaderBlock& response_headers,
- const QuicString& response_body) override {
+ const std::string& response_body) override {
QUIC_DVLOG(1) << "response for stream " << id << " "
<< response_headers.DebugString() << "\n"
<< response_body;
@@ -2201,8 +2201,8 @@
// Test the AckNotifier's ability to track multiple packets by making the
// request body exceed the size of a single packet.
- QuicString request_string =
- "a request body bigger than one packet" + QuicString(kMaxPacketSize, '.');
+ std::string request_string = "a request body bigger than one packet" +
+ std::string(kMaxPacketSize, '.');
// The TestAckListener will cause a failure if not notified.
QuicReferenceCountedPointer<TestAckListener> ack_listener(
@@ -2492,7 +2492,7 @@
EmptyQuicConnectionId(), false, false, 1, "At least 20 characters.",
CONNECTION_ID_PRESENT, CONNECTION_ID_ABSENT, PACKET_4BYTE_PACKET_NUMBER));
// Damage the encrypted data.
- QuicString damaged_packet(packet->data(), packet->length());
+ std::string damaged_packet(packet->data(), packet->length());
damaged_packet[30] ^= 0x01;
QUIC_DLOG(INFO) << "Sending bad packet.";
client_writer_->WritePacket(
@@ -2544,7 +2544,7 @@
QuicStreamId id,
QuicSpdySession* session,
QuicSimpleServerBackend* quic_simple_server_backend,
- QuicString response_body)
+ std::string response_body)
: QuicSimpleServerStream(id,
session,
BIDIRECTIONAL,
@@ -2566,12 +2566,12 @@
SendHeadersAndBody(std::move(headers), response_body_);
}
- QuicString response_body_;
+ std::string response_body_;
};
class StreamWithErrorFactory : public QuicTestServer::StreamFactory {
public:
- explicit StreamWithErrorFactory(QuicString response_body)
+ explicit StreamWithErrorFactory(std::string response_body)
: response_body_(std::move(response_body)) {}
~StreamWithErrorFactory() override = default;
@@ -2585,7 +2585,7 @@
}
private:
- QuicString response_body_;
+ std::string response_body_;
};
// A test server stream that drops all received body.
@@ -2665,7 +2665,7 @@
protected:
void SendResponse() override {
QuicBackendResponse response;
- QuicString body(body_bytes_, 'a');
+ std::string body(body_bytes_, 'a');
response.set_body(body);
SendHeadersAndBodyAndTrailers(response.headers().Clone(), response.body(),
response.trailers().Clone());
@@ -2712,7 +2712,7 @@
// it.
uint32_t response_body_size =
2 * client_config_.GetInitialStreamFlowControlWindowToSend();
- QuicString response_body(response_body_size, 'a');
+ std::string response_body(response_body_size, 'a');
StreamWithErrorFactory stream_factory(response_body);
SetSpdyStreamFactory(&stream_factory);
@@ -2738,7 +2738,7 @@
// before the request FIN is processed but receive the request FIN before the
// response is sent completely.
const uint32_t kRequestBodySize = kMaxPacketSize + 10;
- QuicString request_body(kRequestBodySize, 'a');
+ std::string request_body(kRequestBodySize, 'a');
// Send the request.
client_->SendMessage(headers, request_body);
@@ -2774,7 +2774,7 @@
SetReorderPercentage(30);
// Add a response with headers, body, and trailers.
- const QuicString kBody = "body content";
+ const std::string kBody = "body content";
SpdyHeaderBlock headers;
headers[":status"] = "200";
@@ -2808,24 +2808,24 @@
// If |resource_size| == 0, response body of push resources use default string
// concatenating with resource url. Otherwise, generate a string of
// |resource_size| as body.
- void AddRequestAndResponseWithServerPush(QuicString host,
- QuicString path,
- QuicString response_body,
- QuicString* push_urls,
+ void AddRequestAndResponseWithServerPush(std::string host,
+ std::string path,
+ std::string response_body,
+ std::string* push_urls,
const size_t num_resources,
const size_t resource_size) {
bool use_large_response = resource_size != 0;
- QuicString large_resource;
+ std::string large_resource;
if (use_large_response) {
// Generate a response common body larger than flow control window for
// push response.
- large_resource = QuicString(resource_size, 'a');
+ large_resource = std::string(resource_size, 'a');
}
std::list<QuicBackendResponse::ServerPushInfo> push_resources;
for (size_t i = 0; i < num_resources; ++i) {
- QuicString url = push_urls[i];
+ std::string url = push_urls[i];
QuicUrl resource_url(url);
- QuicString body =
+ std::string body =
use_large_response
? large_resource
: QuicStrCat("This is server push response body for ", url);
@@ -2857,12 +2857,12 @@
SetReorderPercentage(30);
// Add a response with headers, body, and push resources.
- const QuicString kBody = "body content";
+ const std::string kBody = "body content";
size_t kNumResources = 4;
- QuicString push_urls[] = {"https://example.com/font.woff",
- "https://example.com/script.js",
- "https://fonts.example.com/font.woff",
- "https://example.com/logo-hires.jpg"};
+ std::string push_urls[] = {"https://example.com/font.woff",
+ "https://example.com/script.js",
+ "https://fonts.example.com/font.woff",
+ "https://example.com/logo-hires.jpg"};
AddRequestAndResponseWithServerPush("example.com", "/push_example", kBody,
push_urls, kNumResources, 0);
@@ -2880,11 +2880,11 @@
// hasn't finished yet.
EXPECT_TRUE(QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(sequencer));
- for (const QuicString& url : push_urls) {
+ for (const std::string& url : push_urls) {
QUIC_DVLOG(1) << "send request for pushed stream on url " << url;
- QuicString expected_body =
+ std::string expected_body =
QuicStrCat("This is server push response body for ", url);
- QuicString response_body = client_->SendSynchronousRequest(url);
+ std::string response_body = client_->SendSynchronousRequest(url);
QUIC_DVLOG(1) << "response body " << response_body;
EXPECT_EQ(expected_body, response_body);
}
@@ -2904,9 +2904,9 @@
SetReorderPercentage(30);
// Add a response with headers, body, and push resources.
- const QuicString kBody = "body content";
+ const std::string kBody = "body content";
size_t const kNumResources = 4;
- QuicString push_urls[] = {
+ std::string push_urls[] = {
"https://example.com/font.woff",
"https://example.com/script.js",
"https://fonts.example.com/font.woff",
@@ -2924,13 +2924,13 @@
EXPECT_EQ(kBody, client_->SendSynchronousRequest(
"https://example.com/push_example"));
- for (const QuicString& url : push_urls) {
+ for (const std::string& url : push_urls) {
// Sending subsequent requesets will not actually send anything on the wire,
// as the responses are already in the client's cache.
QUIC_DVLOG(1) << "send request for pushed stream on url " << url;
- QuicString expected_body =
+ std::string expected_body =
QuicStrCat("This is server push response body for ", url);
- QuicString response_body = client_->SendSynchronousRequest(url);
+ std::string response_body = client_->SendSynchronousRequest(url);
QUIC_DVLOG(1) << "response body " << response_body;
EXPECT_EQ(expected_body, response_body);
}
@@ -2953,11 +2953,11 @@
SetReorderPercentage(30);
// Add a response with headers, body, and push resources.
- const QuicString kBody = "body content";
+ const std::string kBody = "body content";
// One more resource than max number of outgoing stream of this session.
const size_t kNumResources = 1 + kNumMaxStreams; // 11.
- QuicString push_urls[11];
+ std::string push_urls[11];
for (size_t i = 0; i < kNumResources; ++i) {
push_urls[i] = QuicStrCat("https://example.com/push_resources", i);
}
@@ -2973,7 +2973,7 @@
EXPECT_EQ(kBody, client_->SendSynchronousRequest(
"https://example.com/push_example"));
- for (const QuicString& url : push_urls) {
+ for (const std::string& url : push_urls) {
// Sending subsequent requesets will not actually send anything on the wire,
// as the responses are already in the client's cache.
EXPECT_EQ(QuicStrCat("This is server push response body for ", url),
@@ -3011,10 +3011,10 @@
SetReorderPercentage(30);
// Add a response with headers, body, and push resources.
- const QuicString kBody = "body content";
+ const std::string kBody = "body content";
const size_t kNumResources = kNumMaxStreams + 1;
- QuicString push_urls[11];
+ std::string push_urls[11];
for (size_t i = 0; i < kNumResources; ++i) {
push_urls[i] = QuicStrCat("http://example.com/push_resources", i);
}
@@ -3085,7 +3085,7 @@
// Request body size is 4G plus one more kSizeBytes.
int64_t request_body_size_bytes = pow(2, 32) + kSizeBytes;
ASSERT_LT(INT64_C(4294967296), request_body_size_bytes);
- QuicString body(kSizeBytes, 'a');
+ std::string body(kSizeBytes, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
@@ -3099,7 +3099,7 @@
for (int i = 0; i < request_body_size_bytes / kSizeBytes; ++i) {
bool fin = (i == request_body_size_bytes - 1);
- client_->SendData(QuicString(body.data(), kSizeBytes), fin);
+ client_->SendData(std::string(body.data(), kSizeBytes), fin);
client_->client()->WaitForEvents();
}
VerifyCleanConnection(true);
@@ -3200,7 +3200,7 @@
headers[":path"] = "/foo";
headers[":scheme"] = "https";
headers[":authority"] = server_hostname_;
- headers["key"] = QuicString(64 * 1024, 'a');
+ headers["key"] = std::string(64 * 1024, 'a');
client_->SendMessage(headers, "");
client_->WaitForResponse();
@@ -3236,7 +3236,7 @@
client_->client()->client_session()->connection();
client_connection->set_debug_visitor(&observer);
// 100KB body.
- QuicString body(100 * 1024, 'a');
+ std::string body(100 * 1024, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
headers[":path"] = "/foo";
@@ -3336,7 +3336,7 @@
std::unique_ptr<QuicTestClient> client(CreateQuicClient(bad_writer));
// 1 MB body.
- QuicString body(1024 * 1024, 'a');
+ std::string body(1024 * 1024, 'a');
SpdyHeaderBlock headers;
headers[":method"] = "POST";
headers[":path"] = "/foo";
@@ -3429,7 +3429,7 @@
// INCOMPLETE_RESPONSE will cause the server to not to send the trailer
// (and the FIN) after the response body.
- QuicString response_body(1305, 'a');
+ std::string response_body(1305, 'a');
SpdyHeaderBlock response_headers;
response_headers[":status"] = QuicTextUtils::Uint64ToString(200);
response_headers["content-length"] =
@@ -3471,7 +3471,7 @@
stream->MaybeSetTtl(QuicTime::Delta::FromMicroseconds(1));
// 1 MB body.
- QuicString body(1024 * 1024, 'a');
+ std::string body(1024 * 1024, 'a');
stream->WriteOrBufferBody(body, true);
client_->WaitForResponse();
EXPECT_EQ(QUIC_STREAM_TTL_EXPIRED, client_->stream_error());
@@ -3490,7 +3490,7 @@
ASSERT_GT(kMaxPacketSize, client_session->GetLargestMessagePayload());
ASSERT_LT(0, client_session->GetLargestMessagePayload());
- QuicString message_string(kMaxPacketSize, 'a');
+ std::string message_string(kMaxPacketSize, 'a');
QuicStringPiece message_buffer(message_string);
QuicRandom* random =
QuicConnectionPeer::GetHelper(client_connection)->GetRandomGenerator();
@@ -3662,7 +3662,7 @@
// STOP_SENDING will cause the server to not to send the trailer
// (and the FIN) after the response body. Instead, it sends a STOP_SENDING
// frame for the stream.
- QuicString response_body(1305, 'a');
+ std::string response_body(1305, 'a');
SpdyHeaderBlock response_headers;
response_headers[":status"] = QuicTextUtils::Uint64ToString(200);
response_headers["content-length"] =
diff --git a/quic/core/http/http_decoder.cc b/quic/core/http/http_decoder.cc
index e697821..55879d0 100644
--- a/quic/core/http/http_decoder.cc
+++ b/quic/core/http/http_decoder.cc
@@ -355,7 +355,7 @@
remaining_length_field_length_ -= bytes_to_read;
}
-void HttpDecoder::RaiseError(QuicErrorCode error, QuicString error_detail) {
+void HttpDecoder::RaiseError(QuicErrorCode error, std::string error_detail) {
state_ = STATE_ERROR;
error_ = error;
error_detail_ = std::move(error_detail);
diff --git a/quic/core/http/http_decoder.h b/quic/core/http/http_decoder.h
index 910d189..d6b1cc1 100644
--- a/quic/core/http/http_decoder.h
+++ b/quic/core/http/http_decoder.h
@@ -111,7 +111,7 @@
bool has_payload() { return has_payload_; }
QuicErrorCode error() const { return error_; }
- const QuicString& error_detail() const { return error_detail_; }
+ const std::string& error_detail() const { return error_detail_; }
private:
// Represents the current state of the parsing state machine.
@@ -145,7 +145,7 @@
void BufferFrameLength(QuicDataReader* reader);
// Sets |error_| and |error_detail_| accordingly.
- void RaiseError(QuicErrorCode error, QuicString error_detail);
+ void RaiseError(QuicErrorCode error, std::string error_detail);
// Parses the payload of a PRIORITY frame from |reader| into |frame|.
bool ParsePriorityFrame(QuicDataReader* reader, PriorityFrame* frame);
@@ -170,14 +170,14 @@
// Last error.
QuicErrorCode error_;
// The issue which caused |error_|
- QuicString error_detail_;
+ std::string error_detail_;
// True if the call to ProcessInput() generates any payload. Flushed every
// time ProcessInput() is called.
bool has_payload_;
// Remaining unparsed data.
- QuicString buffer_;
+ std::string buffer_;
// Remaining unparsed length field data.
- QuicString length_buffer_;
+ std::string length_buffer_;
};
} // namespace quic
diff --git a/quic/core/http/http_decoder_test.cc b/quic/core/http/http_decoder_test.cc
index c6d7d9f..cfabe70 100644
--- a/quic/core/http/http_decoder_test.cc
+++ b/quic/core/http/http_decoder_test.cc
@@ -321,12 +321,12 @@
TEST_F(HttpDecoderTest, FrameHeaderPartialDelivery) {
// A large input that will occupy more than 1 byte in the length field.
- QuicString input(2048, 'x');
+ std::string input(2048, 'x');
HttpEncoder encoder;
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
encoder.SerializeDataFrameHeader(input.length(), &buffer);
- QuicString header = QuicString(buffer.get(), header_length);
+ std::string header = std::string(buffer.get(), header_length);
// Partially send only 1 byte of the header to process.
EXPECT_EQ(1u, decoder_.ProcessInput(header.data(), 1));
EXPECT_EQ(QUIC_NO_ERROR, decoder_.error());
diff --git a/quic/core/http/quic_client_promised_info.cc b/quic/core/http/quic_client_promised_info.cc
index abfc4b4..3cebc1e 100644
--- a/quic/core/http/quic_client_promised_info.cc
+++ b/quic/core/http/quic_client_promised_info.cc
@@ -19,7 +19,7 @@
QuicClientPromisedInfo::QuicClientPromisedInfo(
QuicSpdyClientSessionBase* session,
QuicStreamId id,
- QuicString url)
+ std::string url)
: session_(session),
id_(id),
url_(std::move(url)),
diff --git a/quic/core/http/quic_client_promised_info.h b/quic/core/http/quic_client_promised_info.h
index 917c9f7..64ee09e 100644
--- a/quic/core/http/quic_client_promised_info.h
+++ b/quic/core/http/quic_client_promised_info.h
@@ -7,11 +7,11 @@
#include <cstddef>
-#include "net/third_party/quiche/src/quic/core/quic_alarm.h"
#include "net/third_party/quiche/src/quic/core/http/quic_client_push_promise_index.h"
-#include "net/third_party/quiche/src/quic/core/quic_packets.h"
#include "net/third_party/quiche/src/quic/core/http/quic_spdy_client_session_base.h"
#include "net/third_party/quiche/src/quic/core/http/quic_spdy_stream.h"
+#include "net/third_party/quiche/src/quic/core/quic_alarm.h"
+#include "net/third_party/quiche/src/quic/core/quic_packets.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
#include "net/third_party/quiche/src/spdy/core/spdy_framer.h"
@@ -32,7 +32,7 @@
// Interface to QuicSpdyClientStream
QuicClientPromisedInfo(QuicSpdyClientSessionBase* session,
QuicStreamId id,
- QuicString url);
+ std::string url);
QuicClientPromisedInfo(const QuicClientPromisedInfo&) = delete;
QuicClientPromisedInfo& operator=(const QuicClientPromisedInfo&) = delete;
virtual ~QuicClientPromisedInfo();
@@ -76,7 +76,7 @@
QuicStreamId id() const { return id_; }
- const QuicString url() const { return url_; }
+ const std::string url() const { return url_; }
// Return true if there's a request pending matching this push promise.
bool is_validating() const { return client_request_delegate_ != nullptr; }
@@ -98,7 +98,7 @@
QuicSpdyClientSessionBase* session_;
QuicStreamId id_;
- QuicString url_;
+ std::string url_;
spdy::SpdyHeaderBlock request_headers_;
std::unique_ptr<spdy::SpdyHeaderBlock> response_headers_;
spdy::SpdyHeaderBlock client_request_headers_;
diff --git a/quic/core/http/quic_client_promised_info_test.cc b/quic/core/http/quic_client_promised_info_test.cc
index 2a7b1b0..43346d9 100644
--- a/quic/core/http/quic_client_promised_info_test.cc
+++ b/quic/core/http/quic_client_promised_info_test.cc
@@ -49,7 +49,7 @@
delete;
~MockQuicSpdyClientSession() override {}
- bool IsAuthorized(const QuicString& authority) override {
+ bool IsAuthorized(const std::string& authority) override {
return authorized_;
}
@@ -125,10 +125,10 @@
std::unique_ptr<StreamVisitor> stream_visitor_;
std::unique_ptr<QuicSpdyClientStream> promised_stream_;
SpdyHeaderBlock headers_;
- QuicString body_;
+ std::string body_;
SpdyHeaderBlock push_promise_;
QuicStreamId promise_id_;
- QuicString promise_url_;
+ std::string promise_url_;
SpdyHeaderBlock client_request_;
};
diff --git a/quic/core/http/quic_client_push_promise_index.cc b/quic/core/http/quic_client_push_promise_index.cc
index 2ba5951..08a4477 100644
--- a/quic/core/http/quic_client_push_promise_index.cc
+++ b/quic/core/http/quic_client_push_promise_index.cc
@@ -19,7 +19,7 @@
QuicClientPushPromiseIndex::TryHandle::~TryHandle() {}
QuicClientPromisedInfo* QuicClientPushPromiseIndex::GetPromised(
- const QuicString& url) {
+ const std::string& url) {
auto it = promised_by_url_.find(url);
if (it == promised_by_url_.end()) {
return nullptr;
@@ -31,7 +31,7 @@
const spdy::SpdyHeaderBlock& request,
QuicClientPushPromiseIndex::Delegate* delegate,
TryHandle** handle) {
- QuicString url(SpdyUtils::GetPromisedUrlFromHeaders(request));
+ std::string url(SpdyUtils::GetPromisedUrlFromHeaders(request));
auto it = promised_by_url_.find(url);
if (it != promised_by_url_.end()) {
QuicClientPromisedInfo* promised = it->second;
diff --git a/quic/core/http/quic_client_push_promise_index.h b/quic/core/http/quic_client_push_promise_index.h
index 5dd29b4..2647924 100644
--- a/quic/core/http/quic_client_push_promise_index.h
+++ b/quic/core/http/quic_client_push_promise_index.h
@@ -66,7 +66,7 @@
// Called by client code, used to enforce affinity between requests
// for promised streams and the session the promise came from.
- QuicClientPromisedInfo* GetPromised(const QuicString& url);
+ QuicClientPromisedInfo* GetPromised(const std::string& url);
// Called by client code, to initiate rendezvous between a request
// and a server push stream. If |request|'s url is in the index,
diff --git a/quic/core/http/quic_client_push_promise_index_test.cc b/quic/core/http/quic_client_push_promise_index_test.cc
index b68b41f..a4a0ee6 100644
--- a/quic/core/http/quic_client_push_promise_index_test.cc
+++ b/quic/core/http/quic_client_push_promise_index_test.cc
@@ -73,7 +73,7 @@
MockQuicSpdyClientSession session_;
QuicClientPushPromiseIndex index_;
spdy::SpdyHeaderBlock request_;
- QuicString url_;
+ std::string url_;
MockQuicClientPromisedInfo promised_;
QuicClientPushPromiseIndex::TryHandle* handle_;
};
diff --git a/quic/core/http/quic_header_list.cc b/quic/core/http/quic_header_list.cc
index cb10248..e937cf2 100644
--- a/quic/core/http/quic_header_list.cc
+++ b/quic/core/http/quic_header_list.cc
@@ -40,7 +40,7 @@
current_header_list_size_ += name.size();
current_header_list_size_ += value.size();
current_header_list_size_ += spdy::kPerHeaderOverhead;
- header_list_.emplace_back(QuicString(name), QuicString(value));
+ header_list_.emplace_back(std::string(name), std::string(value));
}
}
@@ -60,8 +60,8 @@
compressed_header_bytes_ = 0;
}
-QuicString QuicHeaderList::DebugString() const {
- QuicString s = "{ ";
+std::string QuicHeaderList::DebugString() const {
+ std::string s = "{ ";
for (const auto& p : *this) {
s.append(p.first + "=" + p.second + ", ");
}
diff --git a/quic/core/http/quic_header_list.h b/quic/core/http/quic_header_list.h
index c7b4c80..b62cba4 100644
--- a/quic/core/http/quic_header_list.h
+++ b/quic/core/http/quic_header_list.h
@@ -23,7 +23,7 @@
class QUIC_EXPORT_PRIVATE QuicHeaderList
: public spdy::SpdyHeadersHandlerInterface {
public:
- typedef QuicDeque<std::pair<QuicString, QuicString>> ListType;
+ typedef QuicDeque<std::pair<std::string, std::string>> ListType;
typedef ListType::const_iterator const_iterator;
QuicHeaderList();
@@ -56,10 +56,10 @@
size_t max_header_list_size() const { return max_header_list_size_; }
- QuicString DebugString() const;
+ std::string DebugString() const;
private:
- QuicDeque<std::pair<QuicString, QuicString>> header_list_;
+ QuicDeque<std::pair<std::string, std::string>> header_list_;
// The limit on the size of the header list (defined by spec as name + value +
// overhead for each header field). Headers over this limit will not be
@@ -76,8 +76,8 @@
};
inline bool operator==(const QuicHeaderList& l1, const QuicHeaderList& l2) {
- auto pred = [](const std::pair<QuicString, QuicString>& p1,
- const std::pair<QuicString, QuicString>& p2) {
+ auto pred = [](const std::pair<std::string, std::string>& p1,
+ const std::pair<std::string, std::string>& p2) {
return p1.first == p2.first && p1.second == p2.second;
};
return std::equal(l1.begin(), l1.end(), l2.begin(), pred);
diff --git a/quic/core/http/quic_header_list_test.cc b/quic/core/http/quic_header_list_test.cc
index 1b2a394..c098715 100644
--- a/quic/core/http/quic_header_list_test.cc
+++ b/quic/core/http/quic_header_list_test.cc
@@ -24,8 +24,8 @@
TEST_F(QuicHeaderListTest, TooLarge) {
QuicHeaderList headers;
- QuicString key = "key";
- QuicString value(1 << 18, '1');
+ std::string key = "key";
+ std::string value(1 << 18, '1');
// Send a header that exceeds max_header_list_size.
headers.OnHeader(key, value);
// Send a second header exceeding max_header_list_size.
@@ -42,8 +42,8 @@
TEST_F(QuicHeaderListTest, NotTooLarge) {
QuicHeaderList headers;
headers.set_max_header_list_size(1 << 20);
- QuicString key = "key";
- QuicString value(1 << 18, '1');
+ std::string key = "key";
+ std::string value(1 << 18, '1');
headers.OnHeader(key, value);
size_t total_bytes = key.size() + value.size();
headers.OnHeaderBlockEnd(total_bytes, total_bytes);
diff --git a/quic/core/http/quic_headers_stream_test.cc b/quic/core/http/quic_headers_stream_test.cc
index b6409b1..7059b72 100644
--- a/quic/core/http/quic_headers_stream_test.cc
+++ b/quic/core/http/quic_headers_stream_test.cc
@@ -344,10 +344,10 @@
QuicHeadersStream* headers_stream_;
SpdyHeaderBlock headers_;
std::unique_ptr<TestHeadersHandler> headers_handler_;
- QuicString body_;
- QuicString saved_data_;
- QuicString saved_header_data_;
- QuicString saved_payloads_;
+ std::string body_;
+ std::string saved_data_;
+ std::string saved_header_data_;
+ std::string saved_payloads_;
std::unique_ptr<SpdyFramer> framer_;
std::unique_ptr<http2::Http2DecoderAdapter> deframer_;
StrictMock<MockVisitor> visitor_;
@@ -360,7 +360,8 @@
};
// Run all tests with each version and perspective (client or server).
-INSTANTIATE_TEST_SUITE_P(Tests, QuicHeadersStreamTest,
+INSTANTIATE_TEST_SUITE_P(Tests,
+ QuicHeadersStreamTest,
::testing::ValuesIn(GetTestParams()));
TEST_P(QuicHeadersStreamTest, StreamId) {
@@ -539,9 +540,9 @@
// We want to create a frame that is more than the SPDY Framer's max control
// frame size, which is 16K, but less than the HPACK decoders max decode
// buffer size, which is 32K.
- headers_["key0"] = QuicString(1 << 13, '.');
- headers_["key1"] = QuicString(1 << 13, '.');
- headers_["key2"] = QuicString(1 << 13, '.');
+ headers_["key0"] = std::string(1 << 13, '.');
+ headers_["key1"] = std::string(1 << 13, '.');
+ headers_["key2"] = std::string(1 << 13, '.');
for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_;
stream_id += next_stream_id_) {
for (bool fin : {false, true}) {
@@ -725,9 +726,9 @@
// Create some headers we expect to generate entries in HPACK's
// dynamic table, in addition to content-length.
- headers_["key0"] = QuicString(1 << 1, '.');
- headers_["key1"] = QuicString(1 << 2, '.');
- headers_["key2"] = QuicString(1 << 3, '.');
+ headers_["key0"] = std::string(1 << 1, '.');
+ headers_["key1"] = std::string(1 << 2, '.');
+ headers_["key2"] = std::string(1 << 3, '.');
for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_;
stream_id += next_stream_id_) {
for (bool fin : {false, true}) {
diff --git a/quic/core/http/quic_server_session_base.cc b/quic/core/http/quic_server_session_base.cc
index f240ece..6c6acdf 100644
--- a/quic/core/http/quic_server_session_base.cc
+++ b/quic/core/http/quic_server_session_base.cc
@@ -80,7 +80,7 @@
}
void QuicServerSessionBase::OnConnectionClosed(QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
ConnectionCloseSource source) {
QuicSession::OnConnectionClosed(error, error_details, source);
// In the unlikely event we get a connection close while doing an asynchronous
diff --git a/quic/core/http/quic_server_session_base.h b/quic/core/http/quic_server_session_base.h
index 55a8d60..7332640 100644
--- a/quic/core/http/quic_server_session_base.h
+++ b/quic/core/http/quic_server_session_base.h
@@ -47,7 +47,7 @@
// Override the base class to cancel any ongoing asychronous crypto.
void OnConnectionClosed(QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
ConnectionCloseSource source) override;
// Sends a server config update to the client, containing new bandwidth
@@ -66,7 +66,7 @@
// client.
void OnConfigNegotiated() override;
- void set_serving_region(const QuicString& serving_region) {
+ void set_serving_region(const std::string& serving_region) {
serving_region_ = serving_region;
}
@@ -120,7 +120,7 @@
// Text describing server location. Sent to the client as part of the bandwith
// estimate in the source-address token. Optional, can be left empty.
- QuicString serving_region_;
+ std::string serving_region_;
// Time at which we send the last SCUP to the client.
QuicTime last_scup_time_;
diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index efc2388..5678b26 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -492,7 +492,7 @@
int32_t bandwidth_estimate_kbytes_per_second = 123;
int32_t max_bandwidth_estimate_kbytes_per_second = 134;
int32_t max_bandwidth_estimate_timestamp = 1122334455;
- const QuicString serving_region = "not a real region";
+ const std::string serving_region = "not a real region";
session_->set_serving_region(serving_region);
session_->UnregisterStreamPriority(
@@ -601,7 +601,7 @@
copt.push_back(kBWRE);
QuicConfigPeer::SetReceivedConnectionOptions(session_->config(), copt);
- const QuicString kTestServingRegion = "a serving region";
+ const std::string kTestServingRegion = "a serving region";
session_->set_serving_region(kTestServingRegion);
// Set the time to be one hour + one second from the 0 baseline.
@@ -703,7 +703,7 @@
std::vector<ParsedQuicVersion> packet_version_list = {GetParam()};
std::unique_ptr<QuicEncryptedPacket> packet(ConstructEncryptedPacket(
TestConnectionId(1), EmptyQuicConnectionId(), true, false, 1,
- QuicString(chlo.GetSerialized().AsStringPiece()), CONNECTION_ID_PRESENT,
+ std::string(chlo.GetSerialized().AsStringPiece()), CONNECTION_ID_PRESENT,
CONNECTION_ID_ABSENT, PACKET_4BYTE_PACKET_NUMBER, &packet_version_list));
EXPECT_CALL(stream_helper_, CanAcceptClientHello(_, _, _, _, _))
diff --git a/quic/core/http/quic_spdy_client_session.cc b/quic/core/http/quic_spdy_client_session.cc
index 9e8170b..45eb0ae 100644
--- a/quic/core/http/quic_spdy_client_session.cc
+++ b/quic/core/http/quic_spdy_client_session.cc
@@ -175,7 +175,7 @@
this);
}
-bool QuicSpdyClientSession::IsAuthorized(const QuicString& authority) {
+bool QuicSpdyClientSession::IsAuthorized(const std::string& authority) {
return true;
}
diff --git a/quic/core/http/quic_spdy_client_session.h b/quic/core/http/quic_spdy_client_session.h
index c92753b..3bb8168 100644
--- a/quic/core/http/quic_spdy_client_session.h
+++ b/quic/core/http/quic_spdy_client_session.h
@@ -43,7 +43,7 @@
QuicCryptoClientStreamBase* GetMutableCryptoStream() override;
const QuicCryptoClientStreamBase* GetCryptoStream() const override;
- bool IsAuthorized(const QuicString& authority) override;
+ bool IsAuthorized(const std::string& authority) override;
// QuicSpdyClientSessionBase methods:
void OnProofValid(const QuicCryptoClientConfig::CachedState& cached) override;
diff --git a/quic/core/http/quic_spdy_client_session_base.cc b/quic/core/http/quic_spdy_client_session_base.cc
index 924ab36..b0dfc01 100644
--- a/quic/core/http/quic_spdy_client_session_base.cc
+++ b/quic/core/http/quic_spdy_client_session_base.cc
@@ -118,7 +118,7 @@
return false;
}
- const QuicString url = SpdyUtils::GetPromisedUrlFromHeaders(headers);
+ const std::string url = SpdyUtils::GetPromisedUrlFromHeaders(headers);
QuicClientPromisedInfo* old_promised = GetPromisedByUrl(url);
if (old_promised) {
QUIC_DVLOG(1) << "Promise for stream " << promised_id
@@ -150,7 +150,7 @@
}
QuicClientPromisedInfo* QuicSpdyClientSessionBase::GetPromisedByUrl(
- const QuicString& url) {
+ const std::string& url) {
auto it = push_promise_index_->promised_by_url()->find(url);
if (it != push_promise_index_->promised_by_url()->end()) {
return it->second;
diff --git a/quic/core/http/quic_spdy_client_session_base.h b/quic/core/http/quic_spdy_client_session_base.h
index f27708c..a47bdd0 100644
--- a/quic/core/http/quic_spdy_client_session_base.h
+++ b/quic/core/http/quic_spdy_client_session_base.h
@@ -6,8 +6,8 @@
#define QUICHE_QUIC_CORE_HTTP_QUIC_SPDY_CLIENT_SESSION_BASE_H_
#include "base/macros.h"
-#include "net/third_party/quiche/src/quic/core/quic_crypto_client_stream.h"
#include "net/third_party/quiche/src/quic/core/http/quic_spdy_session.h"
+#include "net/third_party/quiche/src/quic/core/quic_crypto_client_stream.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
@@ -25,7 +25,7 @@
// session affinity for requests corresponding to cross-origin push
// promised streams.
using QuicPromisedByUrlMap =
- QuicUnorderedMap<QuicString, QuicClientPromisedInfo*>;
+ QuicUnorderedMap<std::string, QuicClientPromisedInfo*>;
// The maximum time a promises stream can be reserved without being
// claimed by a client request.
@@ -80,10 +80,10 @@
// list in the certificate should contain a matching DNS name, or IP
// address. |hostname| is derived from the ":authority" header field of
// the PUSH_PROMISE frame, port if present there will be dropped.
- virtual bool IsAuthorized(const QuicString& hostname) = 0;
+ virtual bool IsAuthorized(const std::string& hostname) = 0;
// Session retains ownership.
- QuicClientPromisedInfo* GetPromisedByUrl(const QuicString& url);
+ QuicClientPromisedInfo* GetPromisedByUrl(const std::string& url);
// Session retains ownership.
QuicClientPromisedInfo* GetPromisedById(const QuicStreamId id);
diff --git a/quic/core/http/quic_spdy_client_session_test.cc b/quic/core/http/quic_spdy_client_session_test.cc
index 3a40043..6b80196 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -165,7 +165,7 @@
std::unique_ptr<TestQuicSpdyClientSession> session_;
QuicClientPushPromiseIndex push_promise_index_;
SpdyHeaderBlock push_promise_;
- QuicString promise_url_;
+ std::string promise_url_;
QuicStreamId promised_stream_id_;
QuicStreamId associated_stream_id_;
};
@@ -636,7 +636,8 @@
session_->HandlePromised(associated_stream_id_, id, push_promise_));
// Verify that the promise is in the unclaimed streams map.
- QuicString promise_url(SpdyUtils::GetPromisedUrlFromHeaders(push_promise_));
+ std::string promise_url(
+ SpdyUtils::GetPromisedUrlFromHeaders(push_promise_));
EXPECT_NE(session_->GetPromisedByUrl(promise_url), nullptr);
EXPECT_NE(session_->GetPromisedById(id), nullptr);
}
@@ -654,7 +655,7 @@
session_->HandlePromised(associated_stream_id_, id, push_promise_));
// Verify that the promise was not created.
- QuicString promise_url(SpdyUtils::GetPromisedUrlFromHeaders(push_promise_));
+ std::string promise_url(SpdyUtils::GetPromisedUrlFromHeaders(push_promise_));
EXPECT_EQ(session_->GetPromisedById(id), nullptr);
EXPECT_EQ(session_->GetPromisedByUrl(promise_url), nullptr);
}
diff --git a/quic/core/http/quic_spdy_client_stream.h b/quic/core/http/quic_spdy_client_stream.h
index 8a66740..521914a 100644
--- a/quic/core/http/quic_spdy_client_stream.h
+++ b/quic/core/http/quic_spdy_client_stream.h
@@ -57,7 +57,7 @@
bool fin);
// Returns the response data.
- const QuicString& data() { return data_; }
+ const std::string& data() { return data_; }
// Returns whatever headers have been received for this stream.
const spdy::SpdyHeaderBlock& response_headers() { return response_headers_; }
@@ -83,7 +83,7 @@
// The parsed content-length, or -1 if none is specified.
int64_t content_length_;
int response_code_;
- QuicString data_;
+ std::string data_;
size_t header_bytes_read_;
size_t header_bytes_written_;
diff --git a/quic/core/http/quic_spdy_client_stream_test.cc b/quic/core/http/quic_spdy_client_stream_test.cc
index 0b2c157..3c56630 100644
--- a/quic/core/http/quic_spdy_client_stream_test.cc
+++ b/quic/core/http/quic_spdy_client_stream_test.cc
@@ -97,7 +97,7 @@
std::unique_ptr<QuicSpdyClientStream> stream_;
std::unique_ptr<StreamVisitor> stream_visitor_;
SpdyHeaderBlock headers_;
- QuicString body_;
+ std::string body_;
HttpEncoder encoder_;
};
@@ -124,10 +124,10 @@
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body_.length(), &buffer);
- QuicString header = QuicString(buffer.get(), header_length);
- QuicString data = VersionHasDataFrameHeader(connection_->transport_version())
- ? header + body_
- : body_;
+ std::string header = std::string(buffer.get(), header_length);
+ std::string data = VersionHasDataFrameHeader(connection_->transport_version())
+ ? header + body_
+ : body_;
stream_->OnStreamFrame(
QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, data));
EXPECT_EQ("200", stream_->response_headers().find(":status")->second);
@@ -155,10 +155,10 @@
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body_.length(), &buffer);
- QuicString header = QuicString(buffer.get(), header_length);
- QuicString data = VersionHasDataFrameHeader(connection_->transport_version())
- ? header + body_
- : body_;
+ std::string header = std::string(buffer.get(), header_length);
+ std::string data = VersionHasDataFrameHeader(connection_->transport_version())
+ ? header + body_
+ : body_;
stream_->OnStreamFrame(
QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, data));
EXPECT_EQ("200", stream_->response_headers().find(":status")->second);
@@ -168,7 +168,7 @@
TEST_P(QuicSpdyClientStreamTest,
QUIC_TEST_DISABLED_IN_CHROME(TestFramingExtraData)) {
- QuicString large_body = "hello world!!!!!!";
+ std::string large_body = "hello world!!!!!!";
auto headers = AsHeaderList(headers_);
stream_->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
@@ -180,10 +180,10 @@
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(large_body.length(), &buffer);
- QuicString header = QuicString(buffer.get(), header_length);
- QuicString data = VersionHasDataFrameHeader(connection_->transport_version())
- ? header + large_body
- : large_body;
+ std::string header = std::string(buffer.get(), header_length);
+ std::string data = VersionHasDataFrameHeader(connection_->transport_version())
+ ? header + large_body
+ : large_body;
EXPECT_CALL(*connection_, SendControlFrame(_));
EXPECT_CALL(*connection_,
OnStreamReset(stream_->id(), QUIC_BAD_APPLICATION_PAYLOAD));
@@ -219,10 +219,10 @@
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body_.length(), &buffer);
- QuicString header = QuicString(buffer.get(), header_length);
- QuicString data = VersionHasDataFrameHeader(connection_->transport_version())
- ? header + body_
- : body_;
+ std::string header = std::string(buffer.get(), header_length);
+ std::string data = VersionHasDataFrameHeader(connection_->transport_version())
+ ? header + body_
+ : body_;
stream_->OnStreamFrame(
QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, data));
EXPECT_TRUE(stream_->reading_stopped());
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index ddae51a..415129e 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -283,7 +283,7 @@
}
private:
- void CloseConnection(const QuicString& details, QuicErrorCode code) {
+ void CloseConnection(const std::string& details, QuicErrorCode code) {
if (session_->IsConnected()) {
session_->CloseConnectionWithDetails(code, details);
}
@@ -419,8 +419,8 @@
// byte offset necessary for flow control and open stream accounting.
size_t final_byte_offset = 0;
for (const auto& header : header_list) {
- const QuicString& header_key = header.first;
- const QuicString& header_value = header.second;
+ const std::string& header_key = header.first;
+ const std::string& header_value = header.second;
if (header_key == kFinalOffsetHeaderKey) {
if (!QuicTextUtils::StringToSizeT(header_value, &final_byte_offset)) {
connection()->CloseConnection(
@@ -577,7 +577,8 @@
QuicStreamId promised_stream_id,
size_t frame_len,
const QuicHeaderList& header_list) {
- QuicString error = "OnPromiseHeaderList should be overridden in client code.";
+ std::string error =
+ "OnPromiseHeaderList should be overridden in client code.";
QUIC_BUG << error;
connection()->CloseConnection(QUIC_INTERNAL_ERROR, error,
ConnectionCloseBehavior::SILENT_CLOSE);
@@ -688,7 +689,7 @@
}
void QuicSpdySession::CloseConnectionWithDetails(QuicErrorCode error,
- const QuicString& details) {
+ const std::string& details) {
connection()->CloseConnection(
error, details, ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
}
diff --git a/quic/core/http/quic_spdy_session.h b/quic/core/http/quic_spdy_session.h
index 93067fa..c13daeb 100644
--- a/quic/core/http/quic_spdy_session.h
+++ b/quic/core/http/quic_spdy_session.h
@@ -153,7 +153,7 @@
virtual bool ShouldReleaseHeadersStreamSequencerBuffer();
void CloseConnectionWithDetails(QuicErrorCode error,
- const QuicString& details);
+ const std::string& details);
void set_max_inbound_header_list_size(size_t max_inbound_header_list_size) {
max_inbound_header_list_size_ = max_inbound_header_list_size;
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 1c53472..1087493 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -64,7 +64,7 @@
encryption_established_ = true;
handshake_confirmed_ = true;
CryptoHandshakeMessage msg;
- QuicString error_details;
+ std::string error_details;
session()->config()->SetInitialStreamFlowControlWindowToSend(
kInitialStreamFlowControlWindowForTest);
session()->config()->SetInitialSessionFlowControlWindowToSend(
@@ -569,7 +569,7 @@
EXPECT_CALL(*connection_, SendControlFrame(_));
EXPECT_CALL(*connection_, OnStreamReset(closed_stream_id, _));
stream2->Reset(QUIC_BAD_APPLICATION_PAYLOAD);
- QuicString msg =
+ std::string msg =
QuicStrCat("Marking unknown stream ", closed_stream_id, " blocked.");
EXPECT_QUIC_BUG(session_.MarkConnectionLevelWriteBlocked(closed_stream_id),
msg);
@@ -1086,7 +1086,7 @@
// Create a stream, and send enough data to make it flow control blocked.
TestStream* stream2 = session_.CreateOutgoingBidirectionalStream();
- QuicString body(kMinimumFlowControlSendWindow, '.');
+ std::string body(kMinimumFlowControlSendWindow, '.');
EXPECT_FALSE(stream2->flow_controller()->IsBlocked());
EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
@@ -1321,7 +1321,7 @@
// adjusting the connection level flow control receive window to take into
// account the total number of bytes sent by the peer.
const QuicStreamOffset kByteOffset = 5678;
- QuicString body = "hello";
+ std::string body = "hello";
QuicStreamFrame frame(stream->id(), true, kByteOffset, QuicStringPiece(body));
session_.OnStreamFrame(frame);
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index 9e9f1b7..cdd61c4 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -98,7 +98,7 @@
}
private:
- void CloseConnectionOnWrongFrame(QuicString frame_type) {
+ void CloseConnectionOnWrongFrame(std::string frame_type) {
stream_->session()->connection()->CloseConnection(
QUIC_HTTP_DECODER_ERROR, frame_type + " frame received on data stream",
ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
diff --git a/quic/core/http/quic_spdy_stream_body_buffer_test.cc b/quic/core/http/quic_spdy_stream_body_buffer_test.cc
index 7ea776f..deaf54a 100644
--- a/quic/core/http/quic_spdy_stream_body_buffer_test.cc
+++ b/quic/core/http/quic_spdy_stream_body_buffer_test.cc
@@ -25,7 +25,7 @@
MOCK_METHOD0(OnFinRead, void());
MOCK_METHOD0(OnDataAvailable, void());
MOCK_METHOD2(CloseConnectionWithDetails,
- void(QuicErrorCode error, const QuicString& details));
+ void(QuicErrorCode error, const std::string& details));
MOCK_METHOD1(Reset, void(QuicRstStreamErrorCode error));
MOCK_METHOD0(OnCanWrite, void());
MOCK_METHOD1(AddBytesConsumed, void(QuicByteCount bytes));
@@ -61,7 +61,7 @@
};
TEST_F(QuicSpdyStreamBodyBufferTest, ReceiveBodies) {
- QuicString body(1024, 'a');
+ std::string body(1024, 'a');
EXPECT_FALSE(body_buffer_.HasBytesToRead());
body_buffer_.OnDataHeader(Http3FrameLengths(3, 1024));
body_buffer_.OnDataPayload(QuicStringPiece(body));
@@ -70,7 +70,7 @@
}
TEST_F(QuicSpdyStreamBodyBufferTest, PeekBody) {
- QuicString body(1024, 'a');
+ std::string body(1024, 'a');
body_buffer_.OnDataHeader(Http3FrameLengths(3, 1024));
body_buffer_.OnDataPayload(QuicStringPiece(body));
EXPECT_EQ(1024u, body_buffer_.total_body_bytes_received());
@@ -84,13 +84,13 @@
// Buffer only receives 1 frame. Stream consumes less or equal than a frame.
TEST_F(QuicSpdyStreamBodyBufferTest, MarkConsumedPartialSingleFrame) {
testing::InSequence seq;
- QuicString body(1024, 'a');
+ std::string body(1024, 'a');
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buffer);
- QuicString header = QuicString(buffer.get(), header_length);
+ std::string header = std::string(buffer.get(), header_length);
Http3FrameLengths lengths(header_length, 1024);
- QuicString data = header + body;
+ std::string data = header + body;
QuicStreamFrame frame(1, false, 0, data);
sequencer_.OnStreamFrame(frame);
body_buffer_.OnDataHeader(lengths);
@@ -104,25 +104,25 @@
TEST_F(QuicSpdyStreamBodyBufferTest, MarkConsumedMultipleFrames) {
testing::InSequence seq;
// 1st frame.
- QuicString body1(1024, 'a');
+ std::string body1(1024, 'a');
std::unique_ptr<char[]> buffer;
QuicByteCount header_length1 =
encoder_.SerializeDataFrameHeader(body1.length(), &buffer);
- QuicString header1 = QuicString(buffer.get(), header_length1);
+ std::string header1 = std::string(buffer.get(), header_length1);
Http3FrameLengths lengths1(header_length1, 1024);
- QuicString data1 = header1 + body1;
+ std::string data1 = header1 + body1;
QuicStreamFrame frame1(1, false, 0, data1);
sequencer_.OnStreamFrame(frame1);
body_buffer_.OnDataHeader(lengths1);
body_buffer_.OnDataPayload(QuicStringPiece(body1));
// 2nd frame.
- QuicString body2(2048, 'b');
+ std::string body2(2048, 'b');
QuicByteCount header_length2 =
encoder_.SerializeDataFrameHeader(body2.length(), &buffer);
- QuicString header2 = QuicString(buffer.get(), header_length2);
+ std::string header2 = std::string(buffer.get(), header_length2);
Http3FrameLengths lengths2(header_length2, 2048);
- QuicString data2 = header2 + body2;
+ std::string data2 = header2 + body2;
QuicStreamFrame frame2(1, false, data1.length(), data2);
sequencer_.OnStreamFrame(frame2);
body_buffer_.OnDataHeader(lengths2);
@@ -139,7 +139,7 @@
}
TEST_F(QuicSpdyStreamBodyBufferTest, MarkConsumedMoreThanBuffered) {
- QuicString body(1024, 'a');
+ std::string body(1024, 'a');
Http3FrameLengths lengths(3, 1024);
body_buffer_.OnDataHeader(lengths);
body_buffer_.OnDataPayload(body);
@@ -152,13 +152,13 @@
// Buffer receives 1 frame. Stream read from the buffer.
TEST_F(QuicSpdyStreamBodyBufferTest, ReadSingleBody) {
testing::InSequence seq;
- QuicString body(1024, 'a');
+ std::string body(1024, 'a');
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buffer);
- QuicString header = QuicString(buffer.get(), header_length);
+ std::string header = std::string(buffer.get(), header_length);
Http3FrameLengths lengths(header_length, 1024);
- QuicString data = header + body;
+ std::string data = header + body;
QuicStreamFrame frame(1, false, 0, data);
sequencer_.OnStreamFrame(frame);
body_buffer_.OnDataHeader(lengths);
@@ -179,25 +179,25 @@
TEST_F(QuicSpdyStreamBodyBufferTest, ReadMultipleBody) {
testing::InSequence seq;
// 1st frame.
- QuicString body1(1024, 'a');
+ std::string body1(1024, 'a');
std::unique_ptr<char[]> buffer;
QuicByteCount header_length1 =
encoder_.SerializeDataFrameHeader(body1.length(), &buffer);
- QuicString header1 = QuicString(buffer.get(), header_length1);
+ std::string header1 = std::string(buffer.get(), header_length1);
Http3FrameLengths lengths1(header_length1, 1024);
- QuicString data1 = header1 + body1;
+ std::string data1 = header1 + body1;
QuicStreamFrame frame1(1, false, 0, data1);
sequencer_.OnStreamFrame(frame1);
body_buffer_.OnDataHeader(lengths1);
body_buffer_.OnDataPayload(QuicStringPiece(body1));
// 2nd frame.
- QuicString body2(2048, 'b');
+ std::string body2(2048, 'b');
QuicByteCount header_length2 =
encoder_.SerializeDataFrameHeader(body2.length(), &buffer);
- QuicString header2 = QuicString(buffer.get(), header_length2);
+ std::string header2 = std::string(buffer.get(), header_length2);
Http3FrameLengths lengths2(header_length2, 2048);
- QuicString data2 = header2 + body2;
+ std::string data2 = header2 + body2;
QuicStreamFrame frame2(1, false, data1.length(), data2);
sequencer_.OnStreamFrame(frame2);
body_buffer_.OnDataHeader(lengths2);
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index 1aabe0e..d61d197 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -67,7 +67,7 @@
vec.iov_base = buffer;
vec.iov_len = QUIC_ARRAYSIZE(buffer);
size_t bytes_read = Readv(&vec, 1);
- data_ += QuicString(buffer, bytes_read);
+ data_ += std::string(buffer, bytes_read);
}
MOCK_METHOD1(WriteHeadersMock, void(bool fin));
@@ -81,13 +81,13 @@
return 0;
}
- const QuicString& data() const { return data_; }
+ const std::string& data() const { return data_; }
const spdy::SpdyHeaderBlock& saved_headers() const { return saved_headers_; }
private:
bool should_process_data_;
spdy::SpdyHeaderBlock saved_headers_;
- QuicString data_;
+ std::string data_;
};
class TestMockUpdateStreamSession : public MockQuicSpdySession {
@@ -192,7 +192,8 @@
HttpEncoder encoder_;
};
-INSTANTIATE_TEST_SUITE_P(Tests, QuicSpdyStreamTest,
+INSTANTIATE_TEST_SUITE_P(Tests,
+ QuicSpdyStreamTest,
::testing::ValuesIn(AllSupportedVersions()));
TEST_P(QuicSpdyStreamTest, ProcessHeaderList) {
@@ -295,7 +296,7 @@
TEST_P(QuicSpdyStreamTest, MarkHeadersConsumed) {
Initialize(kShouldProcessData);
- QuicString body = "this is the body";
+ std::string body = "this is the body";
QuicHeaderList headers = ProcessHeaders(false, headers_);
EXPECT_EQ(headers, stream_->header_list());
@@ -306,12 +307,12 @@
TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBody) {
Initialize(kShouldProcessData);
- QuicString body = "this is the body";
+ std::string body = "this is the body";
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buffer);
- QuicString header = QuicString(buffer.get(), header_length);
- QuicString data = HasFrameHeader() ? header + body : body;
+ std::string header = std::string(buffer.get(), header_length);
+ std::string data = HasFrameHeader() ? header + body : body;
EXPECT_EQ("", stream_->data());
QuicHeaderList headers = ProcessHeaders(false, headers_);
@@ -326,12 +327,12 @@
TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyFragments) {
Initialize(kShouldProcessData);
- QuicString body = "this is the body";
+ std::string body = "this is the body";
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buffer);
- QuicString header = QuicString(buffer.get(), header_length);
- QuicString data = HasFrameHeader() ? header + body : body;
+ std::string header = std::string(buffer.get(), header_length);
+ std::string data = HasFrameHeader() ? header + body : body;
for (size_t fragment_size = 1; fragment_size < data.size(); ++fragment_size) {
Initialize(kShouldProcessData);
@@ -352,12 +353,12 @@
TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyFragmentsSplit) {
Initialize(kShouldProcessData);
- QuicString body = "this is the body";
+ std::string body = "this is the body";
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buffer);
- QuicString header = QuicString(buffer.get(), header_length);
- QuicString data = HasFrameHeader() ? header + body : body;
+ std::string header = std::string(buffer.get(), header_length);
+ std::string data = HasFrameHeader() ? header + body : body;
for (size_t split_point = 1; split_point < data.size() - 1; ++split_point) {
Initialize(kShouldProcessData);
@@ -383,12 +384,12 @@
TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyReadv) {
Initialize(!kShouldProcessData);
- QuicString body = "this is the body";
+ std::string body = "this is the body";
std::unique_ptr<char[]> buf;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buf);
- QuicString header = QuicString(buf.get(), header_length);
- QuicString data = HasFrameHeader() ? header + body : body;
+ std::string header = std::string(buf.get(), header_length);
+ std::string data = HasFrameHeader() ? header + body : body;
ProcessHeaders(false, headers_);
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
@@ -404,17 +405,17 @@
size_t bytes_read = stream_->Readv(&vec, 1);
EXPECT_EQ(body.length(), bytes_read);
- EXPECT_EQ(body, QuicString(buffer, bytes_read));
+ EXPECT_EQ(body, std::string(buffer, bytes_read));
}
TEST_P(QuicSpdyStreamTest, ProcessHeadersAndLargeBodySmallReadv) {
Initialize(kShouldProcessData);
- QuicString body(12 * 1024, 'a');
+ std::string body(12 * 1024, 'a');
std::unique_ptr<char[]> buf;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buf);
- QuicString header = QuicString(buf.get(), header_length);
- QuicString data = HasFrameHeader() ? header + body : body;
+ std::string header = std::string(buf.get(), header_length);
+ std::string data = HasFrameHeader() ? header + body : body;
ProcessHeaders(false, headers_);
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
QuicStringPiece(data));
@@ -429,19 +430,19 @@
vec[1].iov_len = QUIC_ARRAYSIZE(buffer2);
size_t bytes_read = stream_->Readv(vec, 2);
EXPECT_EQ(2048u * 2, bytes_read);
- EXPECT_EQ(body.substr(0, 2048), QuicString(buffer, 2048));
- EXPECT_EQ(body.substr(2048, 2048), QuicString(buffer2, 2048));
+ EXPECT_EQ(body.substr(0, 2048), std::string(buffer, 2048));
+ EXPECT_EQ(body.substr(2048, 2048), std::string(buffer2, 2048));
}
TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyMarkConsumed) {
Initialize(!kShouldProcessData);
- QuicString body = "this is the body";
+ std::string body = "this is the body";
std::unique_ptr<char[]> buf;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buf);
- QuicString header = QuicString(buf.get(), header_length);
- QuicString data = HasFrameHeader() ? header + body : body;
+ std::string header = std::string(buf.get(), header_length);
+ std::string data = HasFrameHeader() ? header + body : body;
ProcessHeaders(false, headers_);
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
@@ -453,7 +454,7 @@
EXPECT_EQ(1, stream_->GetReadableRegions(&vec, 1));
EXPECT_EQ(body.length(), vec.iov_len);
- EXPECT_EQ(body, QuicString(static_cast<char*>(vec.iov_base), vec.iov_len));
+ EXPECT_EQ(body, std::string(static_cast<char*>(vec.iov_base), vec.iov_len));
stream_->MarkConsumed(body.length());
EXPECT_EQ(data.length(), stream_->flow_controller()->bytes_consumed());
@@ -461,15 +462,15 @@
TEST_P(QuicSpdyStreamTest, ProcessHeadersAndConsumeMultipleBody) {
Initialize(!kShouldProcessData);
- QuicString body1 = "this is body 1";
- QuicString body2 = "body 2";
+ std::string body1 = "this is body 1";
+ std::string body2 = "body 2";
std::unique_ptr<char[]> buf;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body1.length(), &buf);
- QuicString header = QuicString(buf.get(), header_length);
- QuicString data1 = HasFrameHeader() ? header + body1 : body1;
+ std::string header = std::string(buf.get(), header_length);
+ std::string data1 = HasFrameHeader() ? header + body1 : body1;
header_length = encoder_.SerializeDataFrameHeader(body2.length(), &buf);
- QuicString data2 = HasFrameHeader() ? header + body2 : body2;
+ std::string data2 = HasFrameHeader() ? header + body2 : body2;
ProcessHeaders(false, headers_);
QuicStreamFrame frame1(GetNthClientInitiatedBidirectionalId(0), false, 0,
@@ -488,12 +489,12 @@
TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyIncrementalReadv) {
Initialize(!kShouldProcessData);
- QuicString body = "this is the body";
+ std::string body = "this is the body";
std::unique_ptr<char[]> buf;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buf);
- QuicString header = QuicString(buf.get(), header_length);
- QuicString data = HasFrameHeader() ? header + body : body;
+ std::string header = std::string(buf.get(), header_length);
+ std::string data = HasFrameHeader() ? header + body : body;
ProcessHeaders(false, headers_);
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
@@ -516,12 +517,12 @@
TEST_P(QuicSpdyStreamTest, ProcessHeadersUsingReadvWithMultipleIovecs) {
Initialize(!kShouldProcessData);
- QuicString body = "this is the body";
+ std::string body = "this is the body";
std::unique_ptr<char[]> buf;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buf);
- QuicString header = QuicString(buf.get(), header_length);
- QuicString data = HasFrameHeader() ? header + body : body;
+ std::string header = std::string(buf.get(), header_length);
+ std::string data = HasFrameHeader() ? header + body : body;
ProcessHeaders(false, headers_);
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
@@ -560,7 +561,7 @@
// Try to send more data than the flow control limit allows.
const uint64_t kOverflow = 15;
- QuicString body(kWindow + kOverflow, 'a');
+ std::string body(kWindow + kOverflow, 'a');
const uint64_t kHeaderLength = HasFrameHeader() ? 2 : 0;
if (HasFrameHeader()) {
@@ -602,14 +603,14 @@
stream_->flow_controller()));
// Stream receives enough data to fill a fraction of the receive window.
- QuicString body(kWindow / 3, 'a');
+ std::string body(kWindow / 3, 'a');
QuicByteCount header_length = 0;
- QuicString data;
+ std::string data;
if (HasFrameHeader()) {
std::unique_ptr<char[]> buffer;
header_length = encoder_.SerializeDataFrameHeader(body.length(), &buffer);
- QuicString header = QuicString(buffer.get(), header_length);
+ std::string header = std::string(buffer.get(), header_length);
data = header + body;
} else {
data = body;
@@ -651,14 +652,14 @@
stream_->flow_controller()));
// Stream receives enough data to fill a fraction of the receive window.
- QuicString body(kWindow / 3, 'a');
+ std::string body(kWindow / 3, 'a');
QuicByteCount header_length = 0;
- QuicString data;
+ std::string data;
if (HasFrameHeader()) {
std::unique_ptr<char[]> buffer;
header_length = encoder_.SerializeDataFrameHeader(body.length(), &buffer);
- QuicString header = QuicString(buffer.get(), header_length);
+ std::string header = std::string(buffer.get(), header_length);
data = header + body;
} else {
data = body;
@@ -719,24 +720,24 @@
// Each stream gets a quarter window of data. This should not trigger a
// WINDOW_UPDATE for either stream, nor for the connection.
QuicByteCount header_length = 0;
- QuicString body;
- QuicString data;
- QuicString data2;
- QuicString body2(1, 'a');
+ std::string body;
+ std::string data;
+ std::string data2;
+ std::string body2(1, 'a');
if (HasFrameHeader()) {
- body = QuicString(kWindow / 4 - 2, 'a');
+ body = std::string(kWindow / 4 - 2, 'a');
std::unique_ptr<char[]> buffer;
header_length = encoder_.SerializeDataFrameHeader(body.length(), &buffer);
- QuicString header = QuicString(buffer.get(), header_length);
+ std::string header = std::string(buffer.get(), header_length);
data = header + body;
std::unique_ptr<char[]> buffer2;
QuicByteCount header_length2 =
encoder_.SerializeDataFrameHeader(body2.length(), &buffer2);
- QuicString header2 = QuicString(buffer2.get(), header_length2);
+ std::string header2 = std::string(buffer2.get(), header_length2);
data2 = header2 + body2;
} else {
- body = QuicString(kWindow / 4, 'a');
+ body = std::string(kWindow / 4, 'a');
data = body;
data2 = body2;
}
@@ -773,12 +774,12 @@
ProcessHeaders(false, headers_);
// Receive data to overflow the window, violating flow control.
- QuicString body(kWindow + 1, 'a');
+ std::string body(kWindow + 1, 'a');
std::unique_ptr<char[]> buf;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buf);
- QuicString header = QuicString(buf.get(), header_length);
- QuicString data = HasFrameHeader() ? header + body : body;
+ std::string header = std::string(buf.get(), header_length);
+ std::string data = HasFrameHeader() ? header + body : body;
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
QuicStringPiece(data));
EXPECT_CALL(*connection_,
@@ -816,12 +817,12 @@
ProcessHeaders(false, headers_);
// Send enough data to overflow the connection level flow control window.
- QuicString body(kConnectionWindow + 1, 'a');
+ std::string body(kConnectionWindow + 1, 'a');
std::unique_ptr<char[]> buf;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buf);
- QuicString header = QuicString(buf.get(), header_length);
- QuicString data = HasFrameHeader() ? header + body : body;
+ std::string header = std::string(buf.get(), header_length);
+ std::string data = HasFrameHeader() ? header + body : body;
EXPECT_LT(data.size(), kStreamWindow);
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
@@ -844,7 +845,7 @@
stream_->flow_controller()));
// Send a frame with a FIN but no data. This should not be blocked.
- QuicString body = "";
+ std::string body = "";
bool fin = true;
EXPECT_CALL(*connection_,
@@ -906,12 +907,12 @@
QuicHeaderList headers = ProcessHeaders(false, headers_);
stream_->ConsumeHeaderList();
- const QuicString body = "this is the body";
+ const std::string body = "this is the body";
std::unique_ptr<char[]> buf;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buf);
- QuicString header = QuicString(buf.get(), header_length);
- QuicString data = HasFrameHeader() ? header + body : body;
+ std::string header = std::string(buf.get(), header_length);
+ std::string data = HasFrameHeader() ? header + body : body;
// Receive trailing headers.
SpdyHeaderBlock trailers_block;
@@ -1041,12 +1042,12 @@
stream_->ConsumeHeaderList();
// Receive and consume body with FIN set, and no trailers.
- QuicString body(1024, 'x');
+ std::string body(1024, 'x');
std::unique_ptr<char[]> buf;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buf);
- QuicString header = QuicString(buf.get(), header_length);
- QuicString data = HasFrameHeader() ? header + body : body;
+ std::string header = std::string(buf.get(), header_length);
+ std::string data = HasFrameHeader() ? header + body : body;
QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), /*fin=*/true,
0, data);
@@ -1083,7 +1084,7 @@
// Write non-zero body data to force a non-zero final offset.
EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).Times(AtLeast(1));
- QuicString body(1024, 'x'); // 1 kB
+ std::string body(1024, 'x'); // 1 kB
QuicByteCount header_length = 0;
if (HasFrameHeader()) {
std::unique_ptr<char[]> buf;
@@ -1116,7 +1117,7 @@
// Write non-zero body data.
EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).Times(AtLeast(1));
const int kBodySize = 1 * 1024; // 1 kB
- stream_->WriteOrBufferBody(QuicString(kBodySize, 'x'), false);
+ stream_->WriteOrBufferBody(std::string(kBodySize, 'x'), false);
EXPECT_EQ(0u, stream_->BufferedDataBytes());
// Headers and body have been fully written, there is no queued data. Writing
@@ -1143,7 +1144,7 @@
}
EXPECT_CALL(*session_, WritevData(_, _, kBodySize, _, NO_FIN))
.WillOnce(Return(QuicConsumedData(kBodySize - 1, false)));
- stream_->WriteOrBufferBody(QuicString(kBodySize, 'x'), false);
+ stream_->WriteOrBufferBody(std::string(kBodySize, 'x'), false);
EXPECT_EQ(1u, stream_->BufferedDataBytes());
// Writing trailers will send a FIN, but not close the write side of the
@@ -1201,11 +1202,11 @@
QuicStreamFrame frame1(
QuicUtils::GetHeadersStreamId(connection_->transport_version()), false, 0,
"Header1");
- QuicString header = "";
+ std::string header = "";
if (HasFrameHeader()) {
std::unique_ptr<char[]> buffer;
QuicByteCount header_length = encoder_.SerializeDataFrameHeader(5, &buffer);
- header = QuicString(buffer.get(), header_length);
+ header = std::string(buffer.get(), header_length);
}
QuicStreamFrame frame2(stream_->id(), true, 0, header + "Test1");
QuicStreamFrame frame3(
@@ -1400,8 +1401,8 @@
QuicReferenceCountedPointer<MockAckListener> mock_ack_listener(
new StrictMock<MockAckListener>);
stream_->set_ack_listener(mock_ack_listener);
- QuicString body = "Test1";
- QuicString body2(100, 'x');
+ std::string body = "Test1";
+ std::string body2(100, 'x');
EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).Times(AtLeast(1));
stream_->WriteOrBufferBody(body, false);
@@ -1410,10 +1411,10 @@
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buffer);
- QuicString header = QuicString(buffer.get(), header_length);
+ std::string header = std::string(buffer.get(), header_length);
header_length = encoder_.SerializeDataFrameHeader(body2.length(), &buffer);
- QuicString header2 = QuicString(buffer.get(), header_length);
+ std::string header2 = std::string(buffer.get(), header_length);
EXPECT_CALL(*mock_ack_listener, OnPacketAcked(body.length(), _));
QuicStreamFrame frame(stream_->id(), false, 0, header + body);
@@ -1445,8 +1446,8 @@
QuicReferenceCountedPointer<MockAckListener> mock_ack_listener(
new StrictMock<MockAckListener>);
stream_->set_ack_listener(mock_ack_listener);
- QuicString body = "Test1";
- QuicString body2(100, 'x');
+ std::string body = "Test1";
+ std::string body2(100, 'x');
struct iovec body1_iov = {const_cast<char*>(body.data()), body.length()};
struct iovec body2_iov = {const_cast<char*>(body2.data()), body2.length()};
QuicMemSliceStorage storage(&body1_iov, 1,
@@ -1460,10 +1461,10 @@
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buffer);
- QuicString header = QuicString(buffer.get(), header_length);
+ std::string header = std::string(buffer.get(), header_length);
header_length = encoder_.SerializeDataFrameHeader(body2.length(), &buffer);
- QuicString header2 = QuicString(buffer.get(), header_length);
+ std::string header2 = std::string(buffer.get(), header_length);
EXPECT_CALL(*mock_ack_listener,
OnPacketAcked(body.length() + body2.length(), _));
@@ -1485,8 +1486,8 @@
QuicReferenceCountedPointer<MockAckListener> mock_ack_listener(
new StrictMock<MockAckListener>);
stream_->set_ack_listener(mock_ack_listener);
- QuicString body = "Test1";
- QuicString body2(100, 'x');
+ std::string body = "Test1";
+ std::string body2(100, 'x');
EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).Times(AtLeast(1));
stream_->WriteOrBufferBody(body, false);
@@ -1495,10 +1496,10 @@
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
encoder_.SerializeDataFrameHeader(body.length(), &buffer);
- QuicString header = QuicString(buffer.get(), header_length);
+ std::string header = std::string(buffer.get(), header_length);
header_length = encoder_.SerializeDataFrameHeader(body2.length(), &buffer);
- QuicString header2 = QuicString(buffer.get(), header_length);
+ std::string header2 = std::string(buffer.get(), header_length);
EXPECT_CALL(*mock_ack_listener, OnPacketRetransmitted(body.length()));
QuicStreamFrame frame(stream_->id(), false, 0, header + body);
diff --git a/quic/core/http/spdy_utils.cc b/quic/core/http/spdy_utils.cc
index 7022ae2..c3f312b 100644
--- a/quic/core/http/spdy_utils.cc
+++ b/quic/core/http/spdy_utils.cc
@@ -61,7 +61,7 @@
int64_t* content_length,
SpdyHeaderBlock* headers) {
for (const auto& p : header_list) {
- const QuicString& name = p.first;
+ const std::string& name = p.first;
if (name.empty()) {
QUIC_DLOG(ERROR) << "Header name must not be empty.";
return false;
@@ -90,7 +90,7 @@
SpdyHeaderBlock* trailers) {
bool found_final_byte_offset = false;
for (const auto& p : header_list) {
- const QuicString& name = p.first;
+ const std::string& name = p.first;
// Pull out the final offset pseudo header which indicates the number of
// response body bytes expected.
@@ -129,7 +129,7 @@
}
// static
-QuicString SpdyUtils::GetPromisedUrlFromHeaders(
+std::string SpdyUtils::GetPromisedUrlFromHeaders(
const SpdyHeaderBlock& headers) {
// RFC 7540, Section 8.1.2.3: All HTTP/2 requests MUST include exactly
// one valid value for the ":method", ":scheme", and ":path" pseudo-header
@@ -150,12 +150,12 @@
// So the only methods allowed in a PUSH_PROMISE are GET and HEAD.
SpdyHeaderBlock::const_iterator it = headers.find(":method");
if (it == headers.end() || (it->second != "GET" && it->second != "HEAD")) {
- return QuicString();
+ return std::string();
}
it = headers.find(":scheme");
if (it == headers.end() || it->second.empty()) {
- return QuicString();
+ return std::string();
}
QuicStringPiece scheme = it->second;
@@ -164,7 +164,7 @@
// (see Section 10.1).
it = headers.find(":authority");
if (it == headers.end() || it->second.empty()) {
- return QuicString();
+ return std::string();
}
QuicStringPiece authority = it->second;
@@ -175,7 +175,7 @@
// is deferred to implementations in QuicUrlUtils::GetPushPromiseUrl().
it = headers.find(":path");
if (it == headers.end()) {
- return QuicString();
+ return std::string();
}
QuicStringPiece path = it->second;
@@ -183,7 +183,7 @@
}
// static
-QuicString SpdyUtils::GetPromisedHostNameFromHeaders(
+std::string SpdyUtils::GetPromisedHostNameFromHeaders(
const SpdyHeaderBlock& headers) {
// TODO(fayang): Consider just checking out the value of the ":authority" key
// in headers.
@@ -192,22 +192,22 @@
// static
bool SpdyUtils::PromisedUrlIsValid(const SpdyHeaderBlock& headers) {
- QuicString url(GetPromisedUrlFromHeaders(headers));
+ std::string url(GetPromisedUrlFromHeaders(headers));
return !url.empty() && GURL(url).is_valid();
}
// static
-bool SpdyUtils::PopulateHeaderBlockFromUrl(const QuicString url,
+bool SpdyUtils::PopulateHeaderBlockFromUrl(const std::string url,
SpdyHeaderBlock* headers) {
(*headers)[":method"] = "GET";
size_t pos = url.find("://");
- if (pos == QuicString::npos) {
+ if (pos == std::string::npos) {
return false;
}
(*headers)[":scheme"] = url.substr(0, pos);
size_t start = pos + 3;
pos = url.find("/", start);
- if (pos == QuicString::npos) {
+ if (pos == std::string::npos) {
(*headers)[":authority"] = url.substr(start);
(*headers)[":path"] = "/";
return true;
@@ -218,9 +218,9 @@
}
// static
-QuicString SpdyUtils::GetPushPromiseUrl(QuicStringPiece scheme,
- QuicStringPiece authority,
- QuicStringPiece path) {
+std::string SpdyUtils::GetPushPromiseUrl(QuicStringPiece scheme,
+ QuicStringPiece authority,
+ QuicStringPiece path) {
// RFC 7540, Section 8.1.2.3: The ":path" pseudo-header field includes the
// path and query parts of the target URI (the "path-absolute" production
// and optionally a '?' character followed by the "query" production (see
@@ -249,7 +249,7 @@
// 8.1.2.3 about OPTIONS requests does not apply here (i.e. ":path" cannot be
// "*").
if (path.empty() || path[0] != '/' || (path.size() >= 2 && path[1] == '/')) {
- return QuicString();
+ return std::string();
}
// Validate the scheme; this is to ensure a scheme of "foo://bar" is not
@@ -262,7 +262,7 @@
if (!url::CanonicalizeScheme(scheme.data(), scheme_component,
&canon_scheme_output, &canon_component) ||
!canon_component.is_nonempty() || canon_component.begin != 0) {
- return QuicString();
+ return std::string();
}
canonical_scheme.resize(canon_component.len + 1);
@@ -285,14 +285,14 @@
// it is performed later in processing, only "http" and "https" schemed
// URIs are supported for PUSH.
if (username_component.is_valid() || password_component.is_valid()) {
- return QuicString();
+ return std::string();
}
// Failed parsing or no host present. ParseAuthority() will ensure that
// host_component + port_component cover the entire string, if
// username_component and password_component are not present.
if (!host_component.is_nonempty()) {
- return QuicString();
+ return std::string();
}
// Validate the port (if present; it's optional).
@@ -300,7 +300,7 @@
if (port_component.is_nonempty()) {
parsed_port_number = url::ParsePort(authority.data(), port_component);
if (parsed_port_number < 0 && parsed_port_number != url::PORT_UNSPECIFIED) {
- return QuicString();
+ return std::string();
}
}
@@ -312,7 +312,7 @@
if (!url::CanonicalizeHost(authority.data(), host_component,
&canon_host_output, &canon_component) ||
!canon_component.is_nonempty() || canon_component.begin != 0) {
- return QuicString();
+ return std::string();
}
// At this point, "authority" has been validated to either be of the form
@@ -332,7 +332,7 @@
origin_url.has_username() || origin_url.has_password() ||
(origin_url.has_path() && origin_url.path_piece() != "/") ||
origin_url.has_query() || origin_url.has_ref()) {
- return QuicString();
+ return std::string();
}
// Attempt to parse the path.
@@ -344,7 +344,7 @@
// fragment to the query.
GURL full_url(spec);
if (!full_url.is_valid() || full_url.has_ref()) {
- return QuicString();
+ return std::string();
}
return full_url.spec();
diff --git a/quic/core/http/spdy_utils.h b/quic/core/http/spdy_utils.h
index 073eeeb..f356767 100644
--- a/quic/core/http/spdy_utils.h
+++ b/quic/core/http/spdy_utils.h
@@ -41,11 +41,11 @@
// :path headers of a PUSH_PROMISE. Returns empty string if the headers do not
// conform to HTTP/2 spec or if the ":method" header contains a forbidden
// method for PUSH_PROMISE.
- static QuicString GetPromisedUrlFromHeaders(
+ static std::string GetPromisedUrlFromHeaders(
const spdy::SpdyHeaderBlock& headers);
// Returns hostname, or empty string if missing.
- static QuicString GetPromisedHostNameFromHeaders(
+ static std::string GetPromisedHostNameFromHeaders(
const spdy::SpdyHeaderBlock& headers);
// Returns true if result of |GetPromisedUrlFromHeaders()| is non-empty
@@ -54,15 +54,15 @@
// Populates the fields of |headers| to make a GET request of |url|,
// which must be fully-qualified.
- static bool PopulateHeaderBlockFromUrl(const QuicString url,
+ static bool PopulateHeaderBlockFromUrl(const std::string url,
spdy::SpdyHeaderBlock* headers);
// Returns a canonical, valid URL for a PUSH_PROMISE with the specified
// ":scheme", ":authority", and ":path" header fields, or an empty
// string if the resulting URL is not valid or supported.
- static QuicString GetPushPromiseUrl(QuicStringPiece scheme,
- QuicStringPiece authority,
- QuicStringPiece path);
+ static std::string GetPushPromiseUrl(QuicStringPiece scheme,
+ QuicStringPiece authority,
+ QuicStringPiece path);
};
} // namespace quic
diff --git a/quic/core/http/spdy_utils_test.cc b/quic/core/http/spdy_utils_test.cc
index 6cd2f1d..5e6fbbf 100644
--- a/quic/core/http/spdy_utils_test.cc
+++ b/quic/core/http/spdy_utils_test.cc
@@ -39,7 +39,7 @@
{"cookie", "part3"},
// Already-delimited headers are passed through.
- {"passed-through", QuicString("foo\0baz", 7)},
+ {"passed-through", std::string("foo\0baz", 7)},
// Other headers are joined on \0.
{"joined", "value 1"},
@@ -374,7 +374,7 @@
using PopulateHeaderBlockFromUrl = QuicTest;
TEST_F(PopulateHeaderBlockFromUrl, NormalUsage) {
- QuicString url = "https://www.google.com/index.html";
+ std::string url = "https://www.google.com/index.html";
SpdyHeaderBlock headers;
EXPECT_TRUE(SpdyUtils::PopulateHeaderBlockFromUrl(url, &headers));
EXPECT_EQ("https", headers[":scheme"].as_string());
@@ -383,7 +383,7 @@
}
TEST_F(PopulateHeaderBlockFromUrl, UrlWithNoPath) {
- QuicString url = "https://www.google.com";
+ std::string url = "https://www.google.com";
SpdyHeaderBlock headers;
EXPECT_TRUE(SpdyUtils::PopulateHeaderBlockFromUrl(url, &headers));
EXPECT_EQ("https", headers[":scheme"].as_string());
diff --git a/quic/core/packet_number_indexed_queue_test.cc b/quic/core/packet_number_indexed_queue_test.cc
index 294d2a4..7643fe4 100644
--- a/quic/core/packet_number_indexed_queue_test.cc
+++ b/quic/core/packet_number_indexed_queue_test.cc
@@ -18,7 +18,7 @@
PacketNumberIndexedQueueTest() {}
protected:
- PacketNumberIndexedQueue<QuicString> queue_;
+ PacketNumberIndexedQueue<std::string> queue_;
};
TEST_F(PacketNumberIndexedQueueTest, InitialState) {
diff --git a/quic/core/qpack/fuzzer/qpack_encoder_stream_sender_fuzzer.cc b/quic/core/qpack/fuzzer/qpack_encoder_stream_sender_fuzzer.cc
index 501a69f..bc4de90 100644
--- a/quic/core/qpack/fuzzer/qpack_encoder_stream_sender_fuzzer.cc
+++ b/quic/core/qpack/fuzzer/qpack_encoder_stream_sender_fuzzer.cc
@@ -35,7 +35,7 @@
uint64_t name_index = provider.ConsumeIntegral<uint64_t>();
uint16_t value_length =
provider.ConsumeIntegralInRange<uint16_t>(0, kMaxStringLength);
- QuicString value = provider.ConsumeRandomLengthString(value_length);
+ std::string value = provider.ConsumeRandomLengthString(value_length);
sender.SendInsertWithNameReference(is_static, name_index, value);
break;
@@ -43,10 +43,10 @@
case 1: {
uint16_t name_length =
provider.ConsumeIntegralInRange<uint16_t>(0, kMaxStringLength);
- QuicString name = provider.ConsumeRandomLengthString(name_length);
+ std::string name = provider.ConsumeRandomLengthString(name_length);
uint16_t value_length =
provider.ConsumeIntegralInRange<uint16_t>(0, kMaxStringLength);
- QuicString value = provider.ConsumeRandomLengthString(value_length);
+ std::string value = provider.ConsumeRandomLengthString(value_length);
sender.SendInsertWithoutNameReference(name, value);
break;
}
diff --git a/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc b/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
index 7f75a0f..3c21964 100644
--- a/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
+++ b/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
@@ -32,8 +32,8 @@
break;
}
- QuicString name;
- QuicString value;
+ std::string name;
+ std::string value;
switch (provider.ConsumeIntegral<uint8_t>()) {
case 0:
// Static table entry with no header value.
@@ -126,7 +126,7 @@
// Encode header list.
NoopDecoderStreamErrorDelegate decoder_stream_error_delegate;
NoopEncoderStreamSenderDelegate encoder_stream_sender_delegate;
- QuicString encoded_header_block = QpackEncode(
+ std::string encoded_header_block = QpackEncode(
&decoder_stream_error_delegate, &encoder_stream_sender_delegate,
fragment_size_generator, &header_list);
diff --git a/quic/core/qpack/offline/qpack_offline_decoder.cc b/quic/core/qpack/offline/qpack_offline_decoder.cc
index 2b02edd..137ee7c 100644
--- a/quic/core/qpack/offline/qpack_offline_decoder.cc
+++ b/quic/core/qpack/offline/qpack_offline_decoder.cc
@@ -107,7 +107,7 @@
QuicStringPiece input_filename) {
// Store data in |input_data_storage|; use a QuicStringPiece to efficiently
// keep track of remaining portion yet to be decoded.
- QuicString input_data_storage;
+ std::string input_data_storage;
ReadFileContents(input_filename, &input_data_storage);
QuicStringPiece input_data(input_data_storage);
@@ -166,7 +166,7 @@
QuicStringPiece expected_headers_filename) {
// Store data in |expected_headers_data_storage|; use a QuicStringPiece to
// efficiently keep track of remaining portion yet to be decoded.
- QuicString expected_headers_data_storage;
+ std::string expected_headers_data_storage;
ReadFileContents(expected_headers_filename, &expected_headers_data_storage);
QuicStringPiece expected_headers_data(expected_headers_data_storage);
diff --git a/quic/core/qpack/offline/qpack_offline_decoder_bin.cc b/quic/core/qpack/offline/qpack_offline_decoder_bin.cc
index a0319e6..a4f5373 100644
--- a/quic/core/qpack/offline/qpack_offline_decoder_bin.cc
+++ b/quic/core/qpack/offline/qpack_offline_decoder_bin.cc
@@ -15,7 +15,7 @@
const char* usage =
"Usage: qpack_offline_decoder input_filename expected_headers_filename "
"....";
- std::vector<quic::QuicString> args =
+ std::vector<std::string> args =
quic::QuicParseCommandLineFlags(usage, argc, argv);
if (args.size() < 2 || args.size() % 2 != 0) {
diff --git a/quic/core/qpack/qpack_decoded_headers_accumulator.h b/quic/core/qpack/qpack_decoded_headers_accumulator.h
index 47d4f63..889769f 100644
--- a/quic/core/qpack/qpack_decoded_headers_accumulator.h
+++ b/quic/core/qpack/qpack_decoded_headers_accumulator.h
@@ -56,7 +56,7 @@
size_t uncompressed_header_bytes_;
size_t compressed_header_bytes_;
bool error_detected_;
- QuicString error_message_;
+ std::string error_message_;
};
} // namespace quic
diff --git a/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc b/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
index 0c71b19..27c6fa1 100644
--- a/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
+++ b/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
@@ -79,7 +79,7 @@
EXPECT_CALL(decoder_stream_sender_delegate_,
WriteDecoderStreamData(Eq(kHeaderAcknowledgement)));
- QuicString encoded_data(QuicTextUtils::HexDecode("000023666f6f03626172"));
+ std::string encoded_data(QuicTextUtils::HexDecode("000023666f6f03626172"));
EXPECT_TRUE(accumulator_.Decode(encoded_data));
EXPECT_TRUE(accumulator_.EndHeaderBlock());
diff --git a/quic/core/qpack/qpack_decoder_stream_sender.cc b/quic/core/qpack/qpack_decoder_stream_sender.cc
index 141b64a..cdb3b35 100644
--- a/quic/core/qpack/qpack_decoder_stream_sender.cc
+++ b/quic/core/qpack/qpack_decoder_stream_sender.cc
@@ -23,7 +23,7 @@
instruction_encoder_.Encode(InsertCountIncrementInstruction());
- QuicString output;
+ std::string output;
instruction_encoder_.Next(std::numeric_limits<size_t>::max(), &output);
DCHECK(!instruction_encoder_.HasNext());
@@ -37,7 +37,7 @@
instruction_encoder_.Encode(HeaderAcknowledgementInstruction());
- QuicString output;
+ std::string output;
instruction_encoder_.Next(std::numeric_limits<size_t>::max(), &output);
DCHECK(!instruction_encoder_.HasNext());
@@ -50,7 +50,7 @@
instruction_encoder_.Encode(StreamCancellationInstruction());
- QuicString output;
+ std::string output;
instruction_encoder_.Next(std::numeric_limits<size_t>::max(), &output);
DCHECK(!instruction_encoder_.HasNext());
diff --git a/quic/core/qpack/qpack_decoder_test.cc b/quic/core/qpack/qpack_decoder_test.cc
index 7292c50..d6740c8 100644
--- a/quic/core/qpack/qpack_decoder_test.cc
+++ b/quic/core/qpack/qpack_decoder_test.cc
@@ -62,8 +62,10 @@
const FragmentMode fragment_mode_;
};
-INSTANTIATE_TEST_SUITE_P(, QpackDecoderTest, Values(FragmentMode::kSingleChunk,
- FragmentMode::kOctetByOctet));
+INSTANTIATE_TEST_SUITE_P(,
+ QpackDecoderTest,
+ Values(FragmentMode::kSingleChunk,
+ FragmentMode::kOctetByOctet));
TEST_P(QpackDecoderTest, NoPrefix) {
EXPECT_CALL(handler_,
@@ -119,7 +121,7 @@
TEST_P(QpackDecoderTest, MultipleLiteralEntries) {
EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("bar")));
- QuicString str(127, 'a');
+ std::string str(127, 'a');
EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foobaar"), QuicStringPiece(str)));
EXPECT_CALL(handler_, OnDecodingCompleted());
EXPECT_CALL(decoder_stream_sender_delegate_,
@@ -558,11 +560,11 @@
DecodeEncoderStreamData(
QuicTextUtils::HexDecode("6294e7" // Name "foo".
"7fd903")); // Value length 600.
- QuicString header_value(600, 'Z');
+ std::string header_value(600, 'Z');
DecodeEncoderStreamData(header_value);
// Duplicate most recent entry 200 times.
- DecodeEncoderStreamData(QuicString(200, '\x00'));
+ DecodeEncoderStreamData(std::string(200, '\x00'));
// Now there is only one entry in the dynamic table, with absolute index 200.
diff --git a/quic/core/qpack/qpack_encoder_stream_receiver_test.cc b/quic/core/qpack/qpack_encoder_stream_receiver_test.cc
index 5685981..dcb2039 100644
--- a/quic/core/qpack/qpack_encoder_stream_receiver_test.cc
+++ b/quic/core/qpack/qpack_encoder_stream_receiver_test.cc
@@ -54,7 +54,7 @@
// Value length does not fit in prefix.
// 'Z' would be Huffman encoded to 8 bits, so no Huffman encoding is used.
EXPECT_CALL(*delegate(),
- OnInsertWithNameReference(false, 42, Eq(QuicString(127, 'Z'))));
+ OnInsertWithNameReference(false, 42, Eq(std::string(127, 'Z'))));
Decode(QuicTextUtils::HexDecode(
"c500"
@@ -88,8 +88,8 @@
// Not Huffman encoded long strings; length does not fit on prefix.
// 'Z' would be Huffman encoded to 8 bits, so no Huffman encoding is used.
EXPECT_CALL(*delegate(),
- OnInsertWithoutNameReference(Eq(QuicString(31, 'Z')),
- Eq(QuicString(127, 'Z'))));
+ OnInsertWithoutNameReference(Eq(std::string(31, 'Z')),
+ Eq(std::string(127, 'Z'))));
Decode(QuicTextUtils::HexDecode(
"4000"
diff --git a/quic/core/qpack/qpack_encoder_stream_sender.cc b/quic/core/qpack/qpack_encoder_stream_sender.cc
index fb43046..6cd458a 100644
--- a/quic/core/qpack/qpack_encoder_stream_sender.cc
+++ b/quic/core/qpack/qpack_encoder_stream_sender.cc
@@ -28,7 +28,7 @@
instruction_encoder_.Encode(InsertWithNameReferenceInstruction());
- QuicString output;
+ std::string output;
instruction_encoder_.Next(std::numeric_limits<size_t>::max(), &output);
DCHECK(!instruction_encoder_.HasNext());
@@ -44,7 +44,7 @@
instruction_encoder_.Encode(InsertWithoutNameReferenceInstruction());
- QuicString output;
+ std::string output;
instruction_encoder_.Next(std::numeric_limits<size_t>::max(), &output);
DCHECK(!instruction_encoder_.HasNext());
@@ -57,7 +57,7 @@
instruction_encoder_.Encode(DuplicateInstruction());
- QuicString output;
+ std::string output;
instruction_encoder_.Next(std::numeric_limits<size_t>::max(), &output);
DCHECK(!instruction_encoder_.HasNext());
@@ -70,7 +70,7 @@
instruction_encoder_.Encode(SetDynamicTableCapacityInstruction());
- QuicString output;
+ std::string output;
instruction_encoder_.Next(std::numeric_limits<size_t>::max(), &output);
DCHECK(!instruction_encoder_.HasNext());
diff --git a/quic/core/qpack/qpack_encoder_stream_sender_test.cc b/quic/core/qpack/qpack_encoder_stream_sender_test.cc
index a850f18..a2e7376 100644
--- a/quic/core/qpack/qpack_encoder_stream_sender_test.cc
+++ b/quic/core/qpack/qpack_encoder_stream_sender_test.cc
@@ -51,7 +51,7 @@
"5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"
"5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"
"5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"))));
- stream_.SendInsertWithNameReference(false, 42, QuicString(127, 'Z'));
+ stream_.SendInsertWithNameReference(false, 42, std::string(127, 'Z'));
}
TEST_F(QpackEncoderStreamSenderTest, InsertWithoutNameReference) {
@@ -80,8 +80,8 @@
"5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"
"5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"
"5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"))));
- stream_.SendInsertWithoutNameReference(QuicString(31, 'Z'),
- QuicString(127, 'Z'));
+ stream_.SendInsertWithoutNameReference(std::string(31, 'Z'),
+ std::string(127, 'Z'));
}
TEST_F(QpackEncoderStreamSenderTest, Duplicate) {
diff --git a/quic/core/qpack/qpack_encoder_test.cc b/quic/core/qpack/qpack_encoder_test.cc
index 6dea968..939856d 100644
--- a/quic/core/qpack/qpack_encoder_test.cc
+++ b/quic/core/qpack/qpack_encoder_test.cc
@@ -24,7 +24,7 @@
QpackEncoderTest() : fragment_mode_(GetParam()) {}
~QpackEncoderTest() override = default;
- QuicString Encode(const spdy::SpdyHeaderBlock* header_list) {
+ std::string Encode(const spdy::SpdyHeaderBlock* header_list) {
return QpackEncode(
&decoder_stream_error_delegate_, &encoder_stream_sender_delegate_,
FragmentModeToFragmentSizeGenerator(fragment_mode_), header_list);
@@ -44,7 +44,7 @@
TEST_P(QpackEncoderTest, Empty) {
spdy::SpdyHeaderBlock header_list;
- QuicString output = Encode(&header_list);
+ std::string output = Encode(&header_list);
EXPECT_EQ(QuicTextUtils::HexDecode("0000"), output);
}
@@ -52,7 +52,7 @@
TEST_P(QpackEncoderTest, EmptyName) {
spdy::SpdyHeaderBlock header_list;
header_list[""] = "foo";
- QuicString output = Encode(&header_list);
+ std::string output = Encode(&header_list);
EXPECT_EQ(QuicTextUtils::HexDecode("0000208294e7"), output);
}
@@ -60,7 +60,7 @@
TEST_P(QpackEncoderTest, EmptyValue) {
spdy::SpdyHeaderBlock header_list;
header_list["foo"] = "";
- QuicString output = Encode(&header_list);
+ std::string output = Encode(&header_list);
EXPECT_EQ(QuicTextUtils::HexDecode("00002a94e700"), output);
}
@@ -68,7 +68,7 @@
TEST_P(QpackEncoderTest, EmptyNameAndValue) {
spdy::SpdyHeaderBlock header_list;
header_list[""] = "";
- QuicString output = Encode(&header_list);
+ std::string output = Encode(&header_list);
EXPECT_EQ(QuicTextUtils::HexDecode("00002000"), output);
}
@@ -76,7 +76,7 @@
TEST_P(QpackEncoderTest, Simple) {
spdy::SpdyHeaderBlock header_list;
header_list["foo"] = "bar";
- QuicString output = Encode(&header_list);
+ std::string output = Encode(&header_list);
EXPECT_EQ(QuicTextUtils::HexDecode("00002a94e703626172"), output);
}
@@ -85,8 +85,8 @@
spdy::SpdyHeaderBlock header_list;
header_list["foo"] = "bar";
// 'Z' would be Huffman encoded to 8 bits, so no Huffman encoding is used.
- header_list["ZZZZZZZ"] = QuicString(127, 'Z');
- QuicString output = Encode(&header_list);
+ header_list["ZZZZZZZ"] = std::string(127, 'Z');
+ std::string output = Encode(&header_list);
EXPECT_EQ(
QuicTextUtils::HexDecode(
@@ -110,7 +110,7 @@
header_list["accept-encoding"] = "gzip, deflate, br";
header_list["location"] = "";
- QuicString output = Encode(&header_list);
+ std::string output = Encode(&header_list);
EXPECT_EQ(QuicTextUtils::HexDecode("0000d1dfcc"), output);
}
{
@@ -119,7 +119,7 @@
header_list["accept-encoding"] = "compress";
header_list["location"] = "foo";
- QuicString output = Encode(&header_list);
+ std::string output = Encode(&header_list);
EXPECT_EQ(QuicTextUtils::HexDecode("0000d45f108621e9aec2a11f5c8294e7"),
output);
}
@@ -128,7 +128,7 @@
header_list[":method"] = "TRACE";
header_list["accept-encoding"] = "";
- QuicString output = Encode(&header_list);
+ std::string output = Encode(&header_list);
EXPECT_EQ(QuicTextUtils::HexDecode("00005f000554524143455f1000"), output);
}
}
@@ -145,7 +145,7 @@
// This indexed header field takes exactly three bytes:
// two for the prefix, one for the indexed static entry.
- QuicString output;
+ std::string output;
progressive_encoder->Next(3, &output);
EXPECT_EQ(QuicTextUtils::HexDecode("0000c1"), output);
diff --git a/quic/core/qpack/qpack_encoder_test_utils.cc b/quic/core/qpack/qpack_encoder_test_utils.cc
index b9a3263..dd1ccb3 100644
--- a/quic/core/qpack/qpack_encoder_test_utils.cc
+++ b/quic/core/qpack/qpack_encoder_test_utils.cc
@@ -15,7 +15,7 @@
void NoopEncoderStreamSenderDelegate::WriteEncoderStreamData(
QuicStringPiece data) {}
-QuicString QpackEncode(
+std::string QpackEncode(
QpackEncoder::DecoderStreamErrorDelegate* decoder_stream_error_delegate,
QpackEncoderStreamSender::Delegate* encoder_stream_sender_delegate,
const FragmentSizeGenerator& fragment_size_generator,
@@ -25,7 +25,7 @@
auto progressive_encoder =
encoder.EncodeHeaderList(/* stream_id = */ 1, header_list);
- QuicString output;
+ std::string output;
while (progressive_encoder->HasNext()) {
progressive_encoder->Next(fragment_size_generator(), &output);
}
diff --git a/quic/core/qpack/qpack_encoder_test_utils.h b/quic/core/qpack/qpack_encoder_test_utils.h
index 03d05cb..cb27ab5 100644
--- a/quic/core/qpack/qpack_encoder_test_utils.h
+++ b/quic/core/qpack/qpack_encoder_test_utils.h
@@ -51,7 +51,7 @@
MOCK_METHOD1(WriteEncoderStreamData, void(QuicStringPiece data));
};
-QuicString QpackEncode(
+std::string QpackEncode(
QpackEncoder::DecoderStreamErrorDelegate* decoder_stream_error_delegate,
QpackEncoderStreamSender::Delegate* encoder_stream_sender_delegate,
const FragmentSizeGenerator& fragment_size_generator,
diff --git a/quic/core/qpack/qpack_instruction_decoder.cc b/quic/core/qpack/qpack_instruction_decoder.cc
index dbb2076..96d1a61 100644
--- a/quic/core/qpack/qpack_instruction_decoder.cc
+++ b/quic/core/qpack/qpack_instruction_decoder.cc
@@ -228,7 +228,7 @@
return;
}
- QuicString* const string =
+ std::string* const string =
(field_->type == QpackInstructionFieldType::kName) ? &name_ : &value_;
string->clear();
@@ -248,7 +248,7 @@
DCHECK(field_->type == QpackInstructionFieldType::kName ||
field_->type == QpackInstructionFieldType::kValue);
- QuicString* const string =
+ std::string* const string =
(field_->type == QpackInstructionFieldType::kName) ? &name_ : &value_;
DCHECK_LT(string->size(), string_length_);
@@ -267,14 +267,14 @@
DCHECK(field_->type == QpackInstructionFieldType::kName ||
field_->type == QpackInstructionFieldType::kValue);
- QuicString* const string =
+ std::string* const string =
(field_->type == QpackInstructionFieldType::kName) ? &name_ : &value_;
DCHECK_EQ(string->size(), string_length_);
if (is_huffman_encoded_) {
huffman_decoder_.Reset();
// HpackHuffmanDecoder::Decode() cannot perform in-place decoding.
- QuicString decoded_value;
+ std::string decoded_value;
huffman_decoder_.Decode(*string, &decoded_value);
if (!huffman_decoder_.InputProperlyTerminated()) {
OnError("Error in Huffman-encoded string.");
diff --git a/quic/core/qpack/qpack_instruction_decoder.h b/quic/core/qpack/qpack_instruction_decoder.h
index 9d674c3..49fb0cc 100644
--- a/quic/core/qpack/qpack_instruction_decoder.h
+++ b/quic/core/qpack/qpack_instruction_decoder.h
@@ -61,8 +61,8 @@
bool s_bit() const { return s_bit_; }
uint64_t varint() const { return varint_; }
uint64_t varint2() const { return varint2_; }
- const QuicString& name() const { return name_; }
- const QuicString& value() const { return value_; }
+ const std::string& name() const { return name_; }
+ const std::string& value() const { return value_; }
private:
enum class State {
@@ -114,8 +114,8 @@
bool s_bit_;
uint64_t varint_;
uint64_t varint2_;
- QuicString name_;
- QuicString value_;
+ std::string name_;
+ std::string value_;
// Whether the currently decoded header name or value is Huffman encoded.
bool is_huffman_encoded_;
// Length of string being read into |name_| or |value_|.
diff --git a/quic/core/qpack/qpack_instruction_encoder.cc b/quic/core/qpack/qpack_instruction_encoder.cc
index 72aa7fd..ff135bb 100644
--- a/quic/core/qpack/qpack_instruction_encoder.cc
+++ b/quic/core/qpack/qpack_instruction_encoder.cc
@@ -34,7 +34,7 @@
}
void QpackInstructionEncoder::Next(size_t max_encoded_bytes,
- QuicString* output) {
+ std::string* output) {
DCHECK(HasNext());
DCHECK_NE(0u, max_encoded_bytes);
@@ -108,7 +108,7 @@
}
size_t QpackInstructionEncoder::DoVarintStart(size_t max_encoded_bytes,
- QuicString* output) {
+ std::string* output) {
DCHECK(field_->type == QpackInstructionFieldType::kVarint ||
field_->type == QpackInstructionFieldType::kVarint2 ||
field_->type == QpackInstructionFieldType::kName ||
@@ -149,7 +149,7 @@
}
size_t QpackInstructionEncoder::DoVarintResume(size_t max_encoded_bytes,
- QuicString* output) {
+ std::string* output) {
DCHECK(field_->type == QpackInstructionFieldType::kVarint ||
field_->type == QpackInstructionFieldType::kVarint2 ||
field_->type == QpackInstructionFieldType::kName ||
@@ -195,7 +195,7 @@
}
size_t QpackInstructionEncoder::DoWriteString(size_t max_encoded_bytes,
- QuicString* output) {
+ std::string* output) {
DCHECK(field_->type == QpackInstructionFieldType::kName ||
field_->type == QpackInstructionFieldType::kValue);
diff --git a/quic/core/qpack/qpack_instruction_encoder.h b/quic/core/qpack/qpack_instruction_encoder.h
index 15d908a..c95ceec 100644
--- a/quic/core/qpack/qpack_instruction_encoder.h
+++ b/quic/core/qpack/qpack_instruction_encoder.h
@@ -45,7 +45,7 @@
// Encodes the next up to |max_encoded_bytes| octets of the current
// instruction, appending to |output|. Must only be called when HasNext()
// returns true. |max_encoded_bytes| must be positive.
- void Next(size_t max_encoded_bytes, QuicString* output);
+ void Next(size_t max_encoded_bytes, std::string* output);
private:
enum class State {
@@ -73,10 +73,10 @@
void DoOpcode();
void DoStartField();
void DoStaticBit();
- size_t DoVarintStart(size_t max_encoded_bytes, QuicString* output);
- size_t DoVarintResume(size_t max_encoded_bytes, QuicString* output);
+ size_t DoVarintStart(size_t max_encoded_bytes, std::string* output);
+ size_t DoVarintResume(size_t max_encoded_bytes, std::string* output);
void DoStartString();
- size_t DoWriteString(size_t max_encoded_bytes, QuicString* output);
+ size_t DoWriteString(size_t max_encoded_bytes, std::string* output);
// Storage for field values to be encoded.
bool s_bit_;
@@ -89,7 +89,7 @@
// Storage for the Huffman encoded string literal to be written if Huffman
// encoding is used.
- QuicString huffman_encoded_string_;
+ std::string huffman_encoded_string_;
// If Huffman encoding is used, points to a substring of
// |huffman_encoded_string_|.
diff --git a/quic/core/qpack/qpack_instruction_encoder_test.cc b/quic/core/qpack/qpack_instruction_encoder_test.cc
index 006476f..babbb8c 100644
--- a/quic/core/qpack/qpack_instruction_encoder_test.cc
+++ b/quic/core/qpack/qpack_instruction_encoder_test.cc
@@ -23,12 +23,12 @@
~QpackInstructionEncoderTest() override = default;
// Encode |instruction| with fragment sizes dictated by |fragment_mode_|.
- QuicString EncodeInstruction(const QpackInstruction* instruction) {
+ std::string EncodeInstruction(const QpackInstruction* instruction) {
EXPECT_FALSE(encoder_.HasNext());
FragmentSizeGenerator fragment_size_generator =
FragmentModeToFragmentSizeGenerator(fragment_mode_);
- QuicString output;
+ std::string output;
encoder_.Encode(instruction);
while (encoder_.HasNext()) {
encoder_.Next(fragment_size_generator(), &output);
diff --git a/quic/core/qpack/qpack_progressive_encoder.cc b/quic/core/qpack/qpack_progressive_encoder.cc
index 41433ff..497465b 100644
--- a/quic/core/qpack/qpack_progressive_encoder.cc
+++ b/quic/core/qpack/qpack_progressive_encoder.cc
@@ -37,7 +37,7 @@
}
void QpackProgressiveEncoder::Next(size_t max_encoded_bytes,
- QuicString* output) {
+ std::string* output) {
DCHECK_NE(0u, max_encoded_bytes);
DCHECK(HasNext());
diff --git a/quic/core/qpack/qpack_progressive_encoder.h b/quic/core/qpack/qpack_progressive_encoder.h
index 86cce55..8e204e2 100644
--- a/quic/core/qpack/qpack_progressive_encoder.h
+++ b/quic/core/qpack/qpack_progressive_encoder.h
@@ -36,7 +36,7 @@
bool HasNext() const override;
// Encodes up to |max_encoded_bytes| octets, appending to |output|.
- void Next(size_t max_encoded_bytes, QuicString* output) override;
+ void Next(size_t max_encoded_bytes, std::string* output) override;
private:
const QuicStreamId stream_id_;
diff --git a/quic/core/qpack/qpack_round_trip_test.cc b/quic/core/qpack/qpack_round_trip_test.cc
index 700ff85..99d55fb 100644
--- a/quic/core/qpack/qpack_round_trip_test.cc
+++ b/quic/core/qpack/qpack_round_trip_test.cc
@@ -32,7 +32,7 @@
const spdy::SpdyHeaderBlock& header_list) {
NoopDecoderStreamErrorDelegate decoder_stream_error_delegate;
NoopEncoderStreamSenderDelegate encoder_stream_sender_delegate;
- QuicString encoded_header_block = QpackEncode(
+ std::string encoded_header_block = QpackEncode(
&decoder_stream_error_delegate, &encoder_stream_sender_delegate,
FragmentModeToFragmentSizeGenerator(encoding_fragment_mode_),
&header_list);
@@ -90,8 +90,8 @@
spdy::SpdyHeaderBlock header_list;
header_list["foo"] = "bar";
header_list[":path"] = "/";
- header_list["foobaar"] = QuicString(127, 'Z');
- header_list[QuicString(1000, 'b')] = QuicString(1000, 'c');
+ header_list["foobaar"] = std::string(127, 'Z');
+ header_list[std::string(1000, 'b')] = std::string(1000, 'c');
spdy::SpdyHeaderBlock output = EncodeThenDecode(header_list);
EXPECT_EQ(header_list, output);
diff --git a/quic/core/quic_bandwidth.cc b/quic/core/quic_bandwidth.cc
index cdcf003..a88e15b 100644
--- a/quic/core/quic_bandwidth.cc
+++ b/quic/core/quic_bandwidth.cc
@@ -11,7 +11,7 @@
namespace quic {
-QuicString QuicBandwidth::ToDebugValue() const {
+std::string QuicBandwidth::ToDebugValue() const {
if (bits_per_second_ < 80000) {
return QuicStringPrintf("%" PRId64 " bits/s (%" PRId64 " bytes/s)",
bits_per_second_, bits_per_second_ / 8);
diff --git a/quic/core/quic_bandwidth.h b/quic/core/quic_bandwidth.h
index be3c158..1160d92 100644
--- a/quic/core/quic_bandwidth.h
+++ b/quic/core/quic_bandwidth.h
@@ -86,7 +86,7 @@
bits_per_second_);
}
- QuicString ToDebugValue() const;
+ std::string ToDebugValue() const;
private:
explicit constexpr QuicBandwidth(int64_t bits_per_second)
diff --git a/quic/core/quic_buffered_packet_store.cc b/quic/core/quic_buffered_packet_store.cc
index 68ebac9..d5637ca 100644
--- a/quic/core/quic_buffered_packet_store.cc
+++ b/quic/core/quic_buffered_packet_store.cc
@@ -85,7 +85,7 @@
QuicSocketAddress self_address,
QuicSocketAddress peer_address,
bool is_chlo,
- const QuicString& alpn,
+ const std::string& alpn,
const ParsedQuicVersion& version) {
QUIC_BUG_IF(!FLAGS_quic_allow_chlo_buffering)
<< "Shouldn't buffer packets if disabled via flag.";
diff --git a/quic/core/quic_buffered_packet_store.h b/quic/core/quic_buffered_packet_store.h
index f2490ee..f30bacd 100644
--- a/quic/core/quic_buffered_packet_store.h
+++ b/quic/core/quic_buffered_packet_store.h
@@ -67,7 +67,7 @@
std::list<BufferedPacket> buffered_packets;
QuicTime creation_time;
// The alpn from the CHLO, if one was found.
- QuicString alpn;
+ std::string alpn;
// Indicating whether this is an IETF QUIC connection.
bool ietf_quic;
// If buffered_packets contains the CHLO, it is the version of the CHLO.
@@ -108,7 +108,7 @@
QuicSocketAddress self_address,
QuicSocketAddress peer_address,
bool is_chlo,
- const QuicString& alpn,
+ const std::string& alpn,
const ParsedQuicVersion& version);
// Returns true if there are any packets buffered for |connection_id|.
diff --git a/quic/core/quic_buffered_packet_store_test.cc b/quic/core/quic_buffered_packet_store_test.cc
index e214ff1..bee0f13 100644
--- a/quic/core/quic_buffered_packet_store_test.cc
+++ b/quic/core/quic_buffered_packet_store_test.cc
@@ -64,7 +64,7 @@
QuicBufferedPacketStore store_;
QuicSocketAddress self_address_;
QuicSocketAddress peer_address_;
- QuicString packet_content_;
+ std::string packet_content_;
QuicTime packet_time_;
QuicReceivedPacket packet_;
const ParsedQuicVersion invalid_version_;
diff --git a/quic/core/quic_config.cc b/quic/core/quic_config.cc
index e53719c..1b70463 100644
--- a/quic/core/quic_config.cc
+++ b/quic/core/quic_config.cc
@@ -29,7 +29,7 @@
QuicConfigPresence presence,
uint32_t default_value,
uint32_t* out,
- QuicString* error_details) {
+ std::string* error_details) {
DCHECK(error_details != nullptr);
QuicErrorCode error = msg.GetUint32(tag, out);
switch (error) {
@@ -97,7 +97,7 @@
QuicErrorCode QuicNegotiableUint32::ProcessPeerHello(
const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- QuicString* error_details) {
+ std::string* error_details) {
DCHECK(!negotiated());
DCHECK(error_details != nullptr);
uint32_t value;
@@ -111,7 +111,7 @@
QuicErrorCode QuicNegotiableUint32::ReceiveValue(uint32_t value,
HelloType hello_type,
- QuicString* error_details) {
+ std::string* error_details) {
if (hello_type == SERVER && value > max_value_) {
*error_details = "Invalid value received for " + QuicTagToString(tag_);
return QUIC_INVALID_NEGOTIATED_VALUE;
@@ -167,7 +167,7 @@
QuicErrorCode QuicFixedUint32::ProcessPeerHello(
const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- QuicString* error_details) {
+ std::string* error_details) {
DCHECK(error_details != nullptr);
QuicErrorCode error = peer_hello.GetUint32(tag_, &receive_value_);
switch (error) {
@@ -232,7 +232,7 @@
QuicErrorCode QuicFixedUint128::ProcessPeerHello(
const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- QuicString* error_details) {
+ std::string* error_details) {
DCHECK(error_details != nullptr);
QuicErrorCode error = peer_hello.GetUint128(tag_, &receive_value_);
switch (error) {
@@ -302,7 +302,7 @@
QuicErrorCode QuicFixedTagVector::ProcessPeerHello(
const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- QuicString* error_details) {
+ std::string* error_details) {
DCHECK(error_details != nullptr);
QuicTagVector values;
QuicErrorCode error = peer_hello.GetTaglist(tag_, &values);
@@ -375,7 +375,7 @@
QuicErrorCode QuicFixedSocketAddress::ProcessPeerHello(
const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- QuicString* error_details) {
+ std::string* error_details) {
QuicStringPiece address;
if (!peer_hello.GetStringPiece(tag_, &address)) {
if (presence_ == PRESENCE_REQUIRED) {
@@ -690,7 +690,7 @@
QuicErrorCode QuicConfig::ProcessPeerHello(
const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- QuicString* error_details) {
+ std::string* error_details) {
DCHECK(error_details != nullptr);
QuicErrorCode error = QUIC_NO_ERROR;
@@ -779,7 +779,7 @@
QuicErrorCode QuicConfig::ProcessTransportParameters(
const TransportParameters& params,
HelloType hello_type,
- QuicString* error_details) {
+ std::string* error_details) {
QuicErrorCode error = idle_network_timeout_seconds_.ReceiveValue(
params.idle_timeout, hello_type, error_details);
if (error != QUIC_NO_ERROR) {
diff --git a/quic/core/quic_config.h b/quic/core/quic_config.h
index affc7b9..0037922 100644
--- a/quic/core/quic_config.h
+++ b/quic/core/quic_config.h
@@ -55,7 +55,7 @@
virtual QuicErrorCode ProcessPeerHello(
const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- QuicString* error_details) = 0;
+ std::string* error_details) = 0;
protected:
const QuicTag tag_;
@@ -106,7 +106,7 @@
// PRESENCE_OPTIONAL then |negotiated_value_| is set to |default_value_|.
QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- QuicString* error_details) override;
+ std::string* error_details) override;
// Takes a value |value| parsed from a handshake message (whether a TLS
// ClientHello/ServerHello or a CryptoHandshakeMessage) whose sender was
@@ -115,7 +115,7 @@
// an error, details are put in |*error_details|.
QuicErrorCode ReceiveValue(uint32_t value,
HelloType hello_type,
- QuicString* error_details);
+ std::string* error_details);
private:
uint32_t max_value_;
@@ -147,7 +147,7 @@
// Sets |value_| to the corresponding value from |peer_hello_| if it exists.
QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- QuicString* error_details) override;
+ std::string* error_details) override;
private:
uint32_t send_value_;
@@ -180,7 +180,7 @@
// Sets |value_| to the corresponding value from |peer_hello_| if it exists.
QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- QuicString* error_details) override;
+ std::string* error_details) override;
private:
QuicUint128 send_value_;
@@ -216,7 +216,7 @@
// it exists.
QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- QuicString* error_details) override;
+ std::string* error_details) override;
private:
QuicTagVector send_values_;
@@ -247,7 +247,7 @@
QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- QuicString* error_details) override;
+ std::string* error_details) override;
private:
QuicSocketAddress send_value_;
@@ -418,7 +418,7 @@
// the corresponding QuicErrorCode and sets detailed error in |error_details|.
QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- QuicString* error_details);
+ std::string* error_details);
// FillTransportParameters writes the values to send for ICSL, MIDS, CFCW, and
// SFCW to |*params|, returning true if the values could be written and false
@@ -431,7 +431,7 @@
// it returns a QuicErrorCode and puts a detailed error in |*error_details|.
QuicErrorCode ProcessTransportParameters(const TransportParameters& params,
HelloType hello_type,
- QuicString* error_details);
+ std::string* error_details);
private:
friend class test::QuicConfigPeer;
diff --git a/quic/core/quic_config_test.cc b/quic/core/quic_config_test.cc
index 59ad0ef..8b5aad2 100644
--- a/quic/core/quic_config_test.cc
+++ b/quic/core/quic_config_test.cc
@@ -67,7 +67,7 @@
CryptoHandshakeMessage msg;
client_config.ToHandshakeMessage(&msg);
- QuicString error_details;
+ std::string error_details;
QuicTagVector initial_received_options;
initial_received_options.push_back(kIW50);
EXPECT_TRUE(
@@ -115,7 +115,7 @@
server_config.SetStatelessResetTokenToSend(kTestResetToken);
CryptoHandshakeMessage msg;
server_config.ToHandshakeMessage(&msg);
- QuicString error_details;
+ std::string error_details;
const QuicErrorCode error =
config_.ProcessPeerHello(msg, SERVER, &error_details);
EXPECT_EQ(QUIC_NO_ERROR, error);
@@ -142,7 +142,7 @@
msg.SetValue(kMIDS, 1);
// No error, as rest are optional.
- QuicString error_details;
+ std::string error_details;
const QuicErrorCode error =
config_.ProcessPeerHello(msg, CLIENT, &error_details);
EXPECT_EQ(QUIC_NO_ERROR, error);
@@ -157,7 +157,7 @@
msg.SetValue(kMIDS, 1);
// No error, as rest are optional.
- QuicString error_details;
+ std::string error_details;
const QuicErrorCode error =
config_.ProcessPeerHello(msg, SERVER, &error_details);
EXPECT_EQ(QUIC_NO_ERROR, error);
@@ -167,7 +167,7 @@
TEST_F(QuicConfigTest, MissingValueInCHLO) {
// Server receives CHLO with missing kICSL.
CryptoHandshakeMessage msg;
- QuicString error_details;
+ std::string error_details;
const QuicErrorCode error =
config_.ProcessPeerHello(msg, CLIENT, &error_details);
EXPECT_EQ(QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND, error);
@@ -176,7 +176,7 @@
TEST_F(QuicConfigTest, MissingValueInSHLO) {
// Client receives SHLO with missing kICSL.
CryptoHandshakeMessage msg;
- QuicString error_details;
+ std::string error_details;
const QuicErrorCode error =
config_.ProcessPeerHello(msg, SERVER, &error_details);
EXPECT_EQ(QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND, error);
@@ -190,7 +190,7 @@
CryptoHandshakeMessage msg;
server_config.ToHandshakeMessage(&msg);
- QuicString error_details;
+ std::string error_details;
const QuicErrorCode error =
config_.ProcessPeerHello(msg, SERVER, &error_details);
EXPECT_EQ(QUIC_INVALID_NEGOTIATED_VALUE, error);
@@ -220,7 +220,7 @@
CryptoHandshakeMessage msg;
client_config.ToHandshakeMessage(&msg);
- QuicString error_details;
+ std::string error_details;
const QuicErrorCode error =
config_.ProcessPeerHello(msg, CLIENT, &error_details);
EXPECT_EQ(QUIC_NO_ERROR, error);
@@ -241,7 +241,7 @@
CryptoHandshakeMessage msg;
client_config.ToHandshakeMessage(&msg);
- QuicString error_details;
+ std::string error_details;
const QuicErrorCode error =
config_.ProcessPeerHello(msg, CLIENT, &error_details);
EXPECT_EQ(QUIC_NO_ERROR, error);
@@ -268,7 +268,7 @@
CryptoHandshakeMessage msg;
client_config.ToHandshakeMessage(&msg);
- QuicString error_details;
+ std::string error_details;
const QuicErrorCode error =
config_.ProcessPeerHello(msg, CLIENT, &error_details);
EXPECT_EQ(QUIC_NO_ERROR, error);
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 070191b..b39f617 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -564,7 +564,7 @@
if (debug_visitor_ != nullptr) {
debug_visitor_->OnPublicResetPacket(packet);
}
- QuicString error_details = "Received public reset.";
+ std::string error_details = "Received public reset.";
if (perspective_ == Perspective::IS_CLIENT && !packet.endpoint_id.empty()) {
QuicStrAppend(&error_details, " From ", packet.endpoint_id, ".");
}
@@ -580,7 +580,7 @@
QUIC_DLOG(INFO) << ENDPOINT << "Received packet with mismatched version "
<< ParsedQuicVersionToString(received_version);
if (perspective_ == Perspective::IS_CLIENT) {
- const QuicString error_details = "Protocol version mismatch.";
+ const std::string error_details = "Protocol version mismatch.";
QUIC_BUG << ENDPOINT << error_details;
TearDownLocalConnectionState(QUIC_INTERNAL_ERROR, error_details,
ConnectionCloseSource::FROM_SELF);
@@ -652,7 +652,7 @@
// here. (Check for a bug regression.)
DCHECK_EQ(connection_id_, packet.connection_id);
if (perspective_ == Perspective::IS_SERVER) {
- const QuicString error_details =
+ const std::string error_details =
"Server receieved version negotiation packet.";
QUIC_BUG << error_details;
QUIC_CODE_COUNT(quic_tear_down_local_connection_on_version_negotiation);
@@ -670,7 +670,7 @@
}
if (QuicContainsValue(packet.versions, version())) {
- const QuicString error_details =
+ const std::string error_details =
"Server already supports client's version and should have accepted the "
"connection.";
QUIC_DLOG(WARNING) << error_details;
@@ -748,7 +748,7 @@
if (!packet_generator_.IsPendingPacketEmpty()) {
// Incoming packets may change a queued ACK frame.
- const QuicString error_details =
+ const std::string error_details =
"Pending frames must be serialized before incoming packets are "
"processed.";
QUIC_BUG << error_details << ", received header: " << header;
@@ -780,7 +780,7 @@
if (!header.version_flag) {
// Packets should have the version flag till version negotiation is
// done.
- QuicString error_details =
+ std::string error_details =
QuicStrCat(ENDPOINT, "Packet ", header.packet_number.ToUint64(),
" without version flag before version negotiated.");
QUIC_DLOG(WARNING) << error_details;
@@ -1460,7 +1460,7 @@
const QuicIetfStatelessResetPacket& packet) {
// TODO(fayang): Add OnAuthenticatedIetfStatelessResetPacket to
// debug_visitor_.
- const QuicString error_details = "Received stateless reset.";
+ const std::string error_details = "Received stateless reset.";
QUIC_CODE_COUNT(quic_tear_down_local_connection_on_stateless_reset);
TearDownLocalConnectionState(QUIC_PUBLIC_RESET, error_details,
ConnectionCloseSource::FROM_PEER);
@@ -2491,7 +2491,7 @@
}
write_error_occurred_ = true;
- const QuicString error_details = QuicStrCat(
+ const std::string error_details = QuicStrCat(
"Write failed with error: ", error_code, " (", strerror(error_code), ")");
QUIC_LOG_FIRST_N(ERROR, 2) << ENDPOINT << error_details;
switch (error_code) {
@@ -2550,7 +2550,7 @@
}
void QuicConnection::OnUnrecoverableError(QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
ConnectionCloseSource source) {
// The packet creator or generator encountered an unrecoverable error: tear
// down local connection state immediately.
@@ -2842,7 +2842,7 @@
void QuicConnection::CloseConnection(
QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
ConnectionCloseBehavior connection_close_behavior) {
DCHECK(!error_details.empty());
if (!connected_) {
@@ -2873,7 +2873,7 @@
}
void QuicConnection::SendConnectionClosePacket(QuicErrorCode error,
- const QuicString& details,
+ const std::string& details,
AckBundling ack_mode) {
QUIC_DLOG(INFO) << ENDPOINT << "Sending connection close packet.";
if (fix_termination_packets_) {
@@ -2895,7 +2895,7 @@
void QuicConnection::TearDownLocalConnectionState(
QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
ConnectionCloseSource source) {
if (!connected_) {
QUIC_DLOG(INFO) << "Connection is already closed.";
@@ -2996,7 +2996,7 @@
<< " idle_network_timeout: "
<< idle_network_timeout_.ToMicroseconds();
if (idle_duration >= idle_network_timeout_) {
- const QuicString error_details = "No recent network activity.";
+ const std::string error_details = "No recent network activity.";
QUIC_DVLOG(1) << ENDPOINT << error_details;
if ((sent_packet_manager_.GetConsecutiveTlpCount() > 0 ||
sent_packet_manager_.GetConsecutiveRtoCount() > 0 ||
@@ -3017,7 +3017,7 @@
<< " handshake timeout: "
<< handshake_timeout_.ToMicroseconds();
if (connected_duration >= handshake_timeout_) {
- const QuicString error_details = "Handshake timeout expired.";
+ const std::string error_details = "Handshake timeout expired.";
QUIC_DVLOG(1) << ENDPOINT << error_details;
CloseConnection(QUIC_HANDSHAKE_TIMEOUT, error_details,
ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 985e44c..43aa1dd 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -126,7 +126,7 @@
// Called when the connection is closed either locally by the framer, or
// remotely by the peer.
virtual void OnConnectionClosed(QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
ConnectionCloseSource source) = 0;
// Called when the connection failed to write because the socket was blocked.
@@ -276,7 +276,7 @@
// Called when the connection is closed.
virtual void OnConnectionClosed(QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
ConnectionCloseSource source) {}
// Called when the version negotiation is successful.
@@ -407,7 +407,7 @@
// packet is sent to the peer.
virtual void CloseConnection(
QuicErrorCode error,
- const QuicString& details,
+ const std::string& details,
ConnectionCloseBehavior connection_close_behavior);
// Returns statistics tracked for this connection.
@@ -519,7 +519,7 @@
// QuicConnectionCloseDelegateInterface
void OnUnrecoverableError(QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
ConnectionCloseSource source) override;
// QuicPacketGenerator::DelegateInterface
@@ -917,7 +917,7 @@
// TODO(fayang): change |ack_mode| to bool |force_sending_ack| when
// deprecating quic_deprecate_ack_bundling_mode.
virtual void SendConnectionClosePacket(QuicErrorCode error,
- const QuicString& details,
+ const std::string& details,
AckBundling ack_mode);
// Returns true if the packet should be discarded and not sent.
@@ -952,7 +952,7 @@
// Notifies the visitor of the close and marks the connection as disconnected.
// Does not send a connection close frame to the peer.
void TearDownLocalConnectionState(QuicErrorCode error,
- const QuicString& details,
+ const std::string& details,
ConnectionCloseSource source);
// Writes the given packet to socket, encrypted with packet's
diff --git a/quic/core/quic_connection_close_delegate_interface.h b/quic/core/quic_connection_close_delegate_interface.h
index c9faab8..321d0e5 100644
--- a/quic/core/quic_connection_close_delegate_interface.h
+++ b/quic/core/quic_connection_close_delegate_interface.h
@@ -19,7 +19,7 @@
// Called when an unrecoverable error is encountered.
virtual void OnUnrecoverableError(QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
ConnectionCloseSource source) = 0;
};
diff --git a/quic/core/quic_connection_id.cc b/quic/core/quic_connection_id.cc
index 25c5b1f..07f3a67 100644
--- a/quic/core/quic_connection_id.cc
+++ b/quic/core/quic_connection_id.cc
@@ -64,9 +64,9 @@
data_bytes[0] ^ data_bytes[1] ^ data_bytes[2]);
}
-QuicString QuicConnectionId::ToString() const {
+std::string QuicConnectionId::ToString() const {
if (IsEmpty()) {
- return QuicString("0");
+ return std::string("0");
}
return QuicTextUtils::HexEncode(data_, length_);
}
diff --git a/quic/core/quic_connection_id.h b/quic/core/quic_connection_id.h
index 5a78acd..5a63088 100644
--- a/quic/core/quic_connection_id.h
+++ b/quic/core/quic_connection_id.h
@@ -61,7 +61,7 @@
// Generates an ASCII string that represents
// the contents of the connection ID, or "0" if it is empty.
- QuicString ToString() const;
+ std::string ToString() const;
// operator<< allows easily logging connection IDs.
friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 62056a0..f991355 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -4148,7 +4148,7 @@
// Send more than MTU worth of data. No acknowledgement was received so far,
// so the MTU should be at its old value.
- const QuicString data(kDefaultMaxPacketSize + 1, '.');
+ const std::string data(kDefaultMaxPacketSize + 1, '.');
QuicByteCount size_before_mtu_change;
EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
.Times(2)
@@ -4578,7 +4578,7 @@
// Create a handshake message that also enables silent close.
CryptoHandshakeMessage msg;
- QuicString error_details;
+ std::string error_details;
QuicConfig client_config;
client_config.SetInitialStreamFlowControlWindowToSend(
kInitialStreamFlowControlWindowForTest);
@@ -4645,7 +4645,7 @@
// Create a handshake message that also enables silent close.
CryptoHandshakeMessage msg;
- QuicString error_details;
+ std::string error_details;
QuicConfig client_config;
client_config.SetInitialStreamFlowControlWindowToSend(
kInitialStreamFlowControlWindowForTest);
@@ -4701,7 +4701,7 @@
// Create a handshake message that also enables silent close.
CryptoHandshakeMessage msg;
- QuicString error_details;
+ std::string error_details;
QuicConfig client_config;
client_config.SetInitialStreamFlowControlWindowToSend(
kInitialStreamFlowControlWindowForTest);
@@ -4941,7 +4941,7 @@
// Queue the first packet.
EXPECT_CALL(*send_algorithm_, CanSend(_)).WillOnce(testing::Return(false));
- const QuicString payload(payload_length, 'a');
+ const std::string payload(payload_length, 'a');
EXPECT_EQ(0u, connection_.SendStreamDataWithString(3, payload, 0, NO_FIN)
.bytes_consumed);
EXPECT_EQ(0u, connection_.NumQueuedPackets());
@@ -5000,7 +5000,7 @@
// scope of this test.
total_payload_length = total_payload_length + 2;
}
- const QuicString payload(total_payload_length, 'a');
+ const std::string payload(total_payload_length, 'a');
EXPECT_EQ(payload.size(),
connection_
@@ -5018,7 +5018,7 @@
QuicPacketCreatorPeer::SetSendVersionInPacket(creator_, false);
}
// Set up a larger payload than will fit in one packet.
- const QuicString payload(connection_.max_packet_length(), 'a');
+ const std::string payload(connection_.max_packet_length(), 'a');
EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)).Times(AnyNumber());
// Now send some packets with no truncation.
@@ -7286,7 +7286,7 @@
}
TEST_P(QuicConnectionTest, CloseConnectionForStatelessReject) {
- QuicString error_details("stateless reject");
+ std::string error_details("stateless reject");
EXPECT_CALL(visitor_, OnConnectionClosed(
QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT,
error_details, ConnectionCloseSource::FROM_PEER));
@@ -7624,7 +7624,7 @@
if (connection_.transport_version() <= QUIC_VERSION_44) {
return;
}
- QuicString message(connection_.GetLargestMessagePayload() * 2, 'a');
+ std::string message(connection_.GetLargestMessagePayload() * 2, 'a');
QuicStringPiece message_data(message);
QuicMemSliceStorage storage(nullptr, 0, nullptr, 0);
{
diff --git a/quic/core/quic_control_frame_manager.cc b/quic/core/quic_control_frame_manager.cc
index 8d4ba53..5fd756f 100644
--- a/quic/core/quic_control_frame_manager.cc
+++ b/quic/core/quic_control_frame_manager.cc
@@ -47,7 +47,7 @@
void QuicControlFrameManager::WriteOrBufferGoAway(
QuicErrorCode error,
QuicStreamId last_good_stream_id,
- const QuicString& reason) {
+ const std::string& reason) {
QUIC_DVLOG(1) << "Writing GOAWAY_FRAME";
WriteOrBufferQuicFrame(QuicFrame(new QuicGoAwayFrame(
++last_control_frame_id_, error, last_good_stream_id, reason)));
diff --git a/quic/core/quic_control_frame_manager.h b/quic/core/quic_control_frame_manager.h
index 618f3f9..355179a 100644
--- a/quic/core/quic_control_frame_manager.h
+++ b/quic/core/quic_control_frame_manager.h
@@ -43,7 +43,7 @@
// immediately.
void WriteOrBufferGoAway(QuicErrorCode error,
QuicStreamId last_good_stream_id,
- const QuicString& reason);
+ const std::string& reason);
// Tries to send a WINDOW_UPDATE_FRAME. Buffers the frame if it cannot be sent
// immediately.
diff --git a/quic/core/quic_crypto_client_handshaker.cc b/quic/core/quic_crypto_client_handshaker.cc
index 6647061..62b5bdb 100644
--- a/quic/core/quic_crypto_client_handshaker.cc
+++ b/quic/core/quic_crypto_client_handshaker.cc
@@ -52,7 +52,7 @@
void QuicCryptoClientHandshaker::ProofVerifierCallbackImpl::Run(
bool ok,
- const QuicString& error_details,
+ const std::string& error_details,
std::unique_ptr<ProofVerifyDetails>* details) {
if (parent_ == nullptr) {
return;
@@ -161,7 +161,7 @@
return channel_id_source_callback_run_;
}
-QuicString QuicCryptoClientHandshaker::chlo_hash() const {
+std::string QuicCryptoClientHandshaker::chlo_hash() const {
return chlo_hash_;
}
@@ -185,7 +185,7 @@
void QuicCryptoClientHandshaker::HandleServerConfigUpdateMessage(
const CryptoHandshakeMessage& server_config_update) {
DCHECK(server_config_update.tag() == kSCUP);
- QuicString error_details;
+ std::string error_details;
QuicCryptoClientConfig::CachedState* cached =
crypto_config_->LookupOrCreate(server_id_);
QuicErrorCode error = crypto_config_->ProcessServerConfigUpdate(
@@ -350,7 +350,7 @@
DCHECK(!crypto_negotiated_params_->server_nonce.empty());
}
- QuicString error_details;
+ std::string error_details;
QuicErrorCode error = crypto_config_->FillClientHello(
server_id_, session()->connection()->connection_id(),
session()->supported_versions().front(), cached,
@@ -433,7 +433,7 @@
session()->NeuterUnencryptedData();
stateless_reject_received_ = in->tag() == kSREJ;
- QuicString error_details;
+ std::string error_details;
QuicErrorCode error = crypto_config_->ProcessRejection(
*in, session()->connection()->clock()->WallNow(),
session()->connection()->transport_version(), chlo_hash_, cached,
@@ -613,7 +613,7 @@
return;
}
- QuicString error_details;
+ std::string error_details;
QuicErrorCode error = crypto_config_->ProcessServerHello(
*in, session()->connection()->connection_id(),
session()->connection()->version(),
diff --git a/quic/core/quic_crypto_client_handshaker.h b/quic/core/quic_crypto_client_handshaker.h
index 5836ea2..d335628 100644
--- a/quic/core/quic_crypto_client_handshaker.h
+++ b/quic/core/quic_crypto_client_handshaker.h
@@ -40,7 +40,7 @@
int num_scup_messages_received() const override;
bool WasChannelIDSent() const override;
bool WasChannelIDSourceCallbackRun() const override;
- QuicString chlo_hash() const override;
+ std::string chlo_hash() const override;
bool encryption_established() const override;
bool handshake_confirmed() const override;
const QuicCryptoNegotiatedParameters& crypto_negotiated_params()
@@ -87,7 +87,7 @@
// ProofVerifierCallback interface.
void Run(bool ok,
- const QuicString& error_details,
+ const std::string& error_details,
std::unique_ptr<ProofVerifyDetails>* details) override;
// Cancel causes any future callbacks to be ignored. It must be called on
@@ -174,7 +174,7 @@
QuicCryptoClientConfig* const crypto_config_;
// SHA-256 hash of the most recently sent CHLO.
- QuicString chlo_hash_;
+ std::string chlo_hash_;
// Server's (hostname, port, is_https, privacy_mode) tuple.
const QuicServerId server_id_;
@@ -213,7 +213,7 @@
// verification. These members must not be used after
// STATE_VERIFY_PROOF_COMPLETE.
bool verify_ok_;
- QuicString verify_error_details_;
+ std::string verify_error_details_;
std::unique_ptr<ProofVerifyDetails> verify_details_;
// True if the server responded to a previous CHLO with a stateless
diff --git a/quic/core/quic_crypto_client_handshaker_test.cc b/quic/core/quic_crypto_client_handshaker_test.cc
index e21faf3..329f3c3 100644
--- a/quic/core/quic_crypto_client_handshaker_test.cc
+++ b/quic/core/quic_crypto_client_handshaker_test.cc
@@ -31,26 +31,26 @@
// ProofVerifier override.
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>* verify_details,
std::unique_ptr<ProofVerifierCallback> callback) override {
return QUIC_SUCCESS;
}
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) override {
return QUIC_SUCCESS;
@@ -68,8 +68,8 @@
// ProofSource override.
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) override {
@@ -83,8 +83,8 @@
QuicReferenceCountedPointer<Chain> GetCertChain(
const QuicSocketAddress& server_address,
- const QuicString& hostname) override {
- std::vector<QuicString> certs;
+ const std::string& hostname) override {
+ std::vector<std::string> certs;
certs.push_back("Dummy cert");
return QuicReferenceCountedPointer<ProofSource::Chain>(
new ProofSource::Chain(certs));
@@ -92,7 +92,7 @@
void ComputeTlsSignature(
const QuicSocketAddress& server_address,
- const QuicString& hostname,
+ const std::string& hostname,
uint16_t signature_algorithm,
QuicStringPiece in,
std::unique_ptr<SignatureCallback> callback) override {
@@ -157,7 +157,7 @@
QuicCryptoServerConfig::GenerateConfig(helper_.GetRandomGenerator(),
helper_.GetClock(), options);
state_.Initialize(
- config->config(), "sourcetoken", std::vector<QuicString>{"Dummy cert"},
+ config->config(), "sourcetoken", std::vector<std::string>{"Dummy cert"},
"", "chlo_hash", "signature", helper_.GetClock()->WallNow(),
helper_.GetClock()->WallNow().Add(QuicTime::Delta::FromSeconds(30)));
diff --git a/quic/core/quic_crypto_client_stream.cc b/quic/core/quic_crypto_client_stream.cc
index 66bb9e4..52edbc0 100644
--- a/quic/core/quic_crypto_client_stream.cc
+++ b/quic/core/quic_crypto_client_stream.cc
@@ -92,7 +92,7 @@
return handshaker_->WasChannelIDSourceCallbackRun();
}
-QuicString QuicCryptoClientStream::chlo_hash() const {
+std::string QuicCryptoClientStream::chlo_hash() const {
return handshaker_->chlo_hash();
}
diff --git a/quic/core/quic_crypto_client_stream.h b/quic/core/quic_crypto_client_stream.h
index da149fe..ad6518b 100644
--- a/quic/core/quic_crypto_client_stream.h
+++ b/quic/core/quic_crypto_client_stream.h
@@ -90,7 +90,7 @@
// ChannelIDSource operated asynchronously. Intended for testing.
virtual bool WasChannelIDSourceCallbackRun() const = 0;
- virtual QuicString chlo_hash() const = 0;
+ virtual std::string chlo_hash() const = 0;
// Returns true once any encrypter (initial/0RTT or final/1RTT) has been set
// for the connection.
@@ -156,7 +156,7 @@
// ChannelIDSource operated asynchronously. Intended for testing.
bool WasChannelIDSourceCallbackRun() const;
- QuicString chlo_hash() const;
+ std::string chlo_hash() const;
protected:
void set_handshaker(std::unique_ptr<HandshakerDelegate> handshaker) {
diff --git a/quic/core/quic_crypto_client_stream_test.cc b/quic/core/quic_crypto_client_stream_test.cc
index d9b344a..bd5162b 100644
--- a/quic/core/quic_crypto_client_stream_test.cc
+++ b/quic/core/quic_crypto_client_stream_test.cc
@@ -188,10 +188,10 @@
QuicCryptoClientConfig::CachedState* state =
crypto_config_.LookupOrCreate(server_id_);
- std::vector<QuicString> certs = state->certs();
- QuicString cert_sct = state->cert_sct();
- QuicString signature = state->signature();
- QuicString chlo_hash = state->chlo_hash();
+ std::vector<std::string> certs = state->certs();
+ std::string cert_sct = state->cert_sct();
+ std::string signature = state->signature();
+ std::string chlo_hash = state->chlo_hash();
state->SetProof(certs, cert_sct, chlo_hash, signature + signature);
EXPECT_CALL(*session_, OnProofVerifyDetailsAvailable(testing::_))
@@ -243,7 +243,7 @@
// Make sure that the STK and SCFG are cached correctly.
EXPECT_EQ("xstk", state->source_address_token());
- const QuicString& cached_scfg = state->server_config();
+ const std::string& cached_scfg = state->server_config();
test::CompareCharArraysWithHexError(
"scfg", cached_scfg.data(), cached_scfg.length(),
reinterpret_cast<char*>(scfg), QUIC_ARRAYSIZE(scfg));
diff --git a/quic/core/quic_crypto_server_handshaker.cc b/quic/core/quic_crypto_server_handshaker.cc
index 66f3e12..fb24fed 100644
--- a/quic/core/quic_crypto_server_handshaker.cc
+++ b/quic/core/quic_crypto_server_handshaker.cc
@@ -24,7 +24,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 {
@@ -160,7 +160,7 @@
FinishProcessingHandshakeMessageAfterProcessClientHello(
const ValidateClientHelloResultCallback::Result& result,
QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
std::unique_ptr<CryptoHandshakeMessage> reply,
std::unique_ptr<DiversificationNonce> diversification_nonce,
std::unique_ptr<ProofSource::Details> proof_source_details) {
@@ -207,7 +207,7 @@
// session config.
QuicConfig* config = session()->config();
OverrideQuicConfigDefaults(config);
- QuicString process_error_details;
+ std::string process_error_details;
const QuicErrorCode process_error =
config->ProcessPeerHello(message, CLIENT, &process_error_details);
if (process_error != QUIC_NO_ERROR) {
@@ -354,13 +354,13 @@
}
bool QuicCryptoServerHandshaker::GetBase64SHA256ClientChannelID(
- QuicString* output) const {
+ std::string* output) const {
if (!encryption_established() ||
crypto_negotiated_params_->channel_id.empty()) {
return false;
}
- const QuicString& channel_id(crypto_negotiated_params_->channel_id);
+ const std::string& channel_id(crypto_negotiated_params_->channel_id);
uint8_t digest[SHA256_DIGEST_LENGTH];
SHA256(reinterpret_cast<const uint8_t*>(channel_id.data()), channel_id.size(),
digest);
@@ -392,7 +392,7 @@
std::unique_ptr<ProofSource::Details> proof_source_details,
std::unique_ptr<ProcessClientHelloResultCallback> done_cb) {
const CryptoHandshakeMessage& message = result->client_hello;
- QuicString error_details;
+ std::string error_details;
if (!helper_->CanAcceptClientHello(
message, GetClientAddress(), session()->connection()->peer_address(),
session()->connection()->self_address(), &error_details)) {
diff --git a/quic/core/quic_crypto_server_handshaker.h b/quic/core/quic_crypto_server_handshaker.h
index a1ec99f..544307c 100644
--- a/quic/core/quic_crypto_server_handshaker.h
+++ b/quic/core/quic_crypto_server_handshaker.h
@@ -39,7 +39,7 @@
// From HandshakerDelegate
void CancelOutstandingCallbacks() override;
- bool GetBase64SHA256ClientChannelID(QuicString* output) const override;
+ bool GetBase64SHA256ClientChannelID(std::string* output) const override;
void SendServerConfigUpdate(
const CachedNetworkParameters* cached_network_params) override;
uint8_t NumHandshakeMessages() const override;
@@ -139,7 +139,7 @@
void FinishProcessingHandshakeMessageAfterProcessClientHello(
const ValidateClientHelloResultCallback::Result& result,
QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
std::unique_ptr<CryptoHandshakeMessage> reply,
std::unique_ptr<DiversificationNonce> diversification_nonce,
std::unique_ptr<ProofSource::Details> proof_source_details);
@@ -177,7 +177,7 @@
// Hash of the last received CHLO message which can be used for generating
// server config update messages.
- QuicString chlo_hash_;
+ std::string chlo_hash_;
// Pointer to the helper for this crypto stream. Must outlive this stream.
QuicCryptoServerStream::Helper* helper_;
diff --git a/quic/core/quic_crypto_server_stream.cc b/quic/core/quic_crypto_server_stream.cc
index aa75c66..02e7b8f 100644
--- a/quic/core/quic_crypto_server_stream.cc
+++ b/quic/core/quic_crypto_server_stream.cc
@@ -71,7 +71,7 @@
}
bool QuicCryptoServerStream::GetBase64SHA256ClientChannelID(
- QuicString* output) const {
+ std::string* output) const {
return handshaker()->GetBase64SHA256ClientChannelID(output);
}
diff --git a/quic/core/quic_crypto_server_stream.h b/quic/core/quic_crypto_server_stream.h
index 53d4b38..ec339e1 100644
--- a/quic/core/quic_crypto_server_stream.h
+++ b/quic/core/quic_crypto_server_stream.h
@@ -41,7 +41,7 @@
// GetBase64SHA256ClientChannelID sets |*output| to the base64 encoded,
// SHA-256 hash of the client's ChannelID key and returns true, if the client
// presented a ChannelID. Otherwise it returns false.
- virtual bool GetBase64SHA256ClientChannelID(QuicString* output) const = 0;
+ virtual bool GetBase64SHA256ClientChannelID(std::string* output) const = 0;
virtual int NumServerConfigUpdateMessagesSent() const = 0;
@@ -92,7 +92,7 @@
// GetBase64SHA256ClientChannelID sets |*output| to the base64 encoded,
// SHA-256 hash of the client's ChannelID key and returns true, if the
// client presented a ChannelID. Otherwise it returns false.
- virtual bool GetBase64SHA256ClientChannelID(QuicString* output) const = 0;
+ virtual bool GetBase64SHA256ClientChannelID(std::string* output) const = 0;
// Sends the latest server config and source-address token to the client.
virtual void SendServerConfigUpdate(
@@ -147,7 +147,7 @@
const QuicSocketAddress& client_address,
const QuicSocketAddress& peer_address,
const QuicSocketAddress& self_address,
- QuicString* error_details) const = 0;
+ std::string* error_details) const = 0;
};
// |crypto_config| must outlive the stream.
@@ -165,7 +165,7 @@
// From QuicCryptoServerStreamBase
void CancelOutstandingCallbacks() override;
- bool GetBase64SHA256ClientChannelID(QuicString* output) const override;
+ bool GetBase64SHA256ClientChannelID(std::string* output) const override;
void SendServerConfigUpdate(
const CachedNetworkParameters* cached_network_params) override;
uint8_t NumHandshakeMessages() const override;
diff --git a/quic/core/quic_crypto_stream.cc b/quic/core/quic_crypto_stream.cc
index aef431d..6a941e7 100644
--- a/quic/core/quic_crypto_stream.cc
+++ b/quic/core/quic_crypto_stream.cc
@@ -107,7 +107,7 @@
bool QuicCryptoStream::ExportKeyingMaterial(QuicStringPiece label,
QuicStringPiece context,
size_t result_len,
- QuicString* result) const {
+ std::string* result) const {
if (!handshake_confirmed()) {
QUIC_DLOG(ERROR) << "ExportKeyingMaterial was called before forward-secure"
<< "encryption was established.";
diff --git a/quic/core/quic_crypto_stream.h b/quic/core/quic_crypto_stream.h
index d2a729e..e60277b 100644
--- a/quic/core/quic_crypto_stream.h
+++ b/quic/core/quic_crypto_stream.h
@@ -63,7 +63,7 @@
bool ExportKeyingMaterial(QuicStringPiece label,
QuicStringPiece context,
size_t result_len,
- QuicString* result) const;
+ std::string* result) const;
// Writes |data| to the QuicStream at level |level|.
virtual void WriteCryptoData(EncryptionLevel level, QuicStringPiece data);
diff --git a/quic/core/quic_crypto_stream_test.cc b/quic/core/quic_crypto_stream_test.cc
index 26ed335..263910b 100644
--- a/quic/core/quic_crypto_stream_test.cc
+++ b/quic/core/quic_crypto_stream_test.cc
@@ -118,7 +118,7 @@
}
TEST_F(QuicCryptoStreamTest, ProcessBadData) {
- QuicString bad(message_data_->data(), message_data_->length());
+ std::string bad(message_data_->data(), message_data_->length());
const int kFirstTagIndex = sizeof(uint32_t) + // message tag
sizeof(uint16_t) + // number of tag-value pairs
sizeof(uint16_t); // padding
@@ -148,7 +148,7 @@
InSequence s;
// Send [0, 1350) in ENCRYPTION_NONE.
EXPECT_EQ(ENCRYPTION_NONE, connection_->encryption_level());
- QuicString data(1350, 'a');
+ std::string data(1350, 'a');
EXPECT_CALL(
session_,
WritevData(_,
@@ -208,7 +208,7 @@
InSequence s;
// Send [0, 1350) in ENCRYPTION_NONE.
EXPECT_EQ(ENCRYPTION_NONE, connection_->encryption_level());
- QuicString data(1350, 'a');
+ std::string data(1350, 'a');
EXPECT_CALL(*connection_, SendCryptoData(ENCRYPTION_NONE, 1350, 0))
.WillOnce(Invoke(connection_,
&MockQuicConnection::QuicConnection_SendCryptoData));
@@ -258,7 +258,7 @@
}
// Send [0, 1350) in ENCRYPTION_NONE.
EXPECT_EQ(ENCRYPTION_NONE, connection_->encryption_level());
- QuicString data(1350, 'a');
+ std::string data(1350, 'a');
EXPECT_CALL(
session_,
WritevData(_,
@@ -300,7 +300,7 @@
}
// Send [0, 1350) in ENCRYPTION_NONE.
EXPECT_EQ(ENCRYPTION_NONE, connection_->encryption_level());
- QuicString data(1350, 'a');
+ std::string data(1350, 'a');
EXPECT_CALL(*connection_, SendCryptoData(ENCRYPTION_NONE, 1350, 0))
.WillOnce(Invoke(connection_,
&MockQuicConnection::QuicConnection_SendCryptoData));
@@ -344,7 +344,7 @@
InSequence s;
// Send [0, 1350) in ENCRYPTION_NONE.
EXPECT_EQ(ENCRYPTION_NONE, connection_->encryption_level());
- QuicString data(1350, 'a');
+ std::string data(1350, 'a');
EXPECT_CALL(
session_,
WritevData(_,
@@ -417,7 +417,7 @@
InSequence s;
// Send [0, 1350) in ENCRYPTION_NONE.
EXPECT_EQ(ENCRYPTION_NONE, connection_->encryption_level());
- QuicString data(1350, 'a');
+ std::string data(1350, 'a');
EXPECT_CALL(*connection_, SendCryptoData(ENCRYPTION_NONE, 1350, 0))
.WillOnce(Invoke(connection_,
&MockQuicConnection::QuicConnection_SendCryptoData));
@@ -473,7 +473,7 @@
if (connection_->transport_version() >= QUIC_VERSION_47) {
return;
}
- QuicString data(1350, 'a');
+ std::string data(1350, 'a');
EXPECT_CALL(
session_,
WritevData(_,
@@ -504,7 +504,7 @@
}
// Send [0, 1350) in ENCRYPTION_NONE.
EXPECT_EQ(ENCRYPTION_NONE, connection_->encryption_level());
- QuicString data(1350, 'a');
+ std::string data(1350, 'a');
EXPECT_CALL(*connection_, SendCryptoData(ENCRYPTION_NONE, 1350, 0))
.WillOnce(Invoke(connection_,
&MockQuicConnection::QuicConnection_SendCryptoData));
diff --git a/quic/core/quic_data_reader.cc b/quic/core/quic_data_reader.cc
index e1fbffe..4200329 100644
--- a/quic/core/quic_data_reader.cc
+++ b/quic/core/quic_data_reader.cc
@@ -305,7 +305,7 @@
return true;
}
-QuicString QuicDataReader::DebugString() const {
+std::string QuicDataReader::DebugString() const {
return QuicStrCat(" { length: ", len_, ", position: ", pos_, " }");
}
diff --git a/quic/core/quic_data_reader.h b/quic/core/quic_data_reader.h
index fff0ffd..6295882 100644
--- a/quic/core/quic_data_reader.h
+++ b/quic/core/quic_data_reader.h
@@ -149,7 +149,7 @@
// greater than (2^32)-1.
bool ReadVarIntStreamId(QuicStreamId* result);
- QuicString DebugString() const;
+ std::string DebugString() const;
private:
// Returns true if the underlying buffer has enough room to read the given
diff --git a/quic/core/quic_data_writer.cc b/quic/core/quic_data_writer.cc
index c70bbdd..98a173d 100644
--- a/quic/core/quic_data_writer.cc
+++ b/quic/core/quic_data_writer.cc
@@ -349,7 +349,7 @@
return true;
}
-QuicString QuicDataWriter::DebugString() const {
+std::string QuicDataWriter::DebugString() const {
return QuicStrCat(" { capacity: ", capacity_, ", length: ", length_, " }");
}
diff --git a/quic/core/quic_data_writer.h b/quic/core/quic_data_writer.h
index e107fcb..4e6b179 100644
--- a/quic/core/quic_data_writer.h
+++ b/quic/core/quic_data_writer.h
@@ -122,7 +122,7 @@
size_t remaining() const { return capacity_ - length_; }
- QuicString DebugString() const;
+ std::string DebugString() const;
private:
// Returns the location that the data should be written at, or nullptr if
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index 14da558..ce95320 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -72,7 +72,7 @@
}
void OnUnrecoverableError(QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
ConnectionCloseSource source) override {}
void SaveStatelessRejectFrameData(QuicStringPiece reject) {
@@ -135,7 +135,7 @@
// Generates a packet containing a CONNECTION_CLOSE frame specifying
// |error_code| and |error_details| and add the connection to time wait.
void CloseConnection(QuicErrorCode error_code,
- const QuicString& error_details,
+ const std::string& error_details,
bool ietf_quic) {
QuicConnectionCloseFrame* frame = new QuicConnectionCloseFrame;
frame->error_code = error_code;
@@ -211,14 +211,14 @@
const CryptoHandshakeMessage& chlo) override {
QuicStringPiece alpn_value;
if (chlo.GetStringPiece(kALPN, &alpn_value)) {
- alpn_ = QuicString(alpn_value);
+ alpn_ = std::string(alpn_value);
}
}
- QuicString&& ConsumeAlpn() { return std::move(alpn_); }
+ std::string&& ConsumeAlpn() { return std::move(alpn_); }
private:
- QuicString alpn_;
+ std::string alpn_;
};
// Class which sits between the ChloExtractor and the StatelessRejector
@@ -255,7 +255,7 @@
bool can_accept() const { return can_accept_; }
- const QuicString& error_details() const { return error_details_; }
+ const std::string& error_details() const { return error_details_; }
private:
QuicCryptoServerStream::Helper* helper_; // Unowned.
@@ -266,7 +266,7 @@
QuicSocketAddress self_address_;
StatelessRejector* rejector_; // Unowned.
bool can_accept_;
- QuicString error_details_;
+ std::string error_details_;
};
} // namespace
@@ -653,7 +653,7 @@
void QuicDispatcher::OnConnectionClosed(QuicConnectionId connection_id,
QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
ConnectionCloseSource source) {
auto it = session_map_.find(connection_id);
if (it == session_map_.end()) {
@@ -714,7 +714,7 @@
PacketHeaderFormat format,
ParsedQuicVersion version,
QuicErrorCode error_code,
- const QuicString& error_details,
+ const std::string& error_details,
QuicTimeWaitListManager::TimeWaitAction action) {
if (format != IETF_QUIC_LONG_HEADER_PACKET) {
QUIC_DVLOG(1) << "Statelessly terminating " << connection_id
diff --git a/quic/core/quic_dispatcher.h b/quic/core/quic_dispatcher.h
index 85e6da6..77d4952 100644
--- a/quic/core/quic_dispatcher.h
+++ b/quic/core/quic_dispatcher.h
@@ -79,7 +79,7 @@
// Ensure that the closed connection is cleaned up asynchronously.
void OnConnectionClosed(QuicConnectionId connection_id,
QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
ConnectionCloseSource source) override;
// QuicSession::Visitor interface implementation (via inheritance of
@@ -338,7 +338,7 @@
PacketHeaderFormat format,
ParsedQuicVersion version,
QuicErrorCode error_code,
- const QuicString& error_details,
+ const std::string& error_details,
QuicTimeWaitListManager::TimeWaitAction action);
// Save/Restore per packet context. Used by async stateless rejector.
@@ -453,7 +453,7 @@
QuicSocketAddress current_self_address_;
const QuicReceivedPacket* current_packet_;
// If |current_packet_| is a CHLO packet, the extracted alpn.
- QuicString current_alpn_;
+ std::string current_alpn_;
QuicConnectionId current_connection_id_;
// Used to get the supported versions based on flag. Does not own.
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index e4a42a4..c744505 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -77,7 +77,7 @@
MOCK_METHOD3(OnConnectionClosed,
void(QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
ConnectionCloseSource source));
MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id));
MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(PendingStream pending));
@@ -138,7 +138,7 @@
bool(QuicConnectionId connection_id, bool ietf_quic));
struct TestQuicPerPacketContext : public QuicPerPacketContext {
- QuicString custom_packet_context;
+ std::string custom_packet_context;
};
std::unique_ptr<QuicPerPacketContext> GetPerPacketContext() const override {
@@ -154,7 +154,7 @@
custom_packet_context_ = test_context->custom_packet_context;
}
- QuicString custom_packet_context_;
+ std::string custom_packet_context_;
using QuicDispatcher::current_client_address;
using QuicDispatcher::current_peer_address;
@@ -246,7 +246,7 @@
void ProcessPacket(QuicSocketAddress peer_address,
QuicConnectionId connection_id,
bool has_version_flag,
- const QuicString& data) {
+ const std::string& data) {
ProcessPacket(peer_address, connection_id, has_version_flag, data,
CONNECTION_ID_PRESENT, PACKET_4BYTE_PACKET_NUMBER);
}
@@ -256,7 +256,7 @@
void ProcessPacket(QuicSocketAddress peer_address,
QuicConnectionId connection_id,
bool has_version_flag,
- const QuicString& data,
+ const std::string& data,
QuicConnectionIdIncluded connection_id_included,
QuicPacketNumberLength packet_number_length) {
ProcessPacket(peer_address, connection_id, has_version_flag, data,
@@ -267,7 +267,7 @@
void ProcessPacket(QuicSocketAddress peer_address,
QuicConnectionId connection_id,
bool has_version_flag,
- const QuicString& data,
+ const std::string& data,
QuicConnectionIdIncluded connection_id_included,
QuicPacketNumberLength packet_number_length,
uint64_t packet_number) {
@@ -281,7 +281,7 @@
QuicConnectionId connection_id,
bool has_version_flag,
ParsedQuicVersion version,
- const QuicString& data,
+ const std::string& data,
QuicConnectionIdIncluded connection_id_included,
QuicPacketNumberLength packet_number_length,
uint64_t packet_number) {
@@ -298,11 +298,11 @@
// Add CHLO packet to the beginning to be verified first, because it is
// also processed first by new session.
data_connection_map_[connection_id].push_front(
- QuicString(packet->data(), packet->length()));
+ std::string(packet->data(), packet->length()));
} else {
// For non-CHLO, always append to last.
data_connection_map_[connection_id].push_back(
- QuicString(packet->data(), packet->length()));
+ std::string(packet->data(), packet->length()));
}
dispatcher_->ProcessPacket(server_address_, peer_address, *received_packet);
}
@@ -347,14 +347,14 @@
time_wait_list_manager_);
}
- QuicString SerializeCHLO() {
+ std::string SerializeCHLO() {
CryptoHandshakeMessage client_hello;
client_hello.set_tag(kCHLO);
client_hello.SetStringPiece(kALPN, "hq");
- return QuicString(client_hello.GetSerialized().AsStringPiece());
+ return std::string(client_hello.GetSerialized().AsStringPiece());
}
- QuicString SerializeTlsClientHello() { return ""; }
+ std::string SerializeTlsClientHello() { return ""; }
void MarkSession1Deleted() { session1_ = nullptr; }
@@ -368,7 +368,7 @@
MockTimeWaitListManager* time_wait_list_manager_;
TestQuicSpdyServerSession* session1_;
TestQuicSpdyServerSession* session2_;
- std::map<QuicConnectionId, std::list<QuicString>> data_connection_map_;
+ std::map<QuicConnectionId, std::list<std::string>> data_connection_map_;
QuicBufferedPacketStore* store_;
};
@@ -499,7 +499,7 @@
ParsedQuicVersion parsed_version(PROTOCOL_QUIC_CRYPTO, version);
// Pad the CHLO message with enough data to make the packet large enough
// to trigger version negotiation.
- QuicString chlo = SerializeCHLO() + QuicString(1200, 'a');
+ std::string chlo = SerializeCHLO() + std::string(1200, 'a');
DCHECK_LE(1200u, chlo.length());
ProcessPacket(client_address, TestConnectionId(1), true, parsed_version, chlo,
CONNECTION_ID_PRESENT, PACKET_4BYTE_PACKET_NUMBER, 1);
@@ -516,11 +516,11 @@
QuicTransportVersion version =
static_cast<QuicTransportVersion>(QuicTransportVersionMin() - 1);
ParsedQuicVersion parsed_version(PROTOCOL_QUIC_CRYPTO, version);
- QuicString chlo = SerializeCHLO() + QuicString(1200, 'a');
+ std::string chlo = SerializeCHLO() + std::string(1200, 'a');
// Truncate to 1100 bytes of payload which results in a packet just
// under 1200 bytes after framing, packet, and encryption overhead.
DCHECK_LE(1200u, chlo.length());
- QuicString truncated_chlo = chlo.substr(0, 1100);
+ std::string truncated_chlo = chlo.substr(0, 1100);
DCHECK_EQ(1100u, truncated_chlo.length());
ProcessPacket(client_address, TestConnectionId(1), true, parsed_version,
truncated_chlo, CONNECTION_ID_PRESENT,
@@ -542,11 +542,11 @@
QuicTransportVersion version =
static_cast<QuicTransportVersion>(QuicTransportVersionMin() - 1);
ParsedQuicVersion parsed_version(PROTOCOL_QUIC_CRYPTO, version);
- QuicString chlo = SerializeCHLO() + QuicString(1200, 'a');
+ std::string chlo = SerializeCHLO() + std::string(1200, 'a');
// Truncate to 1100 bytes of payload which results in a packet just
// under 1200 bytes after framing, packet, and encryption overhead.
DCHECK_LE(1200u, chlo.length());
- QuicString truncated_chlo = chlo.substr(0, 1100);
+ std::string truncated_chlo = chlo.substr(0, 1100);
DCHECK_EQ(1100u, truncated_chlo.length());
ProcessPacket(client_address, TestConnectionId(1), true, parsed_version,
truncated_chlo, CONNECTION_ID_PRESENT,
@@ -1167,7 +1167,7 @@
.Times(1);
}
ProcessPacket(client_address, connection_id, true,
- QuicString(client_hello.GetSerialized().AsStringPiece()));
+ std::string(client_hello.GetSerialized().AsStringPiece()));
if (GetParam().enable_stateless_rejects_via_flag) {
EXPECT_EQ(true,
@@ -1218,7 +1218,7 @@
})))
.RetiresOnSaturation();
ProcessPacket(client_address, connection_id, true,
- QuicString(client_hello.GetSerialized().AsStringPiece()));
+ std::string(client_hello.GetSerialized().AsStringPiece()));
EXPECT_FALSE(
time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
}
@@ -1624,8 +1624,8 @@
&full_chlo_);
}
- QuicString SerializeFullCHLO() {
- return QuicString(full_chlo_.GetSerialized().AsStringPiece());
+ std::string SerializeFullCHLO() {
+ return std::string(full_chlo_.GetSerialized().AsStringPiece());
}
protected:
@@ -2130,16 +2130,16 @@
return static_cast<FakeProofSource*>(crypto_config_peer_.GetProofSource());
}
- QuicString SerializeFullCHLO() {
- return QuicString(full_chlo_.GetSerialized().AsStringPiece());
+ std::string SerializeFullCHLO() {
+ return std::string(full_chlo_.GetSerialized().AsStringPiece());
}
- QuicString SerializeFullCHLOForClient2() {
- return QuicString(full_chlo_2_.GetSerialized().AsStringPiece());
+ std::string SerializeFullCHLOForClient2() {
+ return std::string(full_chlo_2_.GetSerialized().AsStringPiece());
}
- QuicString SerializeCHLO() {
- return QuicString(chlo_.GetSerialized().AsStringPiece());
+ std::string SerializeCHLO() {
+ return std::string(chlo_.GetSerialized().AsStringPiece());
}
// Sets up a session, and crypto stream based on the test parameters.
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 2ffb762..22d0ecf 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -1368,7 +1368,7 @@
IpAddressFamily::IP_UNSPEC) {
// packet.client_address is non-empty.
QuicSocketAddressCoder address_coder(packet.client_address);
- QuicString serialized_address = address_coder.Encode();
+ std::string serialized_address = address_coder.Encode();
if (serialized_address.empty()) {
return nullptr;
}
@@ -1994,7 +1994,7 @@
QuicStringPiece endpoint_id;
if (perspective_ == Perspective::IS_CLIENT &&
reset->GetStringPiece(kEPID, &endpoint_id)) {
- packet.endpoint_id = QuicString(endpoint_id);
+ packet.endpoint_id = std::string(endpoint_id);
packet.endpoint_id += '\0';
}
@@ -3724,7 +3724,7 @@
set_detailed_error("Unable to read connection close error details.");
return false;
}
- frame->error_details = QuicString(error_details);
+ frame->error_details = std::string(error_details);
return true;
}
@@ -3755,7 +3755,7 @@
set_detailed_error("Unable to read goaway reason.");
return false;
}
- frame->reason_phrase = QuicString(reason_phrase);
+ frame->reason_phrase = std::string(reason_phrase);
return true;
}
@@ -4511,7 +4511,7 @@
set_detailed_error("Unable to read new token data.");
return false;
}
- frame->token = QuicString(data);
+ frame->token = std::string(data);
return true;
}
@@ -5225,7 +5225,7 @@
set_detailed_error("Unable to read connection close error details.");
return false;
}
- frame->error_details = QuicString(phrase);
+ frame->error_details = std::string(phrase);
return true;
}
@@ -5250,7 +5250,7 @@
set_detailed_error("Unable to read application close error details.");
return false;
}
- frame->error_details = QuicString(phrase);
+ frame->error_details = std::string(phrase);
return true;
}
diff --git a/quic/core/quic_framer.h b/quic/core/quic_framer.h
index 168fef5..d6916f6 100644
--- a/quic/core/quic_framer.h
+++ b/quic/core/quic_framer.h
@@ -516,7 +516,7 @@
// to ciphertext no larger than |ciphertext_size|.
size_t GetMaxPlaintextSize(size_t ciphertext_size);
- const QuicString& detailed_error() { return detailed_error_; }
+ const std::string& detailed_error() { return detailed_error_; }
// The minimum packet number length required to represent |packet_number|.
static QuicPacketNumberLength GetMinPacketNumberLength(
@@ -859,7 +859,7 @@
void set_detailed_error(const char* error) { detailed_error_ = error; }
- QuicString detailed_error_;
+ std::string detailed_error_;
QuicFramerVisitorInterface* visitor_;
QuicErrorCode error_;
// Updated by ProcessPacketHeader when it succeeds decrypting a larger packet.
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index bcd9db6..527307a 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -92,8 +92,8 @@
size_t* output_length,
size_t max_output_length) override {
packet_number_ = QuicPacketNumber(packet_number);
- associated_data_ = QuicString(associated_data);
- plaintext_ = QuicString(plaintext);
+ associated_data_ = std::string(associated_data);
+ plaintext_ = std::string(plaintext);
memcpy(output, plaintext.data(), plaintext.length());
*output_length = plaintext.length();
return true;
@@ -111,8 +111,8 @@
QuicStringPiece GetNoncePrefix() const override { return QuicStringPiece(); }
QuicPacketNumber packet_number_;
- QuicString associated_data_;
- QuicString plaintext_;
+ std::string associated_data_;
+ std::string plaintext_;
};
class TestDecrypter : public QuicDecrypter {
@@ -135,8 +135,8 @@
size_t* output_length,
size_t max_output_length) override {
packet_number_ = QuicPacketNumber(packet_number);
- associated_data_ = QuicString(associated_data);
- ciphertext_ = QuicString(ciphertext);
+ associated_data_ = std::string(associated_data);
+ ciphertext_ = std::string(ciphertext);
memcpy(output, ciphertext.data(), ciphertext.length());
*output_length = ciphertext.length();
return true;
@@ -148,8 +148,8 @@
// Use a distinct value starting with 0xFFFFFF, which is never used by TLS.
uint32_t cipher_id() const override { return 0xFFFFFFF2; }
QuicPacketNumber packet_number_;
- QuicString associated_data_;
- QuicString ciphertext_;
+ std::string associated_data_;
+ std::string ciphertext_;
};
class TestQuicVisitor : public QuicFramerVisitorInterface {
@@ -220,8 +220,8 @@
bool OnStreamFrame(const QuicStreamFrame& frame) override {
++frame_count_;
// Save a copy of the data so it is valid after the packet is processed.
- QuicString* string_data =
- new QuicString(frame.data_buffer, frame.data_length);
+ std::string* string_data =
+ new std::string(frame.data_buffer, frame.data_length);
stream_data_.push_back(QuicWrapUnique(string_data));
stream_frames_.push_back(QuicMakeUnique<QuicStreamFrame>(
frame.stream_id, frame.fin, frame.offset, *string_data));
@@ -231,8 +231,8 @@
bool OnCryptoFrame(const QuicCryptoFrame& frame) override {
++frame_count_;
// Save a copy of the data so it is valid after the packet is processed.
- QuicString* string_data =
- new QuicString(frame.data_buffer, frame.data_length);
+ std::string* string_data =
+ new std::string(frame.data_buffer, frame.data_length);
crypto_data_.push_back(QuicWrapUnique(string_data));
crypto_frames_.push_back(QuicMakeUnique<QuicCryptoFrame>(
ENCRYPTION_NONE, frame.offset, *string_data));
@@ -407,14 +407,14 @@
QuicNewConnectionIdFrame new_connection_id_;
QuicRetireConnectionIdFrame retire_connection_id_;
QuicNewTokenFrame new_token_;
- std::vector<std::unique_ptr<QuicString>> stream_data_;
- std::vector<std::unique_ptr<QuicString>> crypto_data_;
+ std::vector<std::unique_ptr<std::string>> stream_data_;
+ std::vector<std::unique_ptr<std::string>> crypto_data_;
};
// Simple struct for defining a packet's content, and associated
// parse error.
struct PacketFragment {
- QuicString error_if_missing;
+ std::string error_if_missing;
std::vector<unsigned char> fragment;
};
@@ -569,7 +569,7 @@
// Check all the various prefixes of |packet| for the expected
// parse error and error code.
for (size_t i = 0; i < packet->length(); ++i) {
- QuicString expected_error;
+ std::string expected_error;
size_t len = 0;
for (const auto& fragment : fragments) {
len += fragment.fragment.size();
@@ -588,7 +588,7 @@
void CheckProcessingFails(const QuicEncryptedPacket& packet,
size_t len,
- QuicString expected_error,
+ std::string expected_error,
QuicErrorCode error_code) {
QuicEncryptedPacket encrypted(packet.data(), len, false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted)) << "len: " << len;
@@ -598,7 +598,7 @@
void CheckProcessingFails(unsigned char* packet,
size_t len,
- QuicString expected_error,
+ std::string expected_error,
QuicErrorCode error_code) {
QuicEncryptedPacket encrypted(AsChars(packet), len, false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted)) << "len: " << len;
@@ -607,8 +607,8 @@
}
// Checks if the supplied string matches data in the supplied StreamFrame.
- void CheckStreamFrameData(QuicString str, QuicStreamFrame* frame) {
- EXPECT_EQ(str, QuicString(frame->data_buffer, frame->data_length));
+ void CheckStreamFrameData(std::string str, QuicStreamFrame* frame) {
+ EXPECT_EQ(str, std::string(frame->data_buffer, frame->data_length));
}
void CheckCalculatePacketNumber(uint64_t expected_packet_number,
@@ -6210,7 +6210,8 @@
ASSERT_EQ(1u, visitor_.crypto_frames_.size());
QuicCryptoFrame* frame = visitor_.crypto_frames_[0].get();
EXPECT_EQ(kStreamOffset, frame->offset);
- EXPECT_EQ("hello world!", QuicString(frame->data_buffer, frame->data_length));
+ EXPECT_EQ("hello world!",
+ std::string(frame->data_buffer, frame->data_length));
CheckFramingBoundaries(packet, QUIC_INVALID_FRAME_DATA);
}
@@ -7377,7 +7378,7 @@
} else {
close_frame.error_code = static_cast<QuicErrorCode>(0x05060708);
}
- close_frame.error_details = QuicString(2048, 'A');
+ close_frame.error_details = std::string(2048, 'A');
QuicFrames frames = {QuicFrame(&close_frame)};
// clang-format off
@@ -7662,7 +7663,7 @@
QuicApplicationCloseFrame app_close_frame;
app_close_frame.error_code = static_cast<QuicErrorCode>(0x11);
- app_close_frame.error_details = QuicString(2048, 'A');
+ app_close_frame.error_details = std::string(2048, 'A');
QuicFrames frames = {QuicFrame(&app_close_frame)};
@@ -7846,7 +7847,7 @@
QuicGoAwayFrame goaway_frame;
goaway_frame.error_code = static_cast<QuicErrorCode>(0x05060708);
goaway_frame.last_good_stream_id = kStreamId;
- goaway_frame.reason_phrase = QuicString(2048, 'A');
+ goaway_frame.reason_phrase = std::string(2048, 'A');
QuicFrames frames = {QuicFrame(&goaway_frame)};
@@ -9605,7 +9606,7 @@
return (frame.stream_id == kTestQuicStreamId ||
frame.stream_id == QuicUtils::GetCryptoStreamId(QUIC_VERSION_99)) &&
!frame.fin && frame.offset == 0 &&
- QuicString(frame.data_buffer, frame.data_length) == kTestString;
+ std::string(frame.data_buffer, frame.data_length) == kTestString;
// FIN is hard-coded false in ConstructEncryptedPacket.
// Offset 0 is hard-coded in ConstructEncryptedPacket.
}
@@ -11223,8 +11224,8 @@
uint8_t expected_token_value[] = {0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07};
- QuicNewTokenFrame frame(0, QuicString((const char*)(expected_token_value),
- sizeof(expected_token_value)));
+ QuicNewTokenFrame frame(0, std::string((const char*)(expected_token_value),
+ sizeof(expected_token_value)));
QuicFrames frames = {QuicFrame(&frame)};
@@ -11511,7 +11512,7 @@
QuicFramer::GetRetransmittableControlFrameSize(
framer_.transport_version(), QuicFrame(&rst_stream)));
- QuicString error_detail(2048, 'e');
+ std::string error_detail(2048, 'e');
QuicConnectionCloseFrame connection_close(QUIC_NETWORK_IDLE_TIMEOUT,
error_detail);
EXPECT_EQ(QuicFramer::GetMinConnectionCloseFrameSize(
diff --git a/quic/core/quic_ietf_framer_test.cc b/quic/core/quic_ietf_framer_test.cc
index a959791..9e4f3b0 100644
--- a/quic/core/quic_ietf_framer_test.cc
+++ b/quic/core/quic_ietf_framer_test.cc
@@ -796,7 +796,7 @@
NETWORK_BYTE_ORDER);
// empty string,
- QuicString test_string = "Ich Bin Ein Jelly Donut?";
+ std::string test_string = "Ich Bin Ein Jelly Donut?";
QuicConnectionCloseFrame sent_frame;
sent_frame.error_code = static_cast<QuicErrorCode>(0);
sent_frame.error_details = test_string;
@@ -831,7 +831,7 @@
NETWORK_BYTE_ORDER);
// empty string,
- QuicString test_string = "Ich Bin Ein Jelly Donut?";
+ std::string test_string = "Ich Bin Ein Jelly Donut?";
QuicApplicationCloseFrame sent_frame;
sent_frame.error_code = static_cast<QuicErrorCode>(0);
sent_frame.error_details = test_string;
diff --git a/quic/core/quic_interval_set.h b/quic/core/quic_interval_set.h
index e2ca7a5..fe3165b 100644
--- a/quic/core/quic_interval_set.h
+++ b/quic/core/quic_interval_set.h
@@ -298,7 +298,7 @@
// where the intervals are in the same order as given by traversal from
// begin() to end(). This representation is intended for human consumption;
// computer programs should not rely on the output being in exactly this form.
- QuicString ToString() const;
+ std::string ToString() const;
QuicIntervalSet& operator=(std::initializer_list<value_type> il) {
assign(il.begin(), il.end());
@@ -809,7 +809,7 @@
}
template <typename T>
-QuicString QuicIntervalSet<T>::ToString() const {
+std::string QuicIntervalSet<T>::ToString() const {
std::ostringstream os;
os << *this;
return os.str();
diff --git a/quic/core/quic_interval_set_test.cc b/quic/core/quic_interval_set_test.cc
index e823e4f..de45f6f 100644
--- a/quic/core/quic_interval_set_test.cc
+++ b/quic/core/quic_interval_set_test.cc
@@ -424,7 +424,7 @@
}
TEST_F(QuicIntervalSetTest, QuicIntervalSetIntersectionBothEmpty) {
- QuicIntervalSet<QuicString> mine, theirs;
+ QuicIntervalSet<std::string> mine, theirs;
EXPECT_FALSE(mine.Intersects(theirs));
EXPECT_FALSE(theirs.Intersects(mine));
mine.Intersection(theirs);
@@ -434,8 +434,8 @@
}
TEST_F(QuicIntervalSetTest, QuicIntervalSetIntersectionEmptyMine) {
- QuicIntervalSet<QuicString> mine;
- QuicIntervalSet<QuicString> theirs("a", "b");
+ QuicIntervalSet<std::string> mine;
+ QuicIntervalSet<std::string> theirs("a", "b");
EXPECT_FALSE(mine.Intersects(theirs));
EXPECT_FALSE(theirs.Intersects(mine));
mine.Intersection(theirs);
@@ -445,8 +445,8 @@
}
TEST_F(QuicIntervalSetTest, QuicIntervalSetIntersectionEmptyTheirs) {
- QuicIntervalSet<QuicString> mine("a", "b");
- QuicIntervalSet<QuicString> theirs;
+ QuicIntervalSet<std::string> mine("a", "b");
+ QuicIntervalSet<std::string> theirs;
EXPECT_FALSE(mine.Intersects(theirs));
EXPECT_FALSE(theirs.Intersects(mine));
mine.Intersection(theirs);
@@ -456,8 +456,8 @@
}
TEST_F(QuicIntervalSetTest, QuicIntervalSetIntersectionTheirsBeforeMine) {
- QuicIntervalSet<QuicString> mine("y", "z");
- QuicIntervalSet<QuicString> theirs;
+ QuicIntervalSet<std::string> mine("y", "z");
+ QuicIntervalSet<std::string> theirs;
theirs.Add("a", "b");
theirs.Add("c", "d");
EXPECT_FALSE(mine.Intersects(theirs));
@@ -469,10 +469,10 @@
}
TEST_F(QuicIntervalSetTest, QuicIntervalSetIntersectionMineBeforeTheirs) {
- QuicIntervalSet<QuicString> mine;
+ QuicIntervalSet<std::string> mine;
mine.Add("a", "b");
mine.Add("c", "d");
- QuicIntervalSet<QuicString> theirs("y", "z");
+ QuicIntervalSet<std::string> theirs("y", "z");
EXPECT_FALSE(mine.Intersects(theirs));
EXPECT_FALSE(theirs.Intersects(mine));
mine.Intersection(theirs);
@@ -682,7 +682,7 @@
}
TEST_F(QuicIntervalSetTest, QuicIntervalSetDifferenceEmptyMine) {
- QuicIntervalSet<QuicString> mine, theirs;
+ QuicIntervalSet<std::string> mine, theirs;
theirs.Add("a", "b");
mine.Difference(theirs);
@@ -690,7 +690,7 @@
}
TEST_F(QuicIntervalSetTest, QuicIntervalSetDifferenceEmptyTheirs) {
- QuicIntervalSet<QuicString> mine, theirs;
+ QuicIntervalSet<std::string> mine, theirs;
mine.Add("a", "b");
mine.Difference(theirs);
@@ -700,7 +700,7 @@
}
TEST_F(QuicIntervalSetTest, QuicIntervalSetDifferenceTheirsBeforeMine) {
- QuicIntervalSet<QuicString> mine, theirs;
+ QuicIntervalSet<std::string> mine, theirs;
mine.Add("y", "z");
theirs.Add("a", "b");
@@ -711,7 +711,7 @@
}
TEST_F(QuicIntervalSetTest, QuicIntervalSetDifferenceMineBeforeTheirs) {
- QuicIntervalSet<QuicString> mine, theirs;
+ QuicIntervalSet<std::string> mine, theirs;
mine.Add("a", "b");
theirs.Add("y", "z");
@@ -722,10 +722,10 @@
}
TEST_F(QuicIntervalSetTest, QuicIntervalSetDifferenceIdentical) {
- QuicIntervalSet<QuicString> mine;
+ QuicIntervalSet<std::string> mine;
mine.Add("a", "b");
mine.Add("c", "d");
- QuicIntervalSet<QuicString> theirs(mine);
+ QuicIntervalSet<std::string> theirs(mine);
mine.Difference(theirs);
EXPECT_TRUE(mine.Empty());
diff --git a/quic/core/quic_interval_test.cc b/quic/core/quic_interval_test.cc
index 143d417..50e8a50 100644
--- a/quic/core/quic_interval_test.cc
+++ b/quic/core/quic_interval_test.cc
@@ -402,7 +402,7 @@
TEST_F(QuicIntervalTest, IntervalOfTypeWithNoOperatorMinus) {
// QuicInterval<T> should work even if T does not support operator-(). We
// just can't call QuicInterval<T>::Length() for such types.
- const QuicInterval<QuicString> d1("a", "b");
+ const QuicInterval<std::string> d1("a", "b");
const QuicInterval<std::pair<int, int>> d2({1, 2}, {4, 3});
EXPECT_EQ("a", d1.min());
EXPECT_EQ("b", d1.max());
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index 9d823bc..2fd5203 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -188,7 +188,7 @@
if (FLAGS_quic_enforce_single_packet_chlo &&
StreamFrameStartsWithChlo(frame->stream_frame) &&
frame->stream_frame.data_length < write_length) {
- const QuicString error_details =
+ const std::string error_details =
"Client hello won't fit in a single packet.";
QUIC_BUG << error_details << " Constructed stream frame length: "
<< frame->stream_frame.data_length
@@ -380,7 +380,7 @@
void QuicPacketCreator::OnSerializedPacket() {
if (packet_.encrypted_buffer == nullptr) {
- const QuicString error_details = "Failed to SerializePacket.";
+ const std::string error_details = "Failed to SerializePacket.";
QUIC_BUG << error_details;
delegate_->OnUnrecoverableError(QUIC_FAILED_TO_SERIALIZE_PACKET,
error_details,
@@ -792,7 +792,7 @@
}
void QuicPacketCreator::SetRetryToken(QuicStringPiece retry_token) {
- retry_token_ = QuicString(retry_token);
+ retry_token_ = std::string(retry_token);
}
QuicVariableLengthIntegerLength QuicPacketCreator::GetLengthLength() const {
@@ -849,7 +849,7 @@
frame.stream_frame.stream_id !=
QuicUtils::GetCryptoStreamId(framer_->transport_version()) &&
packet_.encryption_level == ENCRYPTION_NONE) {
- const QuicString error_details =
+ const std::string error_details =
"Cannot send stream data without encryption.";
QUIC_BUG << error_details;
delegate_->OnUnrecoverableError(
diff --git a/quic/core/quic_packet_creator.h b/quic/core/quic_packet_creator.h
index f4512c3..3ff5819 100644
--- a/quic/core/quic_packet_creator.h
+++ b/quic/core/quic_packet_creator.h
@@ -390,7 +390,7 @@
SerializedPacket packet_;
// Retry token to send over the wire in v99 IETF Initial packets.
- QuicString retry_token_;
+ std::string retry_token_;
// Pending padding bytes to send. Pending padding bytes will be sent in next
// packet(s) (after all other frames) if current constructed packet does not
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index c15955c..87b6897 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -179,7 +179,7 @@
void CheckStreamFrame(const QuicFrame& frame,
QuicStreamId stream_id,
- const QuicString& data,
+ const std::string& data,
QuicStreamOffset offset,
bool fin) {
EXPECT_EQ(STREAM_FRAME, frame.type);
@@ -253,7 +253,7 @@
QuicFramer client_framer_;
StrictMock<MockFramerVisitor> framer_visitor_;
StrictMock<MockPacketCreatorDelegate> delegate_;
- QuicString data_;
+ std::string data_;
struct iovec iov_;
TestPacketCreator creator_;
SerializedPacket serialized_packet_;
@@ -468,7 +468,7 @@
GetStreamFrameOverhead(client_framer_.transport_version());
size_t capacity = kDefaultMaxPacketSize - overhead;
for (int delta = -5; delta <= 0; ++delta) {
- QuicString data(capacity + delta, 'A');
+ std::string data(capacity + delta, 'A');
size_t bytes_free = 0 - delta;
QuicFrame frame;
@@ -532,7 +532,7 @@
}
TEST_P(QuicPacketCreatorTest, ConsumeCryptoData) {
- QuicString data = "crypto data";
+ std::string data = "crypto data";
QuicFrame frame;
ASSERT_TRUE(creator_.ConsumeCryptoData(ENCRYPTION_NONE, data.length(), 0,
NOT_RETRANSMISSION, &frame));
@@ -577,7 +577,7 @@
EXPECT_EQ(0u, consumed);
CheckStreamFrame(
frame, QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
- QuicString(), 0u, true);
+ std::string(), 0u, true);
EXPECT_TRUE(creator_.HasPendingFrames());
}
@@ -620,7 +620,7 @@
size_t capacity = kDefaultMaxPacketSize - overhead;
// Now, test various sizes around this size.
for (int delta = -5; delta <= 5; ++delta) {
- QuicString data(capacity + delta, 'A');
+ std::string data(capacity + delta, 'A');
size_t bytes_free = delta > 0 ? 0 : 0 - delta;
QuicFrame frame;
MakeIOVector(data, &iov_);
@@ -651,7 +651,7 @@
size_t capacity = kDefaultMaxPacketSize - overhead;
// Now, test various sizes around this size.
for (int delta = -5; delta <= 5; ++delta) {
- QuicString data(capacity + delta, 'A');
+ std::string data(capacity + delta, 'A');
size_t bytes_free = delta > 0 ? 0 : 0 - delta;
QuicFrame frame;
@@ -691,7 +691,7 @@
size_t capacity = kDefaultMaxPacketSize - overhead;
// Now, test various sizes around this size.
for (int delta = -5; delta <= 5; ++delta) {
- QuicString data(capacity + delta, 'A');
+ std::string data(capacity + delta, 'A');
size_t bytes_free = delta > 0 ? 0 : 0 - delta;
QuicFrame frame;
@@ -1128,7 +1128,7 @@
QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_),
QuicPacketCreatorPeer::GetLengthLength(&creator_), &payload_length));
QuicFrame frame;
- const QuicString too_long_payload(payload_length * 2, 'a');
+ const std::string too_long_payload(payload_length * 2, 'a');
MakeIOVector(too_long_payload, &iov_);
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
@@ -1137,7 +1137,7 @@
1u, iov_.iov_len, 0u, 0u, true, false, NOT_RETRANSMISSION, &frame));
size_t consumed = frame.stream_frame.data_length;
EXPECT_EQ(payload_length, consumed);
- const QuicString payload(payload_length, 'a');
+ const std::string payload(payload_length, 'a');
CheckStreamFrame(
frame, QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
payload, 0u, false);
@@ -1510,7 +1510,7 @@
// Verify that there is enough room for the largest message payload.
EXPECT_TRUE(
creator_.HasRoomForMessageFrame(creator_.GetLargestMessagePayload()));
- QuicString message(creator_.GetLargestMessagePayload(), 'a');
+ std::string message(creator_.GetLargestMessagePayload(), 'a');
QuicMessageFrame* message_frame = new QuicMessageFrame(1);
MakeSpan(&allocator_, message, &storage)
.SaveMemSlicesAsMessageData(message_frame);
@@ -1555,7 +1555,7 @@
if (client_framer_.transport_version() <= QUIC_VERSION_44) {
return;
}
- QuicString message_data(kDefaultMaxPacketSize, 'a');
+ std::string message_data(kDefaultMaxPacketSize, 'a');
QuicStringPiece message_buffer(message_data);
QuicMemSliceStorage storage(nullptr, 0, nullptr, 0);
// Test all possible size of message frames.
@@ -1635,7 +1635,7 @@
9, 10, 11, 12, 13, 14, 15, 16};
creator_.SetRetryToken(
- QuicString(retry_token_bytes, sizeof(retry_token_bytes)));
+ std::string(retry_token_bytes, sizeof(retry_token_bytes)));
frames_.push_back(QuicFrame(QuicStreamFrame(
QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), false,
diff --git a/quic/core/quic_packet_generator_test.cc b/quic/core/quic_packet_generator_test.cc
index 7b7d6ce..3903984 100644
--- a/quic/core/quic_packet_generator_test.cc
+++ b/quic/core/quic_packet_generator_test.cc
@@ -52,7 +52,7 @@
MOCK_METHOD0(GetPacketBuffer, char*());
MOCK_METHOD1(OnSerializedPacket, void(SerializedPacket* packet));
MOCK_METHOD3(OnUnrecoverableError,
- void(QuicErrorCode, const QuicString&, ConnectionCloseSource));
+ void(QuicErrorCode, const std::string&, ConnectionCloseSource));
void SetCanWriteAnything() {
EXPECT_CALL(*this, ShouldGeneratePacket(_, _)).WillRepeatedly(Return(true));
@@ -239,7 +239,7 @@
}
QuicGoAwayFrame* CreateGoAwayFrame() {
- return new QuicGoAwayFrame(2, QUIC_NO_ERROR, 1, QuicString());
+ return new QuicGoAwayFrame(2, QUIC_NO_ERROR, 1, std::string());
}
void CheckPacketContains(const PacketContents& contents,
@@ -478,7 +478,7 @@
EXPECT_CALL(delegate_, OnSerializedPacket(_))
.WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
- QuicString data = "crypto data";
+ std::string data = "crypto data";
size_t consumed_bytes =
generator_.ConsumeCryptoData(ENCRYPTION_NONE, data, 0);
generator_.Flush();
@@ -1350,7 +1350,7 @@
frame->error_code = QUIC_PACKET_WRITE_ERROR;
char buf[2000] = {};
QuicStringPiece error_details(buf, 2000);
- frame->error_details = QuicString(error_details);
+ frame->error_details = std::string(error_details);
generator_.AddControlFrame(QuicFrame(frame), /*bundle_ack=*/false);
EXPECT_TRUE(generator_.HasQueuedFrames());
EXPECT_TRUE(generator_.HasRetransmittableFrames());
@@ -1533,7 +1533,7 @@
MESSAGE_STATUS_SUCCESS,
generator_.AddMessageFrame(
2, MakeSpan(&allocator_,
- QuicString(generator_.GetLargestMessagePayload(), 'a'),
+ std::string(generator_.GetLargestMessagePayload(), 'a'),
&storage)));
EXPECT_TRUE(generator_.HasRetransmittableFrames());
@@ -1543,7 +1543,7 @@
generator_.AddMessageFrame(
3,
MakeSpan(&allocator_,
- QuicString(generator_.GetLargestMessagePayload() + 10, 'a'),
+ std::string(generator_.GetLargestMessagePayload() + 10, 'a'),
&storage)));
}
diff --git a/quic/core/quic_packets.h b/quic/core/quic_packets.h
index d2aaf34..509fd08 100644
--- a/quic/core/quic_packets.h
+++ b/quic/core/quic_packets.h
@@ -140,7 +140,7 @@
// An arbitrary string to identify an endpoint. Used by clients to
// differentiate traffic from Google servers vs Non-google servers.
// Will not be used if empty().
- QuicString endpoint_id;
+ std::string endpoint_id;
};
struct QUIC_EXPORT_PRIVATE QuicVersionNegotiationPacket {
diff --git a/quic/core/quic_sent_packet_manager.cc b/quic/core/quic_sent_packet_manager.cc
index 6d6710f..bfafe43 100644
--- a/quic/core/quic_sent_packet_manager.cc
+++ b/quic/core/quic_sent_packet_manager.cc
@@ -1010,7 +1010,7 @@
return retransmission_delay;
}
-QuicString QuicSentPacketManager::GetDebugState() const {
+std::string QuicSentPacketManager::GetDebugState() const {
return send_algorithm_->GetDebugState();
}
diff --git a/quic/core/quic_sent_packet_manager.h b/quic/core/quic_sent_packet_manager.h
index aacdc34..873e88b 100644
--- a/quic/core/quic_sent_packet_manager.h
+++ b/quic/core/quic_sent_packet_manager.h
@@ -237,7 +237,7 @@
}
// Returns debugging information about the state of the congestion controller.
- QuicString GetDebugState() const;
+ std::string GetDebugState() const;
// Returns the number of bytes that are considered in-flight, i.e. not lost or
// acknowledged.
diff --git a/quic/core/quic_server_id.cc b/quic/core/quic_server_id.cc
index ab35d6e..43b94b1 100644
--- a/quic/core/quic_server_id.cc
+++ b/quic/core/quic_server_id.cc
@@ -14,10 +14,10 @@
QuicServerId::QuicServerId() : QuicServerId("", 0, false) {}
-QuicServerId::QuicServerId(const QuicString& host, uint16_t port)
+QuicServerId::QuicServerId(const std::string& host, uint16_t port)
: QuicServerId(host, port, false) {}
-QuicServerId::QuicServerId(const QuicString& host,
+QuicServerId::QuicServerId(const std::string& host,
uint16_t port,
bool privacy_mode_enabled)
: host_(host), port_(port), privacy_mode_enabled_(privacy_mode_enabled) {}
diff --git a/quic/core/quic_server_id.h b/quic/core/quic_server_id.h
index 62c0fda..33a0f0a 100644
--- a/quic/core/quic_server_id.h
+++ b/quic/core/quic_server_id.h
@@ -17,8 +17,8 @@
class QUIC_EXPORT_PRIVATE QuicServerId {
public:
QuicServerId();
- QuicServerId(const QuicString& host, uint16_t port);
- QuicServerId(const QuicString& host,
+ QuicServerId(const std::string& host, uint16_t port);
+ QuicServerId(const std::string& host,
uint16_t port,
bool privacy_mode_enabled);
~QuicServerId();
@@ -27,7 +27,7 @@
bool operator<(const QuicServerId& other) const;
bool operator==(const QuicServerId& other) const;
- const QuicString& host() const { return host_; }
+ const std::string& host() const { return host_; }
uint16_t port() const { return port_; }
@@ -36,7 +36,7 @@
size_t EstimateMemoryUsage() const;
private:
- QuicString host_;
+ std::string host_;
uint16_t port_;
bool privacy_mode_enabled_;
};
diff --git a/quic/core/quic_server_id_test.cc b/quic/core/quic_server_id_test.cc
index e7a2abe..01e5a81 100644
--- a/quic/core/quic_server_id_test.cc
+++ b/quic/core/quic_server_id_test.cc
@@ -116,7 +116,7 @@
}
TEST_F(QuicServerIdTest, EstimateMemoryUsage) {
- QuicString host = "this is a rather very quite long hostname";
+ std::string host = "this is a rather very quite long hostname";
uint16_t port = 10;
bool privacy_mode_enabled = true;
QuicServerId server_id(host, port, privacy_mode_enabled);
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 09e3865..151fa18 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -289,7 +289,7 @@
}
void QuicSession::OnConnectionClosed(QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
ConnectionCloseSource source) {
DCHECK(!connection_->connected());
if (error_ == QUIC_NO_ERROR) {
@@ -617,7 +617,7 @@
}
void QuicSession::SendGoAway(QuicErrorCode error_code,
- const QuicString& reason) {
+ const std::string& reason) {
// GOAWAY frame is not supported in v99.
DCHECK_NE(QUIC_VERSION_99, connection_->transport_version());
if (goaway_sent_) {
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 6cd766f..68cc96e 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -54,7 +54,7 @@
// Called when the connection is closed after the streams have been closed.
virtual void OnConnectionClosed(QuicConnectionId connection_id,
QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
ConnectionCloseSource source) = 0;
// Called when the session has become write blocked.
@@ -106,7 +106,7 @@
void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
void OnBlockedFrame(const QuicBlockedFrame& frame) override;
void OnConnectionClosed(QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
ConnectionCloseSource source) override;
void OnWriteBlocked() override;
void OnSuccessfulVersionNegotiation(
@@ -203,7 +203,7 @@
QuicStreamOffset bytes_written);
// Called when the session wants to go away and not accept any new streams.
- virtual void SendGoAway(QuicErrorCode error_code, const QuicString& reason);
+ virtual void SendGoAway(QuicErrorCode error_code, const std::string& reason);
// Sends a BLOCKED frame.
virtual void SendBlocked(QuicStreamId id);
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 928f690..fba914f 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -65,7 +65,7 @@
encryption_established_ = true;
handshake_confirmed_ = true;
CryptoHandshakeMessage msg;
- QuicString error_details;
+ std::string error_details;
session()->config()->SetInitialStreamFlowControlWindowToSend(
kInitialStreamFlowControlWindowForTest);
session()->config()->SetInitialSessionFlowControlWindowToSend(
@@ -717,7 +717,7 @@
EXPECT_CALL(*connection_, SendControlFrame(_));
EXPECT_CALL(*connection_, OnStreamReset(closed_stream_id, _));
stream2->Reset(QUIC_BAD_APPLICATION_PAYLOAD);
- QuicString msg =
+ std::string msg =
QuicStrCat("Marking unknown stream ", closed_stream_id, " blocked.");
EXPECT_QUIC_BUG(session_.MarkConnectionLevelWriteBlocked(closed_stream_id),
msg);
@@ -1218,7 +1218,7 @@
// Create a stream, and send enough data to make it flow control blocked.
TestStream* stream2 = session_.CreateOutgoingBidirectionalStream();
- QuicString body(kMinimumFlowControlSendWindow, '.');
+ std::string body(kMinimumFlowControlSendWindow, '.');
EXPECT_FALSE(stream2->flow_controller()->IsBlocked());
EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
@@ -1370,7 +1370,7 @@
// adjusting the connection level flow control receive window to take into
// account the total number of bytes sent by the peer.
const QuicStreamOffset kByteOffset = 5678;
- QuicString body = "hello";
+ std::string body = "hello";
QuicStreamFrame frame(stream->id(), true, kByteOffset, QuicStringPiece(body));
session_.OnStreamFrame(frame);
@@ -1735,7 +1735,7 @@
session_.set_writev_consumes_all_data(true);
TestStream* stream2 = session_.CreateOutgoingBidirectionalStream();
- QuicString body(100, '.');
+ std::string body(100, '.');
stream2->WriteOrBufferData(body, false, nullptr);
EXPECT_TRUE(stream2->IsWaitingForAcks());
EXPECT_EQ(1u, QuicStreamPeer::SendBuffer(stream2).size());
@@ -2023,7 +2023,7 @@
session_.set_writev_consumes_all_data(true);
TestStream* stream2 = session_.CreateOutgoingBidirectionalStream();
- QuicString body(100, '.');
+ std::string body(100, '.');
stream2->CloseReadSide();
stream2->WriteOrBufferData(body, true, nullptr);
EXPECT_TRUE(stream2->IsWaitingForAcks());
@@ -2074,7 +2074,7 @@
TestStream* stream4 = new TestStream(GetNthServerInitiatedUnidirectionalId(1),
&session_, WRITE_UNIDIRECTIONAL);
session_.ActivateStream(QuicWrapUnique(stream4));
- QuicString body(100, '.');
+ std::string body(100, '.');
stream4->WriteOrBufferData(body, false, nullptr);
EXPECT_FALSE(QuicContainsKey(session_.zombie_streams(), stream4->id()));
stream4->WriteOrBufferData(body, true, nullptr);
@@ -2103,7 +2103,7 @@
// Discard all incoming data.
stream4->StopReading();
- QuicString data(100, '.');
+ std::string data(100, '.');
QuicStreamFrame stream_frame(GetNthClientInitiatedUnidirectionalId(1), false,
0, data);
stream4->OnStreamFrame(stream_frame);
@@ -2124,7 +2124,7 @@
CloseConnection(
QUIC_TRY_TO_WRITE_DATA_ON_READ_UNIDIRECTIONAL_STREAM, _, _))
.Times(1);
- QuicString body(100, '.');
+ std::string body(100, '.');
stream4->WriteOrBufferData(body, false, nullptr);
}
@@ -2137,7 +2137,7 @@
CloseConnection(
QUIC_TRY_TO_WRITE_DATA_ON_READ_UNIDIRECTIONAL_STREAM, _, _))
.Times(1);
- QuicString body(100, '.');
+ std::string body(100, '.');
struct iovec iov = {const_cast<char*>(body.data()), body.length()};
QuicMemSliceStorage storage(
&iov, 1, session_.connection()->helper()->GetStreamSendBufferAllocator(),
diff --git a/quic/core/quic_socket_address_coder.cc b/quic/core/quic_socket_address_coder.cc
index bb1eaea..1cb8ff7 100644
--- a/quic/core/quic_socket_address_coder.cc
+++ b/quic/core/quic_socket_address_coder.cc
@@ -23,8 +23,8 @@
QuicSocketAddressCoder::~QuicSocketAddressCoder() {}
-QuicString QuicSocketAddressCoder::Encode() const {
- QuicString serialized;
+std::string QuicSocketAddressCoder::Encode() const {
+ std::string serialized;
uint16_t address_family;
switch (address_.host().address_family()) {
case IpAddressFamily::IP_V4:
diff --git a/quic/core/quic_socket_address_coder.h b/quic/core/quic_socket_address_coder.h
index 6ac5d49..e02fc6e 100644
--- a/quic/core/quic_socket_address_coder.h
+++ b/quic/core/quic_socket_address_coder.h
@@ -25,7 +25,7 @@
QuicSocketAddressCoder& operator=(const QuicSocketAddressCoder&) = delete;
~QuicSocketAddressCoder();
- QuicString Encode() const;
+ std::string Encode() const;
bool Decode(const char* data, size_t length);
diff --git a/quic/core/quic_socket_address_coder_test.cc b/quic/core/quic_socket_address_coder_test.cc
index eb65efa..b4a51dd 100644
--- a/quic/core/quic_socket_address_coder_test.cc
+++ b/quic/core/quic_socket_address_coder_test.cc
@@ -17,8 +17,8 @@
QuicIpAddress ip;
ip.FromString("4.31.198.44");
QuicSocketAddressCoder coder(QuicSocketAddress(ip, 0x1234));
- QuicString serialized = coder.Encode();
- QuicString expected("\x02\x00\x04\x1f\xc6\x2c\x34\x12", 8);
+ std::string serialized = coder.Encode();
+ std::string expected("\x02\x00\x04\x1f\xc6\x2c\x34\x12", 8);
EXPECT_EQ(expected, serialized);
}
@@ -26,8 +26,8 @@
QuicIpAddress ip;
ip.FromString("2001:700:300:1800::f");
QuicSocketAddressCoder coder(QuicSocketAddress(ip, 0x5678));
- QuicString serialized = coder.Encode();
- QuicString expected(
+ std::string serialized = coder.Encode();
+ std::string expected(
"\x0a\x00"
"\x20\x01\x07\x00\x03\x00\x18\x00"
"\x00\x00\x00\x00\x00\x00\x00\x0f"
@@ -37,17 +37,17 @@
}
TEST_F(QuicSocketAddressCoderTest, DecodeIPv4) {
- QuicString serialized("\x02\x00\x04\x1f\xc6\x2c\x34\x12", 8);
+ std::string serialized("\x02\x00\x04\x1f\xc6\x2c\x34\x12", 8);
QuicSocketAddressCoder coder;
ASSERT_TRUE(coder.Decode(serialized.data(), serialized.length()));
EXPECT_EQ(IpAddressFamily::IP_V4, coder.ip().address_family());
- QuicString expected_addr("\x04\x1f\xc6\x2c");
+ std::string expected_addr("\x04\x1f\xc6\x2c");
EXPECT_EQ(expected_addr, coder.ip().ToPackedString());
EXPECT_EQ(0x1234, coder.port());
}
TEST_F(QuicSocketAddressCoderTest, DecodeIPv6) {
- QuicString serialized(
+ std::string serialized(
"\x0a\x00"
"\x20\x01\x07\x00\x03\x00\x18\x00"
"\x00\x00\x00\x00\x00\x00\x00\x0f"
@@ -56,7 +56,7 @@
QuicSocketAddressCoder coder;
ASSERT_TRUE(coder.Decode(serialized.data(), serialized.length()));
EXPECT_EQ(IpAddressFamily::IP_V6, coder.ip().address_family());
- QuicString expected_addr(
+ std::string expected_addr(
"\x20\x01\x07\x00\x03\x00\x18\x00"
"\x00\x00\x00\x00\x00\x00\x00\x0f",
16);
@@ -65,7 +65,7 @@
}
TEST_F(QuicSocketAddressCoderTest, DecodeBad) {
- QuicString serialized(
+ std::string serialized(
"\x0a\x00"
"\x20\x01\x07\x00\x03\x00\x18\x00"
"\x00\x00\x00\x00\x00\x00\x00\x0f"
@@ -114,7 +114,7 @@
QuicIpAddress ip;
ASSERT_TRUE(ip.FromString(test_case[i].ip_literal));
QuicSocketAddressCoder encoder(QuicSocketAddress(ip, test_case[i].port));
- QuicString serialized = encoder.Encode();
+ std::string serialized = encoder.Encode();
QuicSocketAddressCoder decoder;
ASSERT_TRUE(decoder.Decode(serialized.data(), serialized.length()));
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index 86207b6..91dace4 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -76,7 +76,7 @@
}
void PendingStream::CloseConnectionWithDetails(QuicErrorCode error,
- const QuicString& details) {
+ const std::string& details) {
session_->connection()->CloseConnection(
error, details, ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
}
@@ -402,7 +402,7 @@
}
void QuicStream::CloseConnectionWithDetails(QuicErrorCode error,
- const QuicString& details) {
+ const std::string& details) {
session()->connection()->CloseConnection(
error, details, ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
}
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index fe0a794..21d57b5 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -59,7 +59,7 @@
void AddBytesConsumed(QuicByteCount bytes) override;
void Reset(QuicRstStreamErrorCode error) override;
void CloseConnectionWithDetails(QuicErrorCode error,
- const QuicString& details) override;
+ const std::string& details) override;
QuicStreamId id() const override;
const QuicSocketAddress& PeerAddressOfLatestPacket() const override;
@@ -144,7 +144,7 @@
// Called by the subclass or the sequencer to close the entire connection from
// this end.
void CloseConnectionWithDetails(QuicErrorCode error,
- const QuicString& details) override;
+ const std::string& details) override;
// Called by the stream sequencer as bytes are consumed from the buffer.
// If the receive window has dropped below the threshold, then send a
diff --git a/quic/core/quic_stream_id_manager.h b/quic/core/quic_stream_id_manager.h
index 95951c0..11f8968 100644
--- a/quic/core/quic_stream_id_manager.h
+++ b/quic/core/quic_stream_id_manager.h
@@ -44,7 +44,7 @@
// Generate a string suitable for sending to the log/etc to show current state
// of the stream ID manager.
- QuicString DebugString() const {
+ std::string DebugString() const {
return QuicStrCat(
" { max_allowed_outgoing_stream_id: ", max_allowed_outgoing_stream_id_,
", actual_max_allowed_incoming_stream_id_: ",
diff --git a/quic/core/quic_stream_id_manager_test.cc b/quic/core/quic_stream_id_manager_test.cc
index 51799e2..2958c89 100644
--- a/quic/core/quic_stream_id_manager_test.cc
+++ b/quic/core/quic_stream_id_manager_test.cc
@@ -329,7 +329,7 @@
QuicStreamId stream_id =
stream_id_manager_->actual_max_allowed_incoming_stream_id() +
kV99StreamIdIncrement;
- QuicString error_details =
+ std::string error_details =
GetParam() ? "Stream id 401 above 397" : "Stream id 403 above 399";
EXPECT_CALL(*connection_,
CloseConnection(QUIC_INVALID_STREAM_ID, error_details, _));
@@ -603,7 +603,7 @@
// jump is not allowed; make sure.
first_dynamic += kV99StreamIdIncrement * 100;
expected_max_incoming += kV99StreamIdIncrement * 100;
- QuicString bug_detail =
+ std::string bug_detail =
GetParam() ? "allocate 5 got 401" : "allocate 7 got 403";
EXPECT_QUIC_BUG(
stream_id_manager_->RegisterStaticStream(first_dynamic),
@@ -830,7 +830,7 @@
stream_id_manager_->actual_max_allowed_incoming_stream_id() +
kV99StreamIdIncrement * 20;
- QuicString error_details =
+ std::string error_details =
GetParam() ? "Stream id 480 above 400" : "Stream id 478 above 398";
EXPECT_CALL(*connection_,
CloseConnection(QUIC_INVALID_STREAM_ID, error_details, _));
diff --git a/quic/core/quic_stream_send_buffer_test.cc b/quic/core/quic_stream_send_buffer_test.cc
index a58f872..7670152 100644
--- a/quic/core/quic_stream_send_buffer_test.cc
+++ b/quic/core/quic_stream_send_buffer_test.cc
@@ -30,8 +30,8 @@
EXPECT_EQ(0u, send_buffer_.size());
EXPECT_EQ(0u, send_buffer_.stream_bytes_written());
EXPECT_EQ(0u, send_buffer_.stream_bytes_outstanding());
- QuicString data1(1536, 'a');
- QuicString data2 = QuicString(256, 'b') + QuicString(256, 'c');
+ std::string data1(1536, 'a');
+ std::string data2 = std::string(256, 'b') + std::string(256, 'c');
struct iovec iov[2];
iov[0] = MakeIovec(QuicStringPiece(data1));
iov[1] = MakeIovec(QuicStringPiece(data2));
@@ -77,11 +77,11 @@
TEST_F(QuicStreamSendBufferTest, CopyDataToBuffer) {
char buf[4000];
QuicDataWriter writer(4000, buf, HOST_BYTE_ORDER);
- QuicString copy1(1024, 'a');
- QuicString copy2 =
- QuicString(512, 'a') + QuicString(256, 'b') + QuicString(256, 'c');
- QuicString copy3(1024, 'c');
- QuicString copy4(768, 'd');
+ std::string copy1(1024, 'a');
+ std::string copy2 =
+ std::string(512, 'a') + std::string(256, 'b') + std::string(256, 'c');
+ std::string copy3(1024, 'c');
+ std::string copy4(768, 'd');
ASSERT_TRUE(send_buffer_.WriteStreamData(0, 1024, &writer));
EXPECT_EQ(copy1, QuicStringPiece(buf, 1024));
@@ -94,12 +94,12 @@
// Test data piece across boundries.
QuicDataWriter writer2(4000, buf, HOST_BYTE_ORDER);
- QuicString copy5 =
- QuicString(536, 'a') + QuicString(256, 'b') + QuicString(232, 'c');
+ std::string copy5 =
+ std::string(536, 'a') + std::string(256, 'b') + std::string(232, 'c');
ASSERT_TRUE(send_buffer_.WriteStreamData(1000, 1024, &writer2));
EXPECT_EQ(copy5, QuicStringPiece(buf, 1024));
ASSERT_TRUE(send_buffer_.WriteStreamData(2500, 1024, &writer2));
- QuicString copy6 = QuicString(572, 'c') + QuicString(452, 'd');
+ std::string copy6 = std::string(572, 'c') + std::string(452, 'd');
EXPECT_EQ(copy6, QuicStringPiece(buf + 1024, 1024));
// Invalid data copy.
diff --git a/quic/core/quic_stream_sequencer.cc b/quic/core/quic_stream_sequencer.cc
index 6311dcf..47c7c9f 100644
--- a/quic/core/quic_stream_sequencer.cc
+++ b/quic/core/quic_stream_sequencer.cc
@@ -60,12 +60,12 @@
const char* data_buffer) {
const size_t previous_readable_bytes = buffered_frames_.ReadableBytes();
size_t bytes_written;
- QuicString error_details;
+ std::string error_details;
QuicErrorCode result = buffered_frames_.OnStreamData(
byte_offset, QuicStringPiece(data_buffer, data_len), &bytes_written,
&error_details);
if (result != QUIC_NO_ERROR) {
- QuicString details = QuicStrCat(
+ std::string details = QuicStrCat(
"Stream ", stream_->id(), ": ", QuicErrorCodeToString(result), ": ",
error_details,
"\nPeer Address: ", stream_->PeerAddressOfLatestPacket().ToString());
@@ -161,7 +161,7 @@
return buffered_frames_.PrefetchNextRegion(iov);
}
-void QuicStreamSequencer::Read(QuicString* buffer) {
+void QuicStreamSequencer::Read(std::string* buffer) {
DCHECK(!blocked_);
buffer->resize(buffer->size() + ReadableBytes());
iovec iov;
@@ -172,12 +172,12 @@
int QuicStreamSequencer::Readv(const struct iovec* iov, size_t iov_len) {
DCHECK(!blocked_);
- QuicString error_details;
+ std::string error_details;
size_t bytes_read;
QuicErrorCode read_error =
buffered_frames_.Readv(iov, iov_len, &bytes_read, &error_details);
if (read_error != QUIC_NO_ERROR) {
- QuicString details =
+ std::string details =
QuicStrCat("Stream ", stream_->id(), ": ", error_details);
stream_->CloseConnectionWithDetails(read_error, details);
return static_cast<int>(bytes_read);
@@ -259,7 +259,7 @@
return buffered_frames_.BytesConsumed();
}
-const QuicString QuicStreamSequencer::DebugString() const {
+const std::string QuicStreamSequencer::DebugString() const {
// clang-format off
return QuicStrCat("QuicStreamSequencer:",
"\n bytes buffered: ", NumBytesBuffered(),
diff --git a/quic/core/quic_stream_sequencer.h b/quic/core/quic_stream_sequencer.h
index 3feee5e..120b997 100644
--- a/quic/core/quic_stream_sequencer.h
+++ b/quic/core/quic_stream_sequencer.h
@@ -43,7 +43,7 @@
// Called when an error has occurred which should result in the connection
// being closed.
virtual void CloseConnectionWithDetails(QuicErrorCode error,
- const QuicString& details) = 0;
+ const std::string& details) = 0;
// Returns the stream id of this stream.
virtual QuicStreamId id() const = 0;
@@ -98,7 +98,7 @@
// Appends all of the readable data to |buffer| and marks all of the appended
// data as consumed.
- void Read(QuicString* buffer);
+ void Read(std::string* buffer);
// Returns true if the sequncer has bytes available for reading.
bool HasBytesToRead() const;
@@ -153,7 +153,7 @@
void set_stream(StreamInterface* stream) { stream_ = stream; }
// Returns string describing internal state.
- const QuicString DebugString() const;
+ const std::string DebugString() const;
private:
friend class test::QuicStreamSequencerPeer;
diff --git a/quic/core/quic_stream_sequencer_buffer.cc b/quic/core/quic_stream_sequencer_buffer.cc
index 485c9dc..75000bd 100644
--- a/quic/core/quic_stream_sequencer_buffer.cc
+++ b/quic/core/quic_stream_sequencer_buffer.cc
@@ -71,7 +71,7 @@
QuicStreamOffset starting_offset,
QuicStringPiece data,
size_t* const bytes_buffered,
- QuicString* error_details) {
+ std::string* error_details) {
*bytes_buffered = 0;
size_t size = data.size();
if (size == 0) {
@@ -158,7 +158,7 @@
bool QuicStreamSequencerBuffer::CopyStreamData(QuicStreamOffset offset,
QuicStringPiece data,
size_t* bytes_copy,
- QuicString* error_details) {
+ std::string* error_details) {
*bytes_copy = 0;
size_t source_remaining = data.size();
if (source_remaining == 0) {
@@ -236,7 +236,7 @@
QuicErrorCode QuicStreamSequencerBuffer::Readv(const iovec* dest_iov,
size_t dest_count,
size_t* bytes_read,
- QuicString* error_details) {
+ std::string* error_details) {
*bytes_read = 0;
for (size_t i = 0; i < dest_count && ReadableBytes() > 0; ++i) {
char* dest = reinterpret_cast<char*>(dest_iov[i].iov_base);
@@ -500,12 +500,12 @@
}
}
-QuicString QuicStreamSequencerBuffer::GapsDebugString() {
+std::string QuicStreamSequencerBuffer::GapsDebugString() {
// TODO(vasilvv): this should return the complement of |bytes_received_|.
return bytes_received_.ToString();
}
-QuicString QuicStreamSequencerBuffer::ReceivedFramesDebugString() {
+std::string QuicStreamSequencerBuffer::ReceivedFramesDebugString() {
return bytes_received_.ToString();
}
diff --git a/quic/core/quic_stream_sequencer_buffer.h b/quic/core/quic_stream_sequencer_buffer.h
index 7e547a9..683294e 100644
--- a/quic/core/quic_stream_sequencer_buffer.h
+++ b/quic/core/quic_stream_sequencer_buffer.h
@@ -27,11 +27,11 @@
//
// Expected Use:
// QuicStreamSequencerBuffer buffer(2.5 * 8 * 1024);
-// QuicString source(1024, 'a');
+// std::string source(1024, 'a');
// QuicStringPiece string_piece(source.data(), source.size());
// size_t written = 0;
// buffer.OnStreamData(800, string_piece, GetEpollClockNow(), &written);
-// source = QuicString{800, 'b'};
+// source = std::string{800, 'b'};
// QuicStringPiece string_piece1(source.data(), 800);
// // Try to write to [1, 801), but should fail due to overlapping,
// // res should be QUIC_INVALID_STREAM_DATA
@@ -109,14 +109,14 @@
QuicErrorCode OnStreamData(QuicStreamOffset offset,
QuicStringPiece data,
size_t* bytes_buffered,
- QuicString* error_details);
+ std::string* error_details);
// Reads from this buffer into given iovec array, up to number of iov_len
// iovec objects and returns the number of bytes read.
QuicErrorCode Readv(const struct iovec* dest_iov,
size_t dest_count,
size_t* bytes_read,
- QuicString* error_details);
+ std::string* error_details);
// Returns the readable region of valid data in iovec format. The readable
// region is the buffer region where there is valid data not yet read by
@@ -173,7 +173,7 @@
bool CopyStreamData(QuicStreamOffset offset,
QuicStringPiece data,
size_t* bytes_copy,
- QuicString* error_details);
+ std::string* error_details);
// Dispose the given buffer block.
// After calling this method, blocks_[index] is set to nullptr
@@ -213,10 +213,10 @@
QuicStreamOffset NextExpectedByte() const;
// Return |gaps_| as a string: [1024, 1500) [1800, 2048)... for debugging.
- QuicString GapsDebugString();
+ std::string GapsDebugString();
// Return all received frames as a string in same format as GapsDebugString();
- QuicString ReceivedFramesDebugString();
+ std::string ReceivedFramesDebugString();
// The maximum total capacity of this buffer in byte, as constructed.
const size_t max_buffer_capacity_bytes_;
diff --git a/quic/core/quic_stream_sequencer_buffer_test.cc b/quic/core/quic_stream_sequencer_buffer_test.cc
index 7d5947c..d74bc9b 100644
--- a/quic/core/quic_stream_sequencer_buffer_test.cc
+++ b/quic/core/quic_stream_sequencer_buffer_test.cc
@@ -74,7 +74,7 @@
std::unique_ptr<QuicStreamSequencerBuffer> buffer_;
std::unique_ptr<QuicStreamSequencerBufferPeer> helper_;
- QuicString error_details_;
+ std::string error_details_;
};
TEST_F(QuicStreamSequencerBufferTest, InitializeWithMaxRecvWindowSize) {
@@ -112,7 +112,7 @@
TEST_F(QuicStreamSequencerBufferTest, OnStreamDataWithinBlock) {
EXPECT_FALSE(helper_->IsBufferAllocated());
- QuicString source(1024, 'a');
+ std::string source(1024, 'a');
size_t written;
EXPECT_EQ(QUIC_NO_ERROR,
buffer_->OnStreamData(800, source, &written, &error_details_));
@@ -131,7 +131,7 @@
TEST_F(QuicStreamSequencerBufferTest, Move) {
EXPECT_FALSE(helper_->IsBufferAllocated());
- QuicString source(1024, 'a');
+ std::string source(1024, 'a');
size_t written;
EXPECT_EQ(QUIC_NO_ERROR,
buffer_->OnStreamData(800, source, &written, &error_details_));
@@ -168,7 +168,7 @@
}
TEST_F(QuicStreamSequencerBufferTest, OnStreamDataWithOverlap) {
- QuicString source(1024, 'a');
+ std::string source(1024, 'a');
// Write something into [800, 1824)
size_t written;
EXPECT_EQ(QUIC_NO_ERROR,
@@ -182,12 +182,12 @@
TEST_F(QuicStreamSequencerBufferTest,
OnStreamDataOverlapAndDuplicateCornerCases) {
- QuicString source(1024, 'a');
+ std::string source(1024, 'a');
// Write something into [800, 1824)
size_t written;
buffer_->OnStreamData(800, source, &written, &error_details_);
- source = QuicString(800, 'b');
- QuicString one_byte = "c";
+ source = std::string(800, 'b');
+ std::string one_byte = "c";
// Write [1, 801).
EXPECT_EQ(QUIC_NO_ERROR,
buffer_->OnStreamData(1, source, &written, &error_details_));
@@ -205,12 +205,12 @@
}
TEST_F(QuicStreamSequencerBufferTest, OnStreamDataWithoutOverlap) {
- QuicString source(1024, 'a');
+ std::string source(1024, 'a');
// Write something into [800, 1824).
size_t written;
EXPECT_EQ(QUIC_NO_ERROR,
buffer_->OnStreamData(800, source, &written, &error_details_));
- source = QuicString(100, 'b');
+ source = std::string(100, 'b');
// Write something into [kBlockSizeBytes * 2 - 20, kBlockSizeBytes * 2 + 80).
EXPECT_EQ(QUIC_NO_ERROR,
buffer_->OnStreamData(kBlockSizeBytes * 2 - 20, source, &written,
@@ -228,7 +228,7 @@
// Three new out of order frames arrive.
const size_t kBytesToWrite = 100;
- QuicString source(kBytesToWrite, 'a');
+ std::string source(kBytesToWrite, 'a');
size_t written;
// Frame [2^32 + 500, 2^32 + 600).
QuicStreamOffset offset = pow(2, 32) + 500;
@@ -252,7 +252,7 @@
TEST_F(QuicStreamSequencerBufferTest, OnStreamDataTillEnd) {
// Write 50 bytes to the end.
const size_t kBytesToWrite = 50;
- QuicString source(kBytesToWrite, 'a');
+ std::string source(kBytesToWrite, 'a');
size_t written;
EXPECT_EQ(QUIC_NO_ERROR,
buffer_->OnStreamData(max_capacity_bytes_ - kBytesToWrite, source,
@@ -264,7 +264,7 @@
TEST_F(QuicStreamSequencerBufferTest, OnStreamDataTillEndCorner) {
// Write 1 byte to the end.
const size_t kBytesToWrite = 1;
- QuicString source(kBytesToWrite, 'a');
+ std::string source(kBytesToWrite, 'a');
size_t written;
EXPECT_EQ(QUIC_NO_ERROR,
buffer_->OnStreamData(max_capacity_bytes_ - kBytesToWrite, source,
@@ -274,7 +274,7 @@
}
TEST_F(QuicStreamSequencerBufferTest, OnStreamDataBeyondCapacity) {
- QuicString source(60, 'a');
+ std::string source(60, 'a');
size_t written;
EXPECT_EQ(QUIC_INTERNAL_ERROR,
buffer_->OnStreamData(max_capacity_bytes_ - 50, source, &written,
@@ -308,12 +308,12 @@
}
TEST_F(QuicStreamSequencerBufferTest, Readv100Bytes) {
- QuicString source(1024, 'a');
+ std::string source(1024, 'a');
// Write something into [kBlockSizeBytes, kBlockSizeBytes + 1024).
size_t written;
buffer_->OnStreamData(kBlockSizeBytes, source, &written, &error_details_);
EXPECT_FALSE(buffer_->HasBytesToRead());
- source = QuicString(100, 'b');
+ source = std::string(100, 'b');
// Write something into [0, 100).
buffer_->OnStreamData(0, source, &written, &error_details_);
EXPECT_TRUE(buffer_->HasBytesToRead());
@@ -325,14 +325,14 @@
QUIC_LOG(ERROR) << error_details_;
EXPECT_EQ(100u, read);
EXPECT_EQ(100u, buffer_->BytesConsumed());
- EXPECT_EQ(source, QuicString(dest, read));
+ EXPECT_EQ(source, std::string(dest, read));
// The first block should be released as its data has been read out.
EXPECT_EQ(nullptr, helper_->GetBlock(0));
EXPECT_TRUE(helper_->CheckBufferInvariants());
}
TEST_F(QuicStreamSequencerBufferTest, ReadvAcrossBlocks) {
- QuicString source(kBlockSizeBytes + 50, 'a');
+ std::string source(kBlockSizeBytes + 50, 'a');
// Write 1st block to full and extand 50 bytes to next block.
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
@@ -346,7 +346,7 @@
EXPECT_EQ(QUIC_NO_ERROR, buffer_->Readv(iovecs, 2, &read, &error_details_));
}
// The last read only reads the rest 50 bytes in 2nd block.
- EXPECT_EQ(QuicString(50, 'a'), QuicString(dest, 50));
+ EXPECT_EQ(std::string(50, 'a'), std::string(dest, 50));
EXPECT_EQ(0, dest[50]) << "Dest[50] shouln't be filled.";
EXPECT_EQ(source.size(), buffer_->BytesConsumed());
EXPECT_TRUE(buffer_->Empty());
@@ -354,7 +354,7 @@
}
TEST_F(QuicStreamSequencerBufferTest, ClearAfterRead) {
- QuicString source(kBlockSizeBytes + 50, 'a');
+ std::string source(kBlockSizeBytes + 50, 'a');
// Write 1st block to full with 'a'.
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
@@ -371,7 +371,7 @@
TEST_F(QuicStreamSequencerBufferTest,
OnStreamDataAcrossLastBlockAndFillCapacity) {
- QuicString source(kBlockSizeBytes + 50, 'a');
+ std::string source(kBlockSizeBytes + 50, 'a');
// Write 1st block to full with 'a'.
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
@@ -384,7 +384,7 @@
// Write more than half block size of bytes in the last block with 'b', which
// will wrap to the beginning and reaches the full capacity.
- source = QuicString(0.5 * kBlockSizeBytes + 512, 'b');
+ source = std::string(0.5 * kBlockSizeBytes + 512, 'b');
EXPECT_EQ(QUIC_NO_ERROR, buffer_->OnStreamData(2 * kBlockSizeBytes, source,
&written, &error_details_));
EXPECT_EQ(source.size(), written);
@@ -393,7 +393,7 @@
TEST_F(QuicStreamSequencerBufferTest,
OnStreamDataAcrossLastBlockAndExceedCapacity) {
- QuicString source(kBlockSizeBytes + 50, 'a');
+ std::string source(kBlockSizeBytes + 50, 'a');
// Write 1st block to full.
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
@@ -405,7 +405,7 @@
// Try to write from [max_capacity_bytes_ - 0.5 * kBlockSizeBytes,
// max_capacity_bytes_ + 512 + 1). But last bytes exceeds current capacity.
- source = QuicString(0.5 * kBlockSizeBytes + 512 + 1, 'b');
+ source = std::string(0.5 * kBlockSizeBytes + 512 + 1, 'b');
EXPECT_EQ(QUIC_INTERNAL_ERROR,
buffer_->OnStreamData(2 * kBlockSizeBytes, source, &written,
&error_details_));
@@ -415,14 +415,14 @@
TEST_F(QuicStreamSequencerBufferTest, ReadvAcrossLastBlock) {
// Write to full capacity and read out 512 bytes at beginning and continue
// appending 256 bytes.
- QuicString source(max_capacity_bytes_, 'a');
+ std::string source(max_capacity_bytes_, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
char dest[512]{0};
const iovec iov{dest, 512};
size_t read;
EXPECT_EQ(QUIC_NO_ERROR, buffer_->Readv(&iov, 1, &read, &error_details_));
- source = QuicString(256, 'b');
+ source = std::string(256, 'b');
buffer_->OnStreamData(max_capacity_bytes_, source, &written, &error_details_);
EXPECT_TRUE(helper_->CheckBufferInvariants());
@@ -456,7 +456,7 @@
TEST_F(QuicStreamSequencerBufferTest, ReleaseWholeBuffer) {
// Tests that buffer is not deallocated unless ReleaseWholeBuffer() is called.
- QuicString source(100, 'b');
+ std::string source(100, 'b');
// Write something into [0, 100).
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
@@ -475,7 +475,7 @@
TEST_F(QuicStreamSequencerBufferTest, GetReadableRegionsBlockedByGap) {
// Write into [1, 1024).
- QuicString source(1023, 'a');
+ std::string source(1023, 'a');
size_t written;
buffer_->OnStreamData(1, source, &written, &error_details_);
// Try to get readable regions, but none is there.
@@ -487,7 +487,7 @@
TEST_F(QuicStreamSequencerBufferTest, GetReadableRegionsTillEndOfBlock) {
// Write first block to full with [0, 256) 'a' and the rest 'b' then read out
// [0, 256)
- QuicString source(kBlockSizeBytes, 'a');
+ std::string source(kBlockSizeBytes, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
char dest[256];
@@ -496,14 +496,14 @@
iovec iovs[2];
int iov_count = buffer_->GetReadableRegions(iovs, 2);
EXPECT_EQ(1, iov_count);
- EXPECT_EQ(QuicString(kBlockSizeBytes - 256, 'a'),
- QuicString(reinterpret_cast<const char*>(iovs[0].iov_base),
- iovs[0].iov_len));
+ EXPECT_EQ(std::string(kBlockSizeBytes - 256, 'a'),
+ std::string(reinterpret_cast<const char*>(iovs[0].iov_base),
+ iovs[0].iov_len));
}
TEST_F(QuicStreamSequencerBufferTest, GetReadableRegionsWithinOneBlock) {
// Write into [0, 1024) and then read out [0, 256)
- QuicString source(1024, 'a');
+ std::string source(1024, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
char dest[256];
@@ -512,15 +512,15 @@
iovec iovs[2];
int iov_count = buffer_->GetReadableRegions(iovs, 2);
EXPECT_EQ(1, iov_count);
- EXPECT_EQ(QuicString(1024 - 256, 'a'),
- QuicString(reinterpret_cast<const char*>(iovs[0].iov_base),
- iovs[0].iov_len));
+ EXPECT_EQ(std::string(1024 - 256, 'a'),
+ std::string(reinterpret_cast<const char*>(iovs[0].iov_base),
+ iovs[0].iov_len));
}
TEST_F(QuicStreamSequencerBufferTest,
GetReadableRegionsAcrossBlockWithLongIOV) {
// Write into [0, 2 * kBlockSizeBytes + 1024) and then read out [0, 1024)
- QuicString source(2 * kBlockSizeBytes + 1024, 'a');
+ std::string source(2 * kBlockSizeBytes + 1024, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
char dest[1024];
@@ -538,13 +538,13 @@
GetReadableRegionsWithMultipleIOVsAcrossEnd) {
// Write into [0, 2 * kBlockSizeBytes + 1024) and then read out [0, 1024)
// and then append 1024 + 512 bytes.
- QuicString source(2.5 * kBlockSizeBytes - 1024, 'a');
+ std::string source(2.5 * kBlockSizeBytes - 1024, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
char dest[1024];
helper_->Read(dest, 1024);
// Write across the end.
- source = QuicString(1024 + 512, 'b');
+ source = std::string(1024 + 512, 'b');
buffer_->OnStreamData(2.5 * kBlockSizeBytes - 1024, source, &written,
&error_details_);
// Use short iovec's.
@@ -558,9 +558,9 @@
EXPECT_EQ(4, buffer_->GetReadableRegions(iovs1, 5));
EXPECT_EQ(0.5 * kBlockSizeBytes, iovs1[2].iov_len);
EXPECT_EQ(512u, iovs1[3].iov_len);
- EXPECT_EQ(QuicString(512, 'b'),
- QuicString(reinterpret_cast<const char*>(iovs1[3].iov_base),
- iovs1[3].iov_len));
+ EXPECT_EQ(std::string(512, 'b'),
+ std::string(reinterpret_cast<const char*>(iovs1[3].iov_base),
+ iovs1[3].iov_len));
}
TEST_F(QuicStreamSequencerBufferTest, GetReadableRegionEmpty) {
@@ -572,7 +572,7 @@
TEST_F(QuicStreamSequencerBufferTest, GetReadableRegionBeforeGap) {
// Write into [1, 1024).
- QuicString source(1023, 'a');
+ std::string source(1023, 'a');
size_t written;
buffer_->OnStreamData(1, source, &written, &error_details_);
// GetReadableRegion should return false because range [0,1) hasn't been
@@ -583,7 +583,7 @@
TEST_F(QuicStreamSequencerBufferTest, GetReadableRegionTillEndOfBlock) {
// Write into [0, kBlockSizeBytes + 1) and then read out [0, 256)
- QuicString source(kBlockSizeBytes + 1, 'a');
+ std::string source(kBlockSizeBytes + 1, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
char dest[256];
@@ -592,13 +592,13 @@
iovec iov;
EXPECT_TRUE(buffer_->GetReadableRegion(&iov));
EXPECT_EQ(
- QuicString(kBlockSizeBytes - 256, 'a'),
- QuicString(reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
+ std::string(kBlockSizeBytes - 256, 'a'),
+ std::string(reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
}
TEST_F(QuicStreamSequencerBufferTest, GetReadableRegionTillGap) {
// Write into [0, kBlockSizeBytes - 1) and then read out [0, 256)
- QuicString source(kBlockSizeBytes - 1, 'a');
+ std::string source(kBlockSizeBytes - 1, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
char dest[256];
@@ -607,8 +607,8 @@
iovec iov;
EXPECT_TRUE(buffer_->GetReadableRegion(&iov));
EXPECT_EQ(
- QuicString(kBlockSizeBytes - 1 - 256, 'a'),
- QuicString(reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
+ std::string(kBlockSizeBytes - 1 - 256, 'a'),
+ std::string(reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
}
TEST_F(QuicStreamSequencerBufferTest, PrefetchEmptyBuffer) {
@@ -617,89 +617,89 @@
}
TEST_F(QuicStreamSequencerBufferTest, PrefetchInitialBuffer) {
- QuicString source(kBlockSizeBytes, 'a');
+ std::string source(kBlockSizeBytes, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
iovec iov;
EXPECT_TRUE(buffer_->PrefetchNextRegion(&iov));
- EXPECT_EQ(source, QuicString(reinterpret_cast<const char*>(iov.iov_base),
- iov.iov_len));
+ EXPECT_EQ(source, std::string(reinterpret_cast<const char*>(iov.iov_base),
+ iov.iov_len));
}
TEST_F(QuicStreamSequencerBufferTest, PrefetchBufferWithOffset) {
- QuicString source(1024, 'a');
+ std::string source(1024, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
iovec iov;
EXPECT_TRUE(buffer_->PrefetchNextRegion(&iov));
- EXPECT_EQ(source, QuicString(reinterpret_cast<const char*>(iov.iov_base),
- iov.iov_len));
+ EXPECT_EQ(source, std::string(reinterpret_cast<const char*>(iov.iov_base),
+ iov.iov_len));
// The second frame goes into the same bucket.
- QuicString source2(800, 'a');
+ std::string source2(800, 'a');
buffer_->OnStreamData(1024, source2, &written, &error_details_);
EXPECT_TRUE(buffer_->PrefetchNextRegion(&iov));
- EXPECT_EQ(source2, QuicString(reinterpret_cast<const char*>(iov.iov_base),
- iov.iov_len));
+ EXPECT_EQ(source2, std::string(reinterpret_cast<const char*>(iov.iov_base),
+ iov.iov_len));
}
TEST_F(QuicStreamSequencerBufferTest, PrefetchBufferWithMultipleBucket) {
const size_t data_size = 1024;
- QuicString source(data_size, 'a');
+ std::string source(data_size, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
iovec iov;
EXPECT_TRUE(buffer_->PrefetchNextRegion(&iov));
- EXPECT_EQ(source, QuicString(reinterpret_cast<const char*>(iov.iov_base),
- iov.iov_len));
- QuicString source2(kBlockSizeBytes, 'b');
+ EXPECT_EQ(source, std::string(reinterpret_cast<const char*>(iov.iov_base),
+ iov.iov_len));
+ std::string source2(kBlockSizeBytes, 'b');
buffer_->OnStreamData(data_size, source2, &written, &error_details_);
EXPECT_TRUE(buffer_->PrefetchNextRegion(&iov));
EXPECT_EQ(
- QuicString(kBlockSizeBytes - data_size, 'b'),
- QuicString(reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
+ std::string(kBlockSizeBytes - data_size, 'b'),
+ std::string(reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
EXPECT_TRUE(buffer_->PrefetchNextRegion(&iov));
EXPECT_EQ(
- QuicString(data_size, 'b'),
- QuicString(reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
+ std::string(data_size, 'b'),
+ std::string(reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
}
TEST_F(QuicStreamSequencerBufferTest, PrefetchBufferAfterBlockRetired) {
- QuicString source(kBlockSizeBytes, 'a');
+ std::string source(kBlockSizeBytes, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
iovec iov;
EXPECT_TRUE(buffer_->PrefetchNextRegion(&iov));
- EXPECT_EQ(source, QuicString(reinterpret_cast<const char*>(iov.iov_base),
- iov.iov_len));
+ EXPECT_EQ(source, std::string(reinterpret_cast<const char*>(iov.iov_base),
+ iov.iov_len));
// Read the whole block so it's retired.
char dest[kBlockSizeBytes];
helper_->Read(dest, kBlockSizeBytes);
- QuicString source2(300, 'b');
+ std::string source2(300, 'b');
buffer_->OnStreamData(kBlockSizeBytes, source2, &written, &error_details_);
EXPECT_TRUE(buffer_->PrefetchNextRegion(&iov));
- EXPECT_EQ(source2, QuicString(reinterpret_cast<const char*>(iov.iov_base),
- iov.iov_len));
+ EXPECT_EQ(source2, std::string(reinterpret_cast<const char*>(iov.iov_base),
+ iov.iov_len));
}
TEST_F(QuicStreamSequencerBufferTest, PrefetchContinously) {
- QuicString source(kBlockSizeBytes, 'a');
+ std::string source(kBlockSizeBytes, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
iovec iov;
EXPECT_TRUE(buffer_->PrefetchNextRegion(&iov));
- EXPECT_EQ(source, QuicString(reinterpret_cast<const char*>(iov.iov_base),
- iov.iov_len));
- QuicString source2(kBlockSizeBytes, 'b');
+ EXPECT_EQ(source, std::string(reinterpret_cast<const char*>(iov.iov_base),
+ iov.iov_len));
+ std::string source2(kBlockSizeBytes, 'b');
buffer_->OnStreamData(kBlockSizeBytes, source2, &written, &error_details_);
EXPECT_TRUE(buffer_->PrefetchNextRegion(&iov));
- EXPECT_EQ(source2, QuicString(reinterpret_cast<const char*>(iov.iov_base),
- iov.iov_len));
+ EXPECT_EQ(source2, std::string(reinterpret_cast<const char*>(iov.iov_base),
+ iov.iov_len));
}
TEST_F(QuicStreamSequencerBufferTest, ConsumeMoreThanPrefetch) {
- QuicString source(100, 'a');
+ std::string source(100, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
char dest[30];
@@ -707,32 +707,32 @@
iovec iov;
EXPECT_TRUE(buffer_->PrefetchNextRegion(&iov));
EXPECT_EQ(
- QuicString(70, 'a'),
- QuicString(reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
- QuicString source2(100, 'b');
+ std::string(70, 'a'),
+ std::string(reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
+ std::string source2(100, 'b');
buffer_->OnStreamData(100, source2, &written, &error_details_);
buffer_->MarkConsumed(100);
EXPECT_TRUE(buffer_->PrefetchNextRegion(&iov));
EXPECT_EQ(
- QuicString(70, 'b'),
- QuicString(reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
+ std::string(70, 'b'),
+ std::string(reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
}
TEST_F(QuicStreamSequencerBufferTest, PrefetchMoreThanBufferHas) {
- QuicString source(100, 'a');
+ std::string source(100, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
iovec iov;
EXPECT_TRUE(buffer_->PrefetchNextRegion(&iov));
EXPECT_EQ(
- QuicString(100, 'a'),
- QuicString(reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
+ std::string(100, 'a'),
+ std::string(reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
EXPECT_FALSE(buffer_->PrefetchNextRegion(&iov));
}
TEST_F(QuicStreamSequencerBufferTest, MarkConsumedInOneBlock) {
// Write into [0, 1024) and then read out [0, 256)
- QuicString source(1024, 'a');
+ std::string source(1024, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
char dest[256];
@@ -748,7 +748,7 @@
TEST_F(QuicStreamSequencerBufferTest, MarkConsumedNotEnoughBytes) {
// Write into [0, 1024) and then read out [0, 256)
- QuicString source(1024, 'a');
+ std::string source(1024, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
char dest[256];
@@ -768,7 +768,7 @@
TEST_F(QuicStreamSequencerBufferTest, MarkConsumedAcrossBlock) {
// Write into [0, 2 * kBlockSizeBytes + 1024) and then read out [0, 1024)
- QuicString source(2 * kBlockSizeBytes + 1024, 'a');
+ std::string source(2 * kBlockSizeBytes + 1024, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
char dest[1024];
@@ -783,12 +783,12 @@
TEST_F(QuicStreamSequencerBufferTest, MarkConsumedAcrossEnd) {
// Write into [0, 2.5 * kBlockSizeBytes - 1024) and then read out [0, 1024)
// and then append 1024 + 512 bytes.
- QuicString source(2.5 * kBlockSizeBytes - 1024, 'a');
+ std::string source(2.5 * kBlockSizeBytes - 1024, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
char dest[1024];
helper_->Read(dest, 1024);
- source = QuicString(1024 + 512, 'b');
+ source = std::string(1024 + 512, 'b');
buffer_->OnStreamData(2.5 * kBlockSizeBytes - 1024, source, &written,
&error_details_);
EXPECT_EQ(1024u, buffer_->BytesConsumed());
@@ -809,14 +809,14 @@
TEST_F(QuicStreamSequencerBufferTest, FlushBufferedFrames) {
// Write into [0, 2.5 * kBlockSizeBytes - 1024) and then read out [0, 1024).
- QuicString source(max_capacity_bytes_ - 1024, 'a');
+ std::string source(max_capacity_bytes_ - 1024, 'a');
size_t written;
buffer_->OnStreamData(0, source, &written, &error_details_);
char dest[1024];
helper_->Read(dest, 1024);
EXPECT_EQ(1024u, buffer_->BytesConsumed());
// Write [1024, 512) to the physical beginning.
- source = QuicString(512, 'b');
+ source = std::string(512, 'b');
buffer_->OnStreamData(max_capacity_bytes_, source, &written, &error_details_);
EXPECT_EQ(512u, written);
EXPECT_EQ(max_capacity_bytes_ - 1024 + 512, buffer_->FlushBufferedFrames());
diff --git a/quic/core/quic_stream_sequencer_test.cc b/quic/core/quic_stream_sequencer_test.cc
index 989b0f6..a99bd28 100644
--- a/quic/core/quic_stream_sequencer_test.cc
+++ b/quic/core/quic_stream_sequencer_test.cc
@@ -33,7 +33,7 @@
MOCK_METHOD0(OnFinRead, void());
MOCK_METHOD0(OnDataAvailable, void());
MOCK_METHOD2(CloseConnectionWithDetails,
- void(QuicErrorCode error, const QuicString& details));
+ void(QuicErrorCode error, const std::string& details));
MOCK_METHOD1(Reset, void(QuicRstStreamErrorCode error));
MOCK_METHOD0(OnCanWrite, void());
MOCK_METHOD1(AddBytesConsumed, void(QuicByteCount bytes));
@@ -70,28 +70,28 @@
: stream_(), sequencer_(new QuicStreamSequencer(&stream_)) {}
// Verify that the data in first region match with the expected[0].
- bool VerifyReadableRegion(const std::vector<QuicString>& expected) {
+ bool VerifyReadableRegion(const std::vector<std::string>& expected) {
return VerifyReadableRegion(*sequencer_, expected);
}
// Verify that the data in each of currently readable regions match with each
// item given in |expected|.
- bool VerifyReadableRegions(const std::vector<QuicString>& expected) {
+ bool VerifyReadableRegions(const std::vector<std::string>& expected) {
return VerifyReadableRegions(*sequencer_, expected);
}
bool VerifyIovecs(iovec* iovecs,
size_t num_iovecs,
- const std::vector<QuicString>& expected) {
+ const std::vector<std::string>& expected) {
return VerifyIovecs(*sequencer_, iovecs, num_iovecs, expected);
}
bool VerifyReadableRegion(const QuicStreamSequencer& sequencer,
- const std::vector<QuicString>& expected) {
+ const std::vector<std::string>& expected) {
iovec iovecs[1];
if (sequencer.GetReadableRegions(iovecs, 1)) {
return (VerifyIovecs(sequencer, iovecs, 1,
- std::vector<QuicString>{expected[0]}));
+ std::vector<std::string>{expected[0]}));
}
return false;
}
@@ -99,7 +99,7 @@
// Verify that the data in each of currently readable regions match with each
// item given in |expected|.
bool VerifyReadableRegions(const QuicStreamSequencer& sequencer,
- const std::vector<QuicString>& expected) {
+ const std::vector<std::string>& expected) {
iovec iovecs[5];
size_t num_iovecs =
sequencer.GetReadableRegions(iovecs, QUIC_ARRAYSIZE(iovecs));
@@ -110,7 +110,7 @@
bool VerifyIovecs(const QuicStreamSequencer& sequencer,
iovec* iovecs,
size_t num_iovecs,
- const std::vector<QuicString>& expected) {
+ const std::vector<std::string>& expected) {
int start_position = 0;
for (size_t i = 0; i < num_iovecs; ++i) {
if (!VerifyIovec(iovecs[i],
@@ -388,7 +388,7 @@
class QuicSequencerRandomTest : public QuicStreamSequencerTest {
public:
- typedef std::pair<int, QuicString> Frame;
+ typedef std::pair<int, std::string> Frame;
typedef std::vector<Frame> FrameList;
void CreateFrames() {
@@ -398,7 +398,7 @@
int size = std::min(OneToN(6), remaining_payload);
int index = payload_size - remaining_payload;
list_.push_back(
- std::make_pair(index, QuicString(kPayload + index, size)));
+ std::make_pair(index, std::string(kPayload + index, size)));
remaining_payload -= size;
}
}
@@ -424,9 +424,9 @@
output_.append(output, bytes_read);
}
- QuicString output_;
+ std::string output_;
// Data which peek at using GetReadableRegion if we back up.
- QuicString peeked_;
+ std::string peeked_;
SimpleRandom random_;
FrameList list_;
};
@@ -507,8 +507,8 @@
ASSERT_EQ(output_.size(), peeked_.size());
}
}
- EXPECT_EQ(QuicString(kPayload), output_);
- EXPECT_EQ(QuicString(kPayload), peeked_);
+ EXPECT_EQ(std::string(kPayload), output_);
+ EXPECT_EQ(std::string(kPayload), peeked_);
EXPECT_EQ(QUIC_ARRAYSIZE(kPayload) - 1, total_bytes_consumed);
}
@@ -525,14 +525,14 @@
EXPECT_EQ(9u, sequencer_->NumBytesBuffered());
// Peek into the data.
- std::vector<QuicString> expected = {"abcdefghi"};
+ std::vector<std::string> expected = {"abcdefghi"};
ASSERT_TRUE(VerifyReadableRegions(expected));
// Consume 1 byte.
EXPECT_CALL(stream_, AddBytesConsumed(1));
sequencer_->MarkConsumed(1);
// Verify data.
- std::vector<QuicString> expected2 = {"bcdefghi"};
+ std::vector<std::string> expected2 = {"bcdefghi"};
ASSERT_TRUE(VerifyReadableRegions(expected2));
EXPECT_EQ(8u, sequencer_->NumBytesBuffered());
@@ -540,7 +540,7 @@
EXPECT_CALL(stream_, AddBytesConsumed(2));
sequencer_->MarkConsumed(2);
// Verify data.
- std::vector<QuicString> expected3 = {"defghi"};
+ std::vector<std::string> expected3 = {"defghi"};
ASSERT_TRUE(VerifyReadableRegions(expected3));
EXPECT_EQ(6u, sequencer_->NumBytesBuffered());
@@ -548,7 +548,7 @@
EXPECT_CALL(stream_, AddBytesConsumed(5));
sequencer_->MarkConsumed(5);
// Verify data.
- std::vector<QuicString> expected4{"i"};
+ std::vector<std::string> expected4{"i"};
ASSERT_TRUE(VerifyReadableRegions(expected4));
EXPECT_EQ(1u, sequencer_->NumBytesBuffered());
}
@@ -561,7 +561,7 @@
// Peek into the data. Only the first chunk should be readable because of the
// missing data.
- std::vector<QuicString> expected{"abc"};
+ std::vector<std::string> expected{"abc"};
ASSERT_TRUE(VerifyReadableRegions(expected));
// Now, attempt to mark consumed more data than was readable and expect the
@@ -581,7 +581,7 @@
// Missing packet: 6, ghi.
OnFrame(9, "jkl");
- std::vector<QuicString> expected = {"abcdef"};
+ std::vector<std::string> expected = {"abcdef"};
ASSERT_TRUE(VerifyReadableRegions(expected));
EXPECT_CALL(stream_, AddBytesConsumed(6));
@@ -600,7 +600,7 @@
EXPECT_EQ(9u, sequencer_->NumBytesBuffered());
// Peek into the data.
- std::vector<QuicString> expected = {"abcdefghi"};
+ std::vector<std::string> expected = {"abcdefghi"};
ASSERT_TRUE(VerifyReadableRegions(expected));
QuicStreamSequencer sequencer2(std::move(*sequencer_));
@@ -624,7 +624,7 @@
TEST_F(QuicStreamSequencerTest, DataAvailableOnOverlappingFrames) {
QuicStreamId id = 1;
- const QuicString data(1000, '.');
+ const std::string data(1000, '.');
// Received [0, 1000).
QuicStreamFrame frame1(id, false, 0, data);
@@ -693,7 +693,7 @@
TEST_F(QuicStreamSequencerTest, ReadSingleFrame) {
EXPECT_CALL(stream_, OnDataAvailable());
OnFrame(0u, "abc");
- QuicString actual;
+ std::string actual;
EXPECT_CALL(stream_, AddBytesConsumed(3));
sequencer_->Read(&actual);
EXPECT_EQ("abc", actual);
@@ -706,7 +706,7 @@
OnFrame(3u, "def");
OnFrame(6u, "ghi");
OnFrame(10u, "xyz"); // Byte 9 is missing.
- QuicString actual;
+ std::string actual;
EXPECT_CALL(stream_, AddBytesConsumed(9));
sequencer_->Read(&actual);
EXPECT_EQ("abcdefghi", actual);
@@ -717,7 +717,7 @@
EXPECT_CALL(stream_, OnDataAvailable());
OnFrame(0u, "def");
OnFrame(3u, "ghi");
- QuicString actual = "abc";
+ std::string actual = "abc";
EXPECT_CALL(stream_, AddBytesConsumed(6));
sequencer_->Read(&actual);
EXPECT_EQ("abcdefghi", actual);
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index d019f71..34f9597 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -66,7 +66,7 @@
using QuicStream::WritevData;
private:
- QuicString data_;
+ std::string data_;
};
class QuicStreamTestBase : public QuicTestWithParam<ParsedQuicVersion> {
@@ -160,7 +160,8 @@
// Index value of 1 has the test run with supported-version[1], which is some
// version OTHER than 99.
INSTANTIATE_TEST_SUITE_P(
- QuicStreamTests, QuicStreamTest,
+ QuicStreamTests,
+ QuicStreamTest,
::testing::ValuesIn(ParsedVersionOfIndex(AllSupportedVersions(), 1)));
// Make a parameterized version of the QuicStreamTest for those tests
@@ -389,7 +390,7 @@
TEST_P(QuicStreamTest, WriteOrBufferDataReachStreamLimit) {
Initialize();
- QuicString data("aaaaa");
+ std::string data("aaaaa");
QuicStreamPeer::SetStreamBytesWritten(kMaxStreamLength - data.length(),
stream_);
EXPECT_CALL(*session_, WritevData(_, _, _, _, _))
@@ -574,7 +575,7 @@
.Times(AtLeast(1))
.WillRepeatedly(Invoke(this, &QuicStreamTest::ClearControlFrame));
- QuicString data(1000, 'x');
+ std::string data(1000, 'x');
for (QuicStreamOffset offset = 0;
offset < 2 * kInitialStreamFlowControlWindowForTest;
offset += data.length()) {
@@ -968,7 +969,7 @@
set_initial_flow_control_window_bytes(500000);
Initialize();
- QuicString data(1024, 'a');
+ std::string data(1024, 'a');
EXPECT_TRUE(stream_->CanWriteNewData());
// Testing WriteOrBufferData.
@@ -1073,7 +1074,7 @@
TEST_P(QuicStreamTest, WritevDataReachStreamLimit) {
Initialize();
- QuicString data("aaaaa");
+ std::string data("aaaaa");
QuicStreamPeer::SetStreamBytesWritten(kMaxStreamLength - data.length(),
stream_);
EXPECT_CALL(*session_, WritevData(_, _, _, _, _))
@@ -1339,7 +1340,7 @@
.WillRepeatedly(Invoke(MockQuicSession::ConsumeData));
EXPECT_CALL(*connection_, SendControlFrame(_))
.WillOnce(Invoke(this, &QuicStreamTest::ClearControlFrame));
- QuicString data(1024, '.');
+ std::string data(1024, '.');
stream_->WriteOrBufferData(data, false, nullptr);
EXPECT_FALSE(HasWriteBlockedStreams());
@@ -1360,7 +1361,7 @@
set_initial_flow_control_window_bytes(kSmallWindow);
Initialize();
- QuicString data(kSmallWindow, '.');
+ std::string data(kSmallWindow, '.');
EXPECT_CALL(*session_, WritevData(_, _, _, _, _))
.WillRepeatedly(Invoke(MockQuicSession::ConsumeData));
EXPECT_CALL(*connection_, SendControlFrame(_))
@@ -1419,7 +1420,7 @@
EXPECT_CALL(*session_, WritevData(_, stream_->id(), 200, 0, FIN))
.WillOnce(Invoke(MockQuicSession::ConsumeData));
- QuicString body(200, 'a');
+ std::string body(200, 'a');
stream_->WriteOrBufferData(body, true, nullptr);
// Set TTL to be 1 s.
@@ -1443,7 +1444,7 @@
EXPECT_CALL(*session_, WritevData(_, stream_->id(), 200, 0, FIN))
.WillOnce(Invoke(MockQuicSession::ConsumeData));
- QuicString body(200, 'a');
+ std::string body(200, 'a');
stream_->WriteOrBufferData(body, true, nullptr);
// Set TTL to be 1 s.
diff --git a/quic/core/quic_tag.cc b/quic/core/quic_tag.cc
index 7c9c329..eebe744 100644
--- a/quic/core/quic_tag.cc
+++ b/quic/core/quic_tag.cc
@@ -34,7 +34,7 @@
return false;
}
-QuicString QuicTagToString(QuicTag tag) {
+std::string QuicTagToString(QuicTag tag) {
char chars[sizeof tag];
bool ascii = true;
const QuicTag orig_tag = tag;
@@ -53,7 +53,7 @@
}
if (ascii) {
- return QuicString(chars, sizeof(chars));
+ return std::string(chars, sizeof(chars));
}
return QuicTextUtils::Uint64ToString(orig_tag);
diff --git a/quic/core/quic_tag.h b/quic/core/quic_tag.h
index 1808d9d..03763a7 100644
--- a/quic/core/quic_tag.h
+++ b/quic/core/quic_tag.h
@@ -22,7 +22,7 @@
// just a mnemonic for the value 0x504d5845 (little-endian version of the ASCII
// string E X M P).
typedef uint32_t QuicTag;
-typedef std::map<QuicTag, QuicString> QuicTagValueMap;
+typedef std::map<QuicTag, std::string> QuicTagValueMap;
typedef std::vector<QuicTag> QuicTagVector;
// MakeQuicTag returns a value given the four bytes. For example:
@@ -46,7 +46,7 @@
// A utility function that converts a tag to a string. It will try to maintain
// the human friendly name if possible (i.e. kABCD -> "ABCD"), or will just
// treat it as a number if not.
-QUIC_EXPORT_PRIVATE QuicString QuicTagToString(QuicTag tag);
+QUIC_EXPORT_PRIVATE std::string QuicTagToString(QuicTag tag);
} // namespace quic
diff --git a/quic/core/quic_time.cc b/quic/core/quic_time.cc
index 92a3eec..e3df0b9 100644
--- a/quic/core/quic_time.cc
+++ b/quic/core/quic_time.cc
@@ -13,7 +13,7 @@
namespace quic {
-QuicString QuicTime::Delta::ToDebugValue() const {
+std::string QuicTime::Delta::ToDebugValue() const {
const int64_t one_ms = 1000;
const int64_t one_s = 1000 * one_ms;
diff --git a/quic/core/quic_time.h b/quic/core/quic_time.h
index 6bd3f68..9624b6f 100644
--- a/quic/core/quic_time.h
+++ b/quic/core/quic_time.h
@@ -75,7 +75,7 @@
return time_offset_ == kQuicInfiniteTimeUs;
}
- QuicString ToDebugValue() const;
+ std::string ToDebugValue() const;
private:
friend inline bool operator==(QuicTime::Delta lhs, QuicTime::Delta rhs);
diff --git a/quic/core/quic_time_wait_list_manager.h b/quic/core/quic_time_wait_list_manager.h
index 74630ad..db1d1f7 100644
--- a/quic/core/quic_time_wait_list_manager.h
+++ b/quic/core/quic_time_wait_list_manager.h
@@ -144,7 +144,7 @@
bool ietf_quic,
std::unique_ptr<QuicPerPacketContext> packet_context);
- virtual void GetEndpointId(QuicString* endpoint_id) {}
+ virtual void GetEndpointId(std::string* endpoint_id) {}
// Returns a stateless reset token which will be included in the public reset
// packet.
diff --git a/quic/core/quic_trace_visitor.cc b/quic/core/quic_trace_visitor.cc
index ba2ed7f..3785d53 100644
--- a/quic/core/quic_trace_visitor.cc
+++ b/quic/core/quic_trace_visitor.cc
@@ -26,8 +26,8 @@
QuicTraceVisitor::QuicTraceVisitor(const QuicConnection* connection)
: connection_(connection),
start_time_(connection_->clock()->ApproximateNow()) {
- QuicString binary_connection_id(connection->connection_id().data(),
- connection->connection_id().length());
+ std::string binary_connection_id(connection->connection_id().data(),
+ connection->connection_id().length());
// We assume that the connection ID in gQUIC is equivalent to the
// server-chosen client-selected ID.
switch (connection->perspective()) {
@@ -263,7 +263,7 @@
void QuicTraceVisitor::OnSuccessfulVersionNegotiation(
const ParsedQuicVersion& version) {
uint32_t tag = QuicEndian::HostToNet32(CreateQuicVersionLabel(version));
- QuicString binary_tag(reinterpret_cast<const char*>(&tag), sizeof(tag));
+ std::string binary_tag(reinterpret_cast<const char*>(&tag), sizeof(tag));
trace_.set_protocol_version(binary_tag);
}
diff --git a/quic/core/quic_trace_visitor_test.cc b/quic/core/quic_trace_visitor_test.cc
index 008026d..ee179bb 100644
--- a/quic/core/quic_trace_visitor_test.cc
+++ b/quic/core/quic_trace_visitor_test.cc
@@ -76,12 +76,12 @@
TEST_F(QuicTraceVisitorTest, ConnectionId) {
char expected_cid[] = {0, 0, 0, 0, 0, 0, 0, 42};
- EXPECT_EQ(QuicString(expected_cid, sizeof(expected_cid)),
+ EXPECT_EQ(std::string(expected_cid, sizeof(expected_cid)),
trace_.destination_connection_id());
}
TEST_F(QuicTraceVisitorTest, Version) {
- QuicString version = trace_.protocol_version();
+ std::string version = trace_.protocol_version();
ASSERT_EQ(4u, version.size());
EXPECT_EQ('Q', version[0]);
}
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index d83db1c..10854bf 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -165,7 +165,7 @@
return "INVALID_TRANSMISSION_TYPE";
}
-QuicString QuicUtils::AddressChangeTypeToString(AddressChangeType type) {
+std::string QuicUtils::AddressChangeTypeToString(AddressChangeType type) {
switch (type) {
RETURN_STRING_LITERAL(NO_CHANGE);
RETURN_STRING_LITERAL(PORT_CHANGE);
diff --git a/quic/core/quic_utils.h b/quic/core/quic_utils.h
index 28ea15b..3ef4788 100644
--- a/quic/core/quic_utils.h
+++ b/quic/core/quic_utils.h
@@ -57,7 +57,7 @@
static const char* TransmissionTypeToString(TransmissionType type);
// Returns AddressChangeType as a string.
- static QuicString AddressChangeTypeToString(AddressChangeType type);
+ static std::string AddressChangeTypeToString(AddressChangeType type);
// Returns SentPacketState as a char*.
static const char* SentPacketStateToString(SentPacketState state);
diff --git a/quic/core/quic_utils_test.cc b/quic/core/quic_utils_test.cc
index de4c76b..f88a34a 100644
--- a/quic/core/quic_utils_test.cc
+++ b/quic/core/quic_utils_test.cc
@@ -18,11 +18,11 @@
class QuicUtilsTest : public QuicTest {};
TEST_F(QuicUtilsTest, DetermineAddressChangeType) {
- const QuicString kIPv4String1 = "1.2.3.4";
- const QuicString kIPv4String2 = "1.2.3.5";
- const QuicString kIPv4String3 = "1.1.3.5";
- const QuicString kIPv6String1 = "2001:700:300:1800::f";
- const QuicString kIPv6String2 = "2001:700:300:1800:1:1:1:f";
+ const std::string kIPv4String1 = "1.2.3.4";
+ const std::string kIPv4String2 = "1.2.3.5";
+ const std::string kIPv4String3 = "1.1.3.5";
+ const std::string kIPv6String1 = "2001:700:300:1800::f";
+ const std::string kIPv6String2 = "2001:700:300:1800:1:1:1:f";
QuicSocketAddress old_address;
QuicSocketAddress new_address;
QuicIpAddress address;
@@ -168,11 +168,11 @@
MockRandom random(33);
QuicConnectionId connection_id = QuicUtils::CreateRandomConnectionId(&random);
EXPECT_EQ(connection_id.length(), sizeof(uint64_t));
- char connection_id_bytes[sizeof(uint64_t)];
- random.RandBytes(connection_id_bytes, QUIC_ARRAYSIZE(connection_id_bytes));
- EXPECT_EQ(connection_id,
- QuicConnectionId(static_cast<char*>(connection_id_bytes),
- QUIC_ARRAYSIZE(connection_id_bytes)));
+ char connection_id_bytes[sizeof(uint64_t)];
+ random.RandBytes(connection_id_bytes, QUIC_ARRAYSIZE(connection_id_bytes));
+ EXPECT_EQ(connection_id,
+ QuicConnectionId(static_cast<char*>(connection_id_bytes),
+ QUIC_ARRAYSIZE(connection_id_bytes)));
EXPECT_NE(connection_id, EmptyQuicConnectionId());
EXPECT_NE(connection_id, TestConnectionId());
EXPECT_NE(connection_id, TestConnectionId(1));
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index efc823d..7ea441a 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -243,15 +243,15 @@
ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, transport_version));
}
-QuicString QuicVersionLabelToString(QuicVersionLabel version_label) {
+std::string QuicVersionLabelToString(QuicVersionLabel version_label) {
return QuicTagToString(QuicEndian::HostToNet32(version_label));
}
-QuicString QuicVersionLabelVectorToString(
+std::string QuicVersionLabelVectorToString(
const QuicVersionLabelVector& version_labels,
- const QuicString& separator,
+ const std::string& separator,
size_t skip_after_nth_version) {
- QuicString result;
+ std::string result;
for (size_t i = 0; i < version_labels.size(); ++i) {
if (i != 0) {
result.append(separator);
@@ -280,7 +280,7 @@
case x: \
return #x
-QuicString QuicVersionToString(QuicTransportVersion transport_version) {
+std::string QuicVersionToString(QuicTransportVersion transport_version) {
switch (transport_version) {
RETURN_STRING_LITERAL(QUIC_VERSION_39);
RETURN_STRING_LITERAL(QUIC_VERSION_43);
@@ -293,13 +293,13 @@
}
}
-QuicString ParsedQuicVersionToString(ParsedQuicVersion version) {
+std::string ParsedQuicVersionToString(ParsedQuicVersion version) {
return QuicVersionLabelToString(CreateQuicVersionLabel(version));
}
-QuicString QuicTransportVersionVectorToString(
+std::string QuicTransportVersionVectorToString(
const QuicTransportVersionVector& versions) {
- QuicString result = "";
+ std::string result = "";
for (size_t i = 0; i < versions.size(); ++i) {
if (i != 0) {
result.append(",");
@@ -309,11 +309,11 @@
return result;
}
-QuicString ParsedQuicVersionVectorToString(
+std::string ParsedQuicVersionVectorToString(
const ParsedQuicVersionVector& versions,
- const QuicString& separator,
+ const std::string& separator,
size_t skip_after_nth_version) {
- QuicString result;
+ std::string result;
for (size_t i = 0; i < versions.size(); ++i) {
if (i != 0) {
result.append(separator);
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index c0fa34a..2825c9f 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -244,20 +244,20 @@
QuicVersionToQuicVersionLabel(QuicTransportVersion transport_version);
// Helper function which translates from a QuicVersionLabel to a string.
-QUIC_EXPORT_PRIVATE QuicString
-QuicVersionLabelToString(QuicVersionLabel version_label);
+QUIC_EXPORT_PRIVATE std::string QuicVersionLabelToString(
+ QuicVersionLabel version_label);
// Returns |separator|-separated list of string representations of
// QuicVersionLabel values in the supplied |version_labels| vector. The values
// after the (0-based) |skip_after_nth_version|'th are skipped.
-QUIC_EXPORT_PRIVATE QuicString
-QuicVersionLabelVectorToString(const QuicVersionLabelVector& version_labels,
- const QuicString& separator,
- size_t skip_after_nth_version);
+QUIC_EXPORT_PRIVATE std::string QuicVersionLabelVectorToString(
+ const QuicVersionLabelVector& version_labels,
+ const std::string& separator,
+ size_t skip_after_nth_version);
// Returns comma separated list of string representations of QuicVersionLabel
// values in the supplied |version_labels| vector.
-QUIC_EXPORT_PRIVATE inline QuicString QuicVersionLabelVectorToString(
+QUIC_EXPORT_PRIVATE inline std::string QuicVersionLabelVectorToString(
const QuicVersionLabelVector& version_labels) {
return QuicVersionLabelVectorToString(version_labels, ",",
std::numeric_limits<size_t>::max());
@@ -275,35 +275,35 @@
// Helper function which translates from a QuicTransportVersion to a string.
// Returns strings corresponding to enum names (e.g. QUIC_VERSION_6).
-QUIC_EXPORT_PRIVATE QuicString
-QuicVersionToString(QuicTransportVersion transport_version);
+QUIC_EXPORT_PRIVATE std::string QuicVersionToString(
+ QuicTransportVersion transport_version);
// Helper function which translates from a ParsedQuicVersion to a string.
// Returns strings corresponding to the on-the-wire tag.
-QUIC_EXPORT_PRIVATE QuicString
-ParsedQuicVersionToString(ParsedQuicVersion version);
+QUIC_EXPORT_PRIVATE std::string ParsedQuicVersionToString(
+ ParsedQuicVersion version);
// Returns comma separated list of string representations of
// QuicTransportVersion enum values in the supplied |versions| vector.
-QUIC_EXPORT_PRIVATE QuicString
-QuicTransportVersionVectorToString(const QuicTransportVersionVector& versions);
+QUIC_EXPORT_PRIVATE std::string QuicTransportVersionVectorToString(
+ const QuicTransportVersionVector& versions);
// Returns comma separated list of string representations of ParsedQuicVersion
// values in the supplied |versions| vector.
-QUIC_EXPORT_PRIVATE QuicString
-ParsedQuicVersionVectorToString(const ParsedQuicVersionVector& versions);
+QUIC_EXPORT_PRIVATE std::string ParsedQuicVersionVectorToString(
+ const ParsedQuicVersionVector& versions);
// Returns |separator|-separated list of string representations of
// ParsedQuicVersion values in the supplied |versions| vector. The values after
// the (0-based) |skip_after_nth_version|'th are skipped.
-QUIC_EXPORT_PRIVATE QuicString
-ParsedQuicVersionVectorToString(const ParsedQuicVersionVector& versions,
- const QuicString& separator,
- size_t skip_after_nth_version);
+QUIC_EXPORT_PRIVATE std::string ParsedQuicVersionVectorToString(
+ const ParsedQuicVersionVector& versions,
+ const std::string& separator,
+ size_t skip_after_nth_version);
// Returns comma separated list of string representations of ParsedQuicVersion
// values in the supplied |versions| vector.
-QUIC_EXPORT_PRIVATE inline QuicString ParsedQuicVersionVectorToString(
+QUIC_EXPORT_PRIVATE inline std::string ParsedQuicVersionVectorToString(
const ParsedQuicVersionVector& versions) {
return ParsedQuicVersionVectorToString(versions, ",",
std::numeric_limits<size_t>::max());
diff --git a/quic/core/stateless_rejector.cc b/quic/core/stateless_rejector.cc
index 3cf30df..24750d7 100644
--- a/quic/core/stateless_rejector.cc
+++ b/quic/core/stateless_rejector.cc
@@ -104,7 +104,7 @@
: rejector_(std::move(rejector)), done_cb_(std::move(done_cb)) {}
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 */)
@@ -140,7 +140,7 @@
void StatelessRejector::ProcessClientHelloDone(
QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
std::unique_ptr<CryptoHandshakeMessage> message,
std::unique_ptr<StatelessRejector> rejector,
std::unique_ptr<StatelessRejector::ProcessDoneCallback> done_cb) {
diff --git a/quic/core/stateless_rejector.h b/quic/core/stateless_rejector.h
index d9ff94d..ae0d379 100644
--- a/quic/core/stateless_rejector.h
+++ b/quic/core/stateless_rejector.h
@@ -66,7 +66,7 @@
QuicErrorCode error() const { return error_; }
// Returns the error details when state() returns FAILED.
- QuicString error_details() const { return error_details_; }
+ std::string error_details() const { return error_details_; }
// Returns the connection ID.
QuicConnectionId connection_id() const { return connection_id_; }
@@ -91,14 +91,14 @@
void ProcessClientHelloDone(
QuicErrorCode error,
- const QuicString& error_details,
+ const std::string& error_details,
std::unique_ptr<CryptoHandshakeMessage> message,
std::unique_ptr<StatelessRejector> rejector,
std::unique_ptr<StatelessRejector::ProcessDoneCallback> done_cb);
State state_;
QuicErrorCode error_;
- QuicString error_details_;
+ std::string error_details_;
ParsedQuicVersion version_;
ParsedQuicVersionVector versions_;
QuicConnectionId connection_id_;
diff --git a/quic/core/stateless_rejector_test.cc b/quic/core/stateless_rejector_test.cc
index 19eef64..cf5cdd0 100644
--- a/quic/core/stateless_rejector_test.cc
+++ b/quic/core/stateless_rejector_test.cc
@@ -56,7 +56,8 @@
FlagsMode flags;
};
-QuicString TestParamToString(const testing::TestParamInfo<TestParams>& params) {
+std::string TestParamToString(
+ const testing::TestParamInfo<TestParams>& params) {
return QuicStrCat("v", ParsedQuicVersionToString(params.param.version), "_",
FlagsModeToString(params.param.flags));
}
@@ -122,7 +123,7 @@
"#" + QuicTextUtils::HexEncode(public_value, sizeof(public_value));
// Generate a client nonce.
- QuicString nonce;
+ std::string nonce;
CryptoUtils::GenerateNonce(
clock_.WallNow(), QuicRandom::GetInstance(),
QuicStringPiece(
@@ -135,7 +136,7 @@
SourceAddressTokens previous_tokens;
QuicIpAddress ip = QuicIpAddress::Loopback4();
MockRandom rand;
- QuicString stk = config_peer_.NewSourceAddressToken(
+ std::string stk = config_peer_.NewSourceAddressToken(
config_peer_.GetPrimaryConfig()->id, previous_tokens, ip, &rand,
clock_.WallNow(), nullptr);
stk_hex_ = "#" + QuicTextUtils::HexEncode(stk);
@@ -162,14 +163,15 @@
std::unique_ptr<StatelessRejector> rejector_;
// Values used in CHLO messages
- QuicString scid_hex_;
- QuicString nonc_hex_;
- QuicString pubs_hex_;
- QuicString ver_hex_;
- QuicString stk_hex_;
+ std::string scid_hex_;
+ std::string nonc_hex_;
+ std::string pubs_hex_;
+ std::string ver_hex_;
+ std::string stk_hex_;
};
-INSTANTIATE_TEST_SUITE_P(Flags, StatelessRejectorTest,
+INSTANTIATE_TEST_SUITE_P(Flags,
+ StatelessRejectorTest,
::testing::ValuesIn(GetTestParams()),
TestParamToString);
@@ -252,7 +254,7 @@
TEST_P(StatelessRejectorTest, AcceptChlo) {
const uint64_t xlct = crypto_test_utils::LeafCertHashForTesting();
- const QuicString xlct_hex =
+ const std::string xlct_hex =
"#" + QuicTextUtils::HexEncode(reinterpret_cast<const char*>(&xlct),
sizeof(xlct));
// clang-format off
diff --git a/quic/core/tls_client_handshaker.cc b/quic/core/tls_client_handshaker.cc
index f232dc3..6a76e08 100644
--- a/quic/core/tls_client_handshaker.cc
+++ b/quic/core/tls_client_handshaker.cc
@@ -20,7 +20,7 @@
void TlsClientHandshaker::ProofVerifierCallbackImpl::Run(
bool ok,
- const QuicString& error_details,
+ const std::string& error_details,
std::unique_ptr<ProofVerifyDetails>* details) {
if (parent_ == nullptr) {
return;
@@ -44,7 +44,7 @@
ProofVerifier* proof_verifier,
SSL_CTX* ssl_ctx,
std::unique_ptr<ProofVerifyContext> verify_context,
- const QuicString& user_agent_id)
+ const std::string& user_agent_id)
: TlsHandshaker(stream, session, ssl_ctx),
server_id_(server_id),
proof_verifier_(proof_verifier),
@@ -116,7 +116,7 @@
}
bool TlsClientHandshaker::ProcessTransportParameters(
- QuicString* error_details) {
+ std::string* error_details) {
TransportParameters params;
const uint8_t* param_bytes;
size_t param_bytes_len;
@@ -166,7 +166,7 @@
return false;
}
-QuicString TlsClientHandshaker::chlo_hash() const {
+std::string TlsClientHandshaker::chlo_hash() const {
return "";
}
@@ -229,7 +229,7 @@
}
void TlsClientHandshaker::CloseConnection(QuicErrorCode error,
- const QuicString& reason_phrase) {
+ const std::string& reason_phrase) {
state_ = STATE_CONNECTION_CLOSED;
stream()->CloseConnectionWithDetails(error, reason_phrase);
}
@@ -238,7 +238,7 @@
QUIC_LOG(INFO) << "Client: handshake finished";
state_ = STATE_HANDSHAKE_COMPLETE;
- QuicString error_details;
+ std::string error_details;
if (!ProcessTransportParameters(&error_details)) {
CloseConnection(QUIC_HANDSHAKE_FAILED, error_details);
return;
@@ -276,11 +276,11 @@
return ssl_verify_invalid;
}
// TODO(nharper): Pass the CRYPTO_BUFFERs into the QUIC stack to avoid copies.
- std::vector<QuicString> certs;
+ std::vector<std::string> certs;
for (CRYPTO_BUFFER* cert : cert_chain) {
certs.push_back(
- QuicString(reinterpret_cast<const char*>(CRYPTO_BUFFER_data(cert)),
- CRYPTO_BUFFER_len(cert)));
+ std::string(reinterpret_cast<const char*>(CRYPTO_BUFFER_data(cert)),
+ CRYPTO_BUFFER_len(cert)));
}
ProofVerifierCallbackImpl* proof_verify_callback =
diff --git a/quic/core/tls_client_handshaker.h b/quic/core/tls_client_handshaker.h
index 3e216f0..106c9c8 100644
--- a/quic/core/tls_client_handshaker.h
+++ b/quic/core/tls_client_handshaker.h
@@ -27,7 +27,7 @@
ProofVerifier* proof_verifier,
SSL_CTX* ssl_ctx,
std::unique_ptr<ProofVerifyContext> verify_context,
- const QuicString& user_agent_id);
+ const std::string& user_agent_id);
TlsClientHandshaker(const TlsClientHandshaker&) = delete;
TlsClientHandshaker& operator=(const TlsClientHandshaker&) = delete;
@@ -43,7 +43,7 @@
int num_scup_messages_received() const override;
bool WasChannelIDSent() const override;
bool WasChannelIDSourceCallbackRun() const override;
- QuicString chlo_hash() const override;
+ std::string chlo_hash() const override;
// From QuicCryptoClientStream::HandshakerDelegate and TlsHandshaker
bool encryption_established() const override;
@@ -62,7 +62,7 @@
// ProofVerifierCallback interface.
void Run(bool ok,
- const QuicString& error_details,
+ const std::string& error_details,
std::unique_ptr<ProofVerifyDetails>* details) override;
// If called, Cancel causes the pending callback to be a no-op.
@@ -81,12 +81,12 @@
} state_ = STATE_IDLE;
bool SetTransportParameters();
- bool ProcessTransportParameters(QuicString* error_details);
+ bool ProcessTransportParameters(std::string* error_details);
void FinishHandshake();
void AdvanceHandshake() override;
void CloseConnection(QuicErrorCode error,
- const QuicString& reason_phrase) override;
+ const std::string& reason_phrase) override;
// Certificate verification functions:
@@ -107,14 +107,14 @@
ProofVerifier* proof_verifier_;
std::unique_ptr<ProofVerifyContext> verify_context_;
- QuicString user_agent_id_;
+ std::string user_agent_id_;
// ProofVerifierCallback used for async certificate verification. This object
// is owned by |proof_verifier_|.
ProofVerifierCallbackImpl* proof_verify_callback_ = nullptr;
std::unique_ptr<ProofVerifyDetails> verify_details_;
enum ssl_verify_result_t verify_result_ = ssl_verify_retry;
- QuicString cert_verify_error_details_;
+ std::string cert_verify_error_details_;
bool encryption_established_ = false;
bool handshake_confirmed_ = false;
diff --git a/quic/core/tls_handshaker.h b/quic/core/tls_handshaker.h
index ceba9a9..9658923 100644
--- a/quic/core/tls_handshaker.h
+++ b/quic/core/tls_handshaker.h
@@ -38,7 +38,7 @@
bool ProcessInput(QuicStringPiece input, EncryptionLevel level) override;
size_t InputBytesRemaining() const override { return 0; }
QuicErrorCode error() const override { return parser_error_; }
- const QuicString& error_detail() const override {
+ const std::string& error_detail() const override {
return parser_error_detail_;
}
@@ -53,7 +53,7 @@
virtual void AdvanceHandshake() = 0;
virtual void CloseConnection(QuicErrorCode error,
- const QuicString& reason_phrase) = 0;
+ const std::string& reason_phrase) = 0;
// Creates an SSL_CTX and configures it with the options that are appropriate
// for both client and server. The caller is responsible for ownership of the
@@ -135,7 +135,7 @@
QuicSession* session_;
QuicErrorCode parser_error_ = QUIC_NO_ERROR;
- QuicString parser_error_detail_;
+ std::string parser_error_detail_;
bssl::UniquePtr<SSL> ssl_;
};
diff --git a/quic/core/tls_handshaker_test.cc b/quic/core/tls_handshaker_test.cc
index 2d678dd..ae9e3fc 100644
--- a/quic/core/tls_handshaker_test.cc
+++ b/quic/core/tls_handshaker_test.cc
@@ -26,16 +26,16 @@
: verifier_(crypto_test_utils::ProofVerifierForTesting()) {}
QuicAsyncStatus VerifyProof(
- const QuicString& hostname,
+ const std::string& hostname,
const uint16_t port,
- const QuicString& server_config,
+ const std::string& server_config,
QuicTransportVersion quic_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) override {
return verifier_->VerifyProof(
@@ -44,10 +44,10 @@
}
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) override {
if (!active_) {
@@ -81,7 +81,7 @@
class FailingProofVerifierCallback : public ProofVerifierCallback {
public:
void Run(bool ok,
- const QuicString& error_details,
+ const std::string& error_details,
std::unique_ptr<ProofVerifyDetails>* details) override {
FAIL();
}
@@ -89,10 +89,10 @@
class VerifyChainPendingOp {
public:
- VerifyChainPendingOp(const QuicString& hostname,
- const std::vector<QuicString>& certs,
+ VerifyChainPendingOp(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,
ProofVerifier* delegate)
@@ -117,10 +117,10 @@
}
private:
- QuicString hostname_;
- std::vector<QuicString> certs_;
+ std::string hostname_;
+ 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_;
ProofVerifier* delegate_;
@@ -158,10 +158,10 @@
}
void WriteCryptoData(EncryptionLevel level, QuicStringPiece data) override {
- pending_writes_.push_back(std::make_pair(QuicString(data), level));
+ pending_writes_.push_back(std::make_pair(std::string(data), level));
}
- const std::vector<std::pair<QuicString, EncryptionLevel>>& pending_writes() {
+ const std::vector<std::pair<std::string, EncryptionLevel>>& pending_writes() {
return pending_writes_;
}
@@ -191,7 +191,7 @@
}
private:
- std::vector<std::pair<QuicString, EncryptionLevel>> pending_writes_;
+ std::vector<std::pair<std::string, EncryptionLevel>> pending_writes_;
};
class TestQuicCryptoClientStream : public TestQuicCryptoStream {
diff --git a/quic/core/tls_server_handshaker.cc b/quic/core/tls_server_handshaker.cc
index 02cc441..b8f9573 100644
--- a/quic/core/tls_server_handshaker.cc
+++ b/quic/core/tls_server_handshaker.cc
@@ -21,7 +21,7 @@
: handshaker_(handshaker) {}
void TlsServerHandshaker::SignatureCallback::Run(bool ok,
- QuicString signature) {
+ std::string signature) {
if (handshaker_ == nullptr) {
return;
}
@@ -91,7 +91,7 @@
}
bool TlsServerHandshaker::GetBase64SHA256ClientChannelID(
- QuicString* output) const {
+ std::string* output) const {
// Channel ID is not supported when TLS is used in QUIC.
return false;
}
@@ -189,13 +189,13 @@
}
void TlsServerHandshaker::CloseConnection(QuicErrorCode error,
- const QuicString& reason_phrase) {
+ const std::string& reason_phrase) {
state_ = STATE_CONNECTION_CLOSED;
stream()->CloseConnectionWithDetails(error, reason_phrase);
}
bool TlsServerHandshaker::ProcessTransportParameters(
- QuicString* error_details) {
+ std::string* error_details) {
TransportParameters client_params;
const uint8_t* client_params_bytes;
size_t params_bytes_len;
@@ -352,7 +352,7 @@
CRYPTO_BUFFER_free(certs[i]);
}
- QuicString error_details;
+ std::string error_details;
if (!ProcessTransportParameters(&error_details)) {
CloseConnection(QUIC_HANDSHAKE_FAILED, error_details);
*out_alert = SSL_AD_INTERNAL_ERROR;
diff --git a/quic/core/tls_server_handshaker.h b/quic/core/tls_server_handshaker.h
index c3efc82..4b38a74 100644
--- a/quic/core/tls_server_handshaker.h
+++ b/quic/core/tls_server_handshaker.h
@@ -37,7 +37,7 @@
// From QuicCryptoServerStream::HandshakerDelegate
void CancelOutstandingCallbacks() override;
- bool GetBase64SHA256ClientChannelID(QuicString* output) const override;
+ bool GetBase64SHA256ClientChannelID(std::string* output) const override;
void SendServerConfigUpdate(
const CachedNetworkParameters* cached_network_params) override;
uint8_t NumHandshakeMessages() const override;
@@ -64,7 +64,7 @@
class SignatureCallback : public ProofSource::SignatureCallback {
public:
explicit SignatureCallback(TlsServerHandshaker* handshaker);
- void Run(bool ok, QuicString signature) override;
+ void Run(bool ok, std::string signature) override;
// If called, Cancel causes the pending callback to be a no-op.
void Cancel();
@@ -90,15 +90,15 @@
// for the TLS stack to read.
void AdvanceHandshake() override;
void CloseConnection(QuicErrorCode error,
- const QuicString& reason_phrase) override;
+ const std::string& reason_phrase) override;
// Called when the TLS handshake is complete.
void FinishHandshake();
- void CloseConnection(const QuicString& reason_phrase);
+ void CloseConnection(const std::string& reason_phrase);
bool SetTransportParameters();
- bool ProcessTransportParameters(QuicString* error_details);
+ bool ProcessTransportParameters(std::string* error_details);
// Calls the instance method PrivateKeySign after looking up the
// TlsServerHandshaker from |ssl|.
@@ -154,8 +154,8 @@
ProofSource* proof_source_;
SignatureCallback* signature_callback_ = nullptr;
- QuicString hostname_;
- QuicString cert_verify_sig_;
+ std::string hostname_;
+ std::string cert_verify_sig_;
bool encryption_established_ = false;
bool handshake_confirmed_ = false;
diff --git a/quic/core/uber_quic_stream_id_manager_test.cc b/quic/core/uber_quic_stream_id_manager_test.cc
index 353e35d..929d0a1 100644
--- a/quic/core/uber_quic_stream_id_manager_test.cc
+++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -67,7 +67,8 @@
QuicFrame frame_;
};
-INSTANTIATE_TEST_SUITE_P(Tests, UberQuicStreamIdManagerTest,
+INSTANTIATE_TEST_SUITE_P(Tests,
+ UberQuicStreamIdManagerTest,
::testing::ValuesIn({Perspective::IS_CLIENT,
Perspective::IS_SERVER}));
@@ -218,9 +219,9 @@
EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(
manager_->actual_max_allowed_incoming_unidirectional_stream_id()));
- QuicString error_details = GetParam() == Perspective::IS_SERVER
- ? "Stream id 404 above 400"
- : "Stream id 401 above 397";
+ std::string error_details = GetParam() == Perspective::IS_SERVER
+ ? "Stream id 404 above 400"
+ : "Stream id 401 above 397";
EXPECT_CALL(*connection_,
CloseConnection(QUIC_INVALID_STREAM_ID, error_details, _));
EXPECT_FALSE(manager_->MaybeIncreaseLargestPeerStreamId(
