Use quiche string libraries in //third_party/quic/core/crypto

gfe-relnote: n/a, no functional change
PiperOrigin-RevId: 285405224
Change-Id: I4a7f6d34ee42a2929cbbff2f303ee36b5b6ceb8a
diff --git a/quic/core/crypto/quic_crypto_client_config.cc b/quic/core/crypto/quic_crypto_client_config.cc
index d674126..330192b 100644
--- a/quic/core/crypto/quic_crypto_client_config.cc
+++ b/quic/core/crypto/quic_crypto_client_config.cc
@@ -32,8 +32,8 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.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 {
 
@@ -153,7 +153,7 @@
 
 QuicCryptoClientConfig::CachedState::ServerConfigState
 QuicCryptoClientConfig::CachedState::SetServerConfig(
-    QuicStringPiece server_config,
+    quiche::QuicheStringPiece server_config,
     QuicWallTime now,
     QuicWallTime expiry_time,
     std::string* error_details) {
@@ -211,9 +211,9 @@
 
 void QuicCryptoClientConfig::CachedState::SetProof(
     const std::vector<std::string>& certs,
-    QuicStringPiece cert_sct,
-    QuicStringPiece chlo_hash,
-    QuicStringPiece signature) {
+    quiche::QuicheStringPiece cert_sct,
+    quiche::QuicheStringPiece chlo_hash,
+    quiche::QuicheStringPiece signature) {
   bool has_changed = signature != server_config_sig_ ||
                      chlo_hash != chlo_hash_ || certs_.size() != certs.size();
 
@@ -272,12 +272,12 @@
 }
 
 bool QuicCryptoClientConfig::CachedState::Initialize(
-    QuicStringPiece server_config,
-    QuicStringPiece source_address_token,
+    quiche::QuicheStringPiece server_config,
+    quiche::QuicheStringPiece source_address_token,
     const std::vector<std::string>& certs,
     const std::string& cert_sct,
-    QuicStringPiece chlo_hash,
-    QuicStringPiece signature,
+    quiche::QuicheStringPiece chlo_hash,
+    quiche::QuicheStringPiece signature,
     QuicWallTime now,
     QuicWallTime expiration_time) {
   DCHECK(server_config_.empty());
@@ -345,12 +345,12 @@
 }
 
 void QuicCryptoClientConfig::CachedState::set_source_address_token(
-    QuicStringPiece token) {
+    quiche::QuicheStringPiece token) {
   source_address_token_ = std::string(token);
 }
 
 void QuicCryptoClientConfig::CachedState::set_cert_sct(
-    QuicStringPiece cert_sct) {
+    quiche::QuicheStringPiece cert_sct) {
   cert_sct_ = std::string(cert_sct);
 }
 
@@ -472,7 +472,7 @@
   // the STK can be validated by the server.
   const CryptoHandshakeMessage* scfg = cached->GetServerConfig();
   if (scfg != nullptr) {
-    QuicStringPiece scid;
+    quiche::QuicheStringPiece scid;
     if (scfg->GetStringPiece(kSCID, &scid)) {
       out->SetStringPiece(kSCID, scid);
     }
@@ -488,8 +488,8 @@
 
   char proof_nonce[32];
   rand->RandBytes(proof_nonce, QUIC_ARRAYSIZE(proof_nonce));
-  out->SetStringPiece(
-      kNONP, QuicStringPiece(proof_nonce, QUIC_ARRAYSIZE(proof_nonce)));
+  out->SetStringPiece(kNONP, quiche::QuicheStringPiece(
+                                 proof_nonce, QUIC_ARRAYSIZE(proof_nonce)));
 
   out->SetVector(kPDMD, QuicTagVector{kX509});
 
@@ -550,7 +550,7 @@
     return QUIC_CRYPTO_INTERNAL_ERROR;
   }
 
-  QuicStringPiece scid;
+  quiche::QuicheStringPiece scid;
   if (!scfg->GetStringPiece(kSCID, &scid)) {
     *error_details = "SCFG missing SCID";
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
@@ -582,14 +582,14 @@
   out->SetVector(kAEAD, QuicTagVector{out_params->aead});
   out->SetVector(kKEXS, QuicTagVector{out_params->key_exchange});
 
-  QuicStringPiece public_value;
+  quiche::QuicheStringPiece public_value;
   if (scfg->GetNthValue24(kPUBS, key_exchange_index, &public_value) !=
       QUIC_NO_ERROR) {
     *error_details = "Missing public value";
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
   }
 
-  QuicStringPiece orbit;
+  quiche::QuicheStringPiece orbit;
   if (!scfg->GetStringPiece(kORBT, &orbit) || orbit.size() != kOrbitSize) {
     *error_details = "SCFG missing OBIT";
     return QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND;
@@ -672,13 +672,13 @@
     const CryptoHandshakeMessage& message,
     QuicWallTime now,
     QuicTransportVersion /*version*/,
-    QuicStringPiece chlo_hash,
+    quiche::QuicheStringPiece chlo_hash,
     const std::vector<std::string>& cached_certs,
     CachedState* cached,
     std::string* error_details) {
   DCHECK(error_details != nullptr);
 
-  QuicStringPiece scfg;
+  quiche::QuicheStringPiece scfg;
   if (!message.GetStringPiece(kSCFG, &scfg)) {
     *error_details = "Missing SCFG";
     return QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND;
@@ -703,12 +703,12 @@
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
   }
 
-  QuicStringPiece token;
+  quiche::QuicheStringPiece token;
   if (message.GetStringPiece(kSourceAddressTokenTag, &token)) {
     cached->set_source_address_token(token);
   }
 
-  QuicStringPiece proof, cert_bytes, cert_sct;
+  quiche::QuicheStringPiece proof, cert_bytes, cert_sct;
   bool has_proof = message.GetStringPiece(kPROF, &proof);
   bool has_cert = message.GetStringPiece(kCertificateTag, &cert_bytes);
   if (has_proof && has_cert) {
@@ -744,7 +744,7 @@
     const CryptoHandshakeMessage& rej,
     QuicWallTime now,
     const QuicTransportVersion version,
-    QuicStringPiece chlo_hash,
+    quiche::QuicheStringPiece chlo_hash,
     CachedState* cached,
     QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
     std::string* error_details) {
@@ -762,7 +762,7 @@
     return error;
   }
 
-  QuicStringPiece nonce;
+  quiche::QuicheStringPiece nonce;
   if (rej.GetStringPiece(kServerNonceTag, &nonce)) {
     out_params->server_nonce = std::string(nonce);
   }
@@ -787,12 +787,12 @@
   }
 
   // Learn about updated source address tokens.
-  QuicStringPiece token;
+  quiche::QuicheStringPiece token;
   if (server_hello.GetStringPiece(kSourceAddressTokenTag, &token)) {
     cached->set_source_address_token(token);
   }
 
-  QuicStringPiece shlo_nonce;
+  quiche::QuicheStringPiece shlo_nonce;
   if (!server_hello.GetStringPiece(kServerNonceTag, &shlo_nonce)) {
     *error_details = "server hello missing server nonce";
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
@@ -801,7 +801,7 @@
   // TODO(agl):
   //   learn about updated SCFGs.
 
-  QuicStringPiece public_value;
+  quiche::QuicheStringPiece public_value;
   if (!server_hello.GetStringPiece(kPUBS, &public_value)) {
     *error_details = "server hello missing forward secure public value";
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
@@ -837,7 +837,7 @@
     const CryptoHandshakeMessage& server_config_update,
     QuicWallTime now,
     const QuicTransportVersion version,
-    QuicStringPiece chlo_hash,
+    quiche::QuicheStringPiece chlo_hash,
     CachedState* cached,
     QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
     std::string* error_details) {
@@ -886,8 +886,8 @@
   DCHECK(server_state->IsEmpty());
   size_t i = 0;
   for (; i < canonical_suffixes_.size(); ++i) {
-    if (QuicTextUtils::EndsWithIgnoreCase(server_id.host(),
-                                          canonical_suffixes_[i])) {
+    if (quiche::QuicheTextUtils::EndsWithIgnoreCase(server_id.host(),
+                                                    canonical_suffixes_[i])) {
       break;
     }
   }