commit c48c871a41b3155b544abac5ce0d70691800a3b1
author vasilvv <vasilvv@google.com> Mon Mar 11 13:38:16 2019 -0700
committer Copybara-Service <copybara-worker@google.com> Mon Mar 11 13:38:47 2019 -0700
tree 86edd4f8e47d8e9c1d862efac09aa6b46d01037a
parent 348de99ee1f13e6747da3695387a2c78610f5f62

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

quic/core/crypto/p256_key_exchange.cc

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));
 }