Use quiche string libraries in third_party/quic/test_tools
gfe-relnote: n/a, no functional change
PiperOrigin-RevId: 285009487
Change-Id: Ib5df01e93b8567c062cac8e5469e1ff86161445f
diff --git a/quic/test_tools/crypto_test_utils.cc b/quic/test_tools/crypto_test_utils.cc
index 6716dec..7197427 100644
--- a/quic/test_tools/crypto_test_utils.cc
+++ b/quic/test_tools/crypto_test_utils.cc
@@ -32,12 +32,13 @@
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_framer_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_stream_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/simple_quic_framer.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
namespace quic {
namespace test {
@@ -175,15 +176,15 @@
EXPECT_THAT(rej->tag(), testing::Eq(kREJ));
QUIC_VLOG(1) << "Extract valid STK and SCID from\n" << rej->DebugString();
- QuicStringPiece srct;
+ quiche::QuicheStringPiece srct;
ASSERT_TRUE(rej->GetStringPiece(kSourceAddressTokenTag, &srct));
- QuicStringPiece scfg;
+ quiche::QuicheStringPiece scfg;
ASSERT_TRUE(rej->GetStringPiece(kSCFG, &scfg));
std::unique_ptr<CryptoHandshakeMessage> server_config(
CryptoFramer::ParseMessage(scfg));
- QuicStringPiece scid;
+ quiche::QuicheStringPiece scid;
ASSERT_TRUE(server_config->GetStringPiece(kSCID, &scid));
*out_ = result_->client_hello;
@@ -246,9 +247,10 @@
EXPECT_CALL(*server_conn, OnCanWrite()).Times(testing::AnyNumber());
EXPECT_CALL(*client_conn, OnCanWrite()).Times(testing::AnyNumber());
EXPECT_CALL(server_session, SelectAlpn(_))
- .WillRepeatedly([alpn](const std::vector<QuicStringPiece>& alpns) {
- return std::find(alpns.cbegin(), alpns.cend(), alpn);
- });
+ .WillRepeatedly(
+ [alpn](const std::vector<quiche::QuicheStringPiece>& alpns) {
+ return std::find(alpns.cbegin(), alpns.cend(), alpn);
+ });
// The client's handshake must have been started already.
CHECK_NE(0u, client_conn->encrypted_packets_.size());
@@ -437,23 +439,26 @@
class MockCommonCertSets : public CommonCertSets {
public:
- MockCommonCertSets(QuicStringPiece cert, uint64_t hash, uint32_t index)
+ MockCommonCertSets(quiche::QuicheStringPiece cert,
+ uint64_t hash,
+ uint32_t index)
: cert_(cert), hash_(hash), index_(index) {}
- QuicStringPiece GetCommonHashes() const override {
+ quiche::QuicheStringPiece GetCommonHashes() const override {
QUIC_BUG << "not implemented";
- return QuicStringPiece();
+ return quiche::QuicheStringPiece();
}
- QuicStringPiece GetCert(uint64_t hash, uint32_t index) const override {
+ quiche::QuicheStringPiece GetCert(uint64_t hash,
+ uint32_t index) const override {
if (hash == hash_ && index == index_) {
return cert_;
}
- return QuicStringPiece();
+ return quiche::QuicheStringPiece();
}
- bool MatchCert(QuicStringPiece cert,
- QuicStringPiece common_set_hashes,
+ bool MatchCert(quiche::QuicheStringPiece cert,
+ quiche::QuicheStringPiece common_set_hashes,
uint64_t* out_hash,
uint32_t* out_index) const override {
if (cert != cert_) {
@@ -488,7 +493,7 @@
const uint32_t index_;
};
-CommonCertSets* MockCommonCertSets(QuicStringPiece cert,
+CommonCertSets* MockCommonCertSets(quiche::QuicheStringPiece cert,
uint64_t hash,
uint32_t index) {
return new class MockCommonCertSets(cert, hash, index);
@@ -549,10 +554,10 @@
<< decrypter;
return;
}
- QuicStringPiece encrypter_key = encrypter->GetKey();
- QuicStringPiece encrypter_iv = encrypter->GetNoncePrefix();
- QuicStringPiece decrypter_key = decrypter->GetKey();
- QuicStringPiece decrypter_iv = decrypter->GetNoncePrefix();
+ quiche::QuicheStringPiece encrypter_key = encrypter->GetKey();
+ quiche::QuicheStringPiece encrypter_iv = encrypter->GetNoncePrefix();
+ quiche::QuicheStringPiece decrypter_key = decrypter->GetKey();
+ quiche::QuicheStringPiece decrypter_iv = decrypter->GetNoncePrefix();
CompareCharArraysWithHexError(label + " key", encrypter_key.data(),
encrypter_key.length(), decrypter_key.data(),
decrypter_key.length());
@@ -592,9 +597,9 @@
}
}
- QuicStringPiece client_subkey_secret =
+ quiche::QuicheStringPiece client_subkey_secret =
client->crypto_negotiated_params().subkey_secret;
- QuicStringPiece server_subkey_secret =
+ quiche::QuicheStringPiece server_subkey_secret =
server->crypto_negotiated_params().subkey_secret;
CompareCharArraysWithHexError("subkey secret", client_subkey_secret.data(),
client_subkey_secret.length(),
@@ -674,8 +679,8 @@
size_t value_len = value.length();
if (value_len > 0 && value[0] == '#') {
// This is ascii encoded hex.
- std::string hex_value =
- QuicTextUtils::HexDecode(QuicStringPiece(&value[1]));
+ std::string hex_value = quiche::QuicheTextUtils::HexDecode(
+ quiche::QuicheStringPiece(&value[1]));
msg.SetStringPiece(quic_tag, hex_value);
continue;
}
@@ -759,7 +764,8 @@
}
*inout_packet_index = index;
- QuicConnectionPeer::SetCurrentPacket(dest_conn, QuicStringPiece(nullptr, 0));
+ QuicConnectionPeer::SetCurrentPacket(dest_conn,
+ quiche::QuicheStringPiece(nullptr, 0));
}
CryptoHandshakeMessage GenerateDefaultInchoateCHLO(
@@ -791,18 +797,19 @@
primary_config.set_primary_time(clock->WallNow().ToUNIXSeconds());
std::unique_ptr<CryptoHandshakeMessage> msg =
crypto_config->AddConfig(primary_config, clock->WallNow());
- QuicStringPiece orbit;
+ quiche::QuicheStringPiece orbit;
CHECK(msg->GetStringPiece(kORBT, &orbit));
std::string nonce;
CryptoUtils::GenerateNonce(clock->WallNow(), QuicRandom::GetInstance(), orbit,
&nonce);
- return ("#" + QuicTextUtils::HexEncode(nonce));
+ return ("#" + quiche::QuicheTextUtils::HexEncode(nonce));
}
std::string GenerateClientPublicValuesHex() {
char public_value[32];
memset(public_value, 42, sizeof(public_value));
- return ("#" + QuicTextUtils::HexEncode(public_value, sizeof(public_value)));
+ return ("#" + quiche::QuicheTextUtils::HexEncode(public_value,
+ sizeof(public_value)));
}
void GenerateFullCHLO(const CryptoHandshakeMessage& inchoate_chlo,
