Add QuicStringPiece which is actually StringPiece.

net/quic/test_tools/crypto_test_utils.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/test_tools/crypto_test_utils.h"
 
 #include <memory>
 
 #include "net/quic/core/crypto/channel_id.h"
 #include "net/quic/core/crypto/common_cert_set.h"
@@ skipping 16 matching lines @@
 #include "net/quic/test_tools/quic_framer_peer.h"
 #include "net/quic/test_tools/quic_stream_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/simple_quic_framer.h"
 #include "third_party/boringssl/src/include/openssl/bn.h"
 #include "third_party/boringssl/src/include/openssl/ec.h"
 #include "third_party/boringssl/src/include/openssl/ecdsa.h"
 #include "third_party/boringssl/src/include/openssl/obj_mac.h"
 #include "third_party/boringssl/src/include/openssl/sha.h"
 
-using base::StringPiece;
 using std::string;
 
 namespace net {
 namespace test {
 
 TestChannelIDKey::TestChannelIDKey(EVP_PKEY* ecdsa_key)
     : ecdsa_key_(ecdsa_key) {}
 TestChannelIDKey::~TestChannelIDKey() {}
 
-bool TestChannelIDKey::Sign(StringPiece signed_data,
+bool TestChannelIDKey::Sign(QuicStringPiece signed_data,
                             string* out_signature) const {
   bssl::ScopedEVP_MD_CTX md_ctx;
   if (EVP_DigestSignInit(md_ctx.get(), nullptr, EVP_sha256(), nullptr,
                          ecdsa_key_.get()) != 1) {
     return false;
   }
 
   EVP_DigestUpdate(md_ctx.get(), ChannelIDVerifier::kContextStr,
                    strlen(ChannelIDVerifier::kContextStr) + 1);
   EVP_DigestUpdate(md_ctx.get(), ChannelIDVerifier::kClientToServerStr,
@@ skipping 277 matching lines @@
     return std::unique_ptr<ProcessClientHelloCallback>(
         new ProcessClientHelloCallback(this));
   }
 
   void ProcessClientHelloDone(std::unique_ptr<CryptoHandshakeMessage> rej) {
     // Verify output is a REJ or SREJ.
     EXPECT_THAT(rej->tag(),
                 testing::AnyOf(testing::Eq(kSREJ), testing::Eq(kREJ)));
 
     VLOG(1) << "Extract valid STK and SCID from\n" << rej->DebugString();
-    StringPiece srct;
+    QuicStringPiece srct;
     ASSERT_TRUE(rej->GetStringPiece(kSourceAddressTokenTag, &srct));
 
-    StringPiece scfg;
+    QuicStringPiece scfg;
     ASSERT_TRUE(rej->GetStringPiece(kSCFG, &scfg));
     std::unique_ptr<CryptoHandshakeMessage> server_config(
         CryptoFramer::ParseMessage(scfg));
 
-    StringPiece scid;
+    QuicStringPiece scid;
     ASSERT_TRUE(server_config->GetStringPiece(kSCID, &scid));
 
     *out_ = result_->client_hello;
     out_->SetStringPiece(kSCID, scid);
     out_->SetStringPiece(kSourceAddressTokenTag, srct);
     uint64_t xlct = LeafCertHashForTesting();
     out_->SetValue(kXLCT, xlct);
   }
 
  protected:
@@ skipping 215 matching lines @@
   if (!ok || chain->certs.empty()) {
     DCHECK(false) << "Proof generation failed";
     return 0;
   }
 
   return QuicUtils::FNV1a_64_Hash(chain->certs.at(0));
 }
 
 class MockCommonCertSets : public CommonCertSets {
  public:
-  MockCommonCertSets(StringPiece cert, uint64_t hash, uint32_t index)
+  MockCommonCertSets(QuicStringPiece cert, uint64_t hash, uint32_t index)
       : cert_(cert.as_string()), hash_(hash), index_(index) {}
 
-  StringPiece GetCommonHashes() const override {
+  QuicStringPiece GetCommonHashes() const override {
     CHECK(false) << "not implemented";
-    return StringPiece();
+    return QuicStringPiece();
   }
 
-  StringPiece GetCert(uint64_t hash, uint32_t index) const override {
+  QuicStringPiece GetCert(uint64_t hash, uint32_t index) const override {
     if (hash == hash_ && index == index_) {
       return cert_;
     }
-    return StringPiece();
+    return QuicStringPiece();
   }
 
-  bool MatchCert(StringPiece cert,
-                 StringPiece common_set_hashes,
+  bool MatchCert(QuicStringPiece cert,
+                 QuicStringPiece common_set_hashes,
                  uint64_t* out_hash,
                  uint32_t* out_index) const override {
     if (cert != cert_) {
       return false;
     }
 
     if (common_set_hashes.size() % sizeof(uint64_t) != 0) {
       return false;
     }
     bool client_has_set = false;
@@ skipping 14 matching lines @@
     *out_index = index_;
     return true;
   }
 
  private:
   const string cert_;
   const uint64_t hash_;
   const uint32_t index_;
 };
 
-CommonCertSets* MockCommonCertSets(StringPiece cert,
+CommonCertSets* MockCommonCertSets(QuicStringPiece cert,
                                    uint64_t hash,
                                    uint32_t index) {
   return new class MockCommonCertSets(cert, hash, index);
 }
 
 void FillInDummyReject(CryptoHandshakeMessage* rej, bool reject_is_stateless) {
   if (reject_is_stateless) {
     rej->set_tag(kSREJ);
   } else {
     rej->set_tag(kREJ);
@@ skipping 42 matching lines @@
       QuicStreamPeer::session(client)->connection()->alternative_decrypter());
   const QuicEncrypter* server_encrypter(
       QuicFramerPeer::GetEncrypter(server_framer, ENCRYPTION_INITIAL));
   const QuicDecrypter* server_decrypter(
       QuicStreamPeer::session(server)->connection()->decrypter());
   const QuicEncrypter* server_forward_secure_encrypter(
       QuicFramerPeer::GetEncrypter(server_framer, ENCRYPTION_FORWARD_SECURE));
   const QuicDecrypter* server_forward_secure_decrypter(
       QuicStreamPeer::session(server)->connection()->alternative_decrypter());
 
-  StringPiece client_encrypter_key = client_encrypter->GetKey();
-  StringPiece client_encrypter_iv = client_encrypter->GetNoncePrefix();
-  StringPiece client_decrypter_key = client_decrypter->GetKey();
-  StringPiece client_decrypter_iv = client_decrypter->GetNoncePrefix();
-  StringPiece client_forward_secure_encrypter_key =
+  QuicStringPiece client_encrypter_key = client_encrypter->GetKey();
+  QuicStringPiece client_encrypter_iv = client_encrypter->GetNoncePrefix();
+  QuicStringPiece client_decrypter_key = client_decrypter->GetKey();
+  QuicStringPiece client_decrypter_iv = client_decrypter->GetNoncePrefix();
+  QuicStringPiece client_forward_secure_encrypter_key =
       client_forward_secure_encrypter->GetKey();
-  StringPiece client_forward_secure_encrypter_iv =
+  QuicStringPiece client_forward_secure_encrypter_iv =
       client_forward_secure_encrypter->GetNoncePrefix();
-  StringPiece client_forward_secure_decrypter_key =
+  QuicStringPiece client_forward_secure_decrypter_key =
       client_forward_secure_decrypter->GetKey();
-  StringPiece client_forward_secure_decrypter_iv =
+  QuicStringPiece client_forward_secure_decrypter_iv =
       client_forward_secure_decrypter->GetNoncePrefix();
-  StringPiece server_encrypter_key = server_encrypter->GetKey();
-  StringPiece server_encrypter_iv = server_encrypter->GetNoncePrefix();
-  StringPiece server_decrypter_key = server_decrypter->GetKey();
-  StringPiece server_decrypter_iv = server_decrypter->GetNoncePrefix();
-  StringPiece server_forward_secure_encrypter_key =
+  QuicStringPiece server_encrypter_key = server_encrypter->GetKey();
+  QuicStringPiece server_encrypter_iv = server_encrypter->GetNoncePrefix();
+  QuicStringPiece server_decrypter_key = server_decrypter->GetKey();
+  QuicStringPiece server_decrypter_iv = server_decrypter->GetNoncePrefix();
+  QuicStringPiece server_forward_secure_encrypter_key =
       server_forward_secure_encrypter->GetKey();
-  StringPiece server_forward_secure_encrypter_iv =
+  QuicStringPiece server_forward_secure_encrypter_iv =
       server_forward_secure_encrypter->GetNoncePrefix();
-  StringPiece server_forward_secure_decrypter_key =
+  QuicStringPiece server_forward_secure_decrypter_key =
       server_forward_secure_decrypter->GetKey();
-  StringPiece server_forward_secure_decrypter_iv =
+  QuicStringPiece server_forward_secure_decrypter_iv =
       server_forward_secure_decrypter->GetNoncePrefix();
 
-  StringPiece client_subkey_secret =
+  QuicStringPiece client_subkey_secret =
       client->crypto_negotiated_params().subkey_secret;
-  StringPiece server_subkey_secret =
+  QuicStringPiece server_subkey_secret =
       server->crypto_negotiated_params().subkey_secret;
 
   const char kSampleLabel[] = "label";
   const char kSampleContext[] = "context";
   const size_t kSampleOutputLength = 32;
   string client_key_extraction;
   string server_key_extraction;
   string client_tb_ekm;
   string server_tb_ekm;
   EXPECT_TRUE(client->ExportKeyingMaterial(kSampleLabel, kSampleContext,
@@ skipping 104 matching lines @@
 
   for (const auto& tag_and_value : tags_and_values) {
     const string& tag = tag_and_value.first;
     const string& value = tag_and_value.second;
 
     const QuicTag quic_tag = ParseTag(tag.c_str());
 
     size_t value_len = value.length();
     if (value_len > 0 && value[0] == '#') {
       // This is ascii encoded hex.
-      string hex_value = QuicTextUtils::HexDecode(StringPiece(&value[1]));
+      string hex_value = QuicTextUtils::HexDecode(QuicStringPiece(&value[1]));
       msg.SetStringPiece(quic_tag, hex_value);
       continue;
     }
     msg.SetStringPiece(quic_tag, value);
   }
 
   // The CryptoHandshakeMessage needs to be serialized and parsed to ensure
   // that any padding is included.
   std::unique_ptr<QuicData> bytes(CryptoFramer::ConstructHandshakeMessage(msg));
   std::unique_ptr<CryptoHandshakeMessage> parsed(
@@ skipping 27 matching lines @@
 
   size_t index = *inout_packet_index;
   for (; index < source_conn->encrypted_packets_.size(); index++) {
     if (!framer.ProcessPacket(*source_conn->encrypted_packets_[index])) {
       // The framer will be unable to decrypt forward-secure packets sent after
       // the handshake is complete. Don't treat them as handshake packets.
       break;
     }
 
     for (const auto& stream_frame : framer.stream_frames()) {
-      ASSERT_TRUE(crypto_framer.ProcessInput(
-          StringPiece(stream_frame->data_buffer, stream_frame->data_length)));
+      ASSERT_TRUE(crypto_framer.ProcessInput(QuicStringPiece(
+          stream_frame->data_buffer, stream_frame->data_length)));
       ASSERT_FALSE(crypto_visitor.error());
     }
     QuicConnectionPeer::SetCurrentPacket(
         dest_conn, source_conn->encrypted_packets_[index]->AsStringPiece());
   }
   *inout_packet_index = index;
 
   QuicConnectionPeer::SwapCrypters(dest_conn, framer.framer());
 
   ASSERT_EQ(0u, crypto_framer.InputBytesRemaining());
 
   for (const CryptoHandshakeMessage& message : crypto_visitor.messages()) {
     dest_stream->OnHandshakeMessage(message);
   }
-  QuicConnectionPeer::SetCurrentPacket(dest_conn, StringPiece(nullptr, 0));
+  QuicConnectionPeer::SetCurrentPacket(dest_conn, QuicStringPiece(nullptr, 0));
 }
 
 CryptoHandshakeMessage GenerateDefaultInchoateCHLO(
     const QuicClock* clock,
     QuicVersion version,
     QuicCryptoServerConfig* crypto_config) {
   // clang-format off
   return CreateCHLO(
       {{"PDMD", "X509"},
        {"AEAD", "AESG"},
@@ skipping 11 matching lines @@
   QuicCryptoServerConfig::ConfigOptions new_config_options;
   old_config_options.id = "old-config-id";
   delete crypto_config->AddDefaultConfig(QuicRandom::GetInstance(), clock,
                                          old_config_options);
   std::unique_ptr<QuicServerConfigProtobuf> primary_config(
       crypto_config->GenerateConfig(QuicRandom::GetInstance(), clock,
                                     new_config_options));
   primary_config->set_primary_time(clock->WallNow().ToUNIXSeconds());
   std::unique_ptr<CryptoHandshakeMessage> msg(
       crypto_config->AddConfig(std::move(primary_config), clock->WallNow()));
-  StringPiece orbit;
+  QuicStringPiece orbit;
   CHECK(msg->GetStringPiece(kORBT, &orbit));
   string nonce;
   CryptoUtils::GenerateNonce(
       clock->WallNow(), QuicRandom::GetInstance(),
-      StringPiece(reinterpret_cast<const char*>(orbit.data()),
-                  sizeof(orbit.size())),
+      QuicStringPiece(reinterpret_cast<const char*>(orbit.data()),
+                      sizeof(orbit.size())),
       &nonce);
   return ("#" + QuicTextUtils::HexEncode(nonce));
 }
 
 string GenerateClientPublicValuesHex() {
   char public_value[32];
   memset(public_value, 42, sizeof(public_value));
   return ("#" + QuicTextUtils::HexEncode(public_value, sizeof(public_value)));
 }
 
@@ skipping 10 matching lines @@
   FullChloGenerator generator(crypto_config, server_addr, client_addr, clock,
                               proof, compressed_certs_cache, out);
   crypto_config->ValidateClientHello(
       inchoate_chlo, client_addr.host(), server_addr, version, clock, proof,
       generator.GetValidateClientHelloCallback());
 }
 
 }  // namespace crypto_test_utils
 }  // namespace test
 }  // namespace net