Add QuicStringPiece which is actually StringPiece.

net/quic/core/crypto/crypto_server_test.cc

 // Copyright (c) 2013 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 <algorithm>
 #include <cstdint>
 #include <memory>
 #include <ostream>
 #include <vector>
 
 #include "net/quic/core/crypto/cert_compressor.h"
 #include "net/quic/core/crypto/common_cert_set.h"
 #include "net/quic/core/crypto/crypto_handshake.h"
 #include "net/quic/core/crypto/crypto_server_config_protobuf.h"
 #include "net/quic/core/crypto/crypto_utils.h"
 #include "net/quic/core/crypto/proof_source.h"
 #include "net/quic/core/crypto/quic_crypto_server_config.h"
 #include "net/quic/core/crypto/quic_random.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_socket_address_coder.h"
 #include "net/quic/core/quic_utils.h"
+#include "net/quic/platform/api/quic_string_piece.h"
 #include "net/quic/platform/api/quic_text_utils.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/delayed_verify_strike_register_client.h"
 #include "net/quic/test_tools/failing_proof_source.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/mock_random.h"
 #include "net/quic/test_tools/quic_crypto_server_config_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/boringssl/src/include/openssl/sha.h"
 
-using base::StringPiece;
 using std::string;
 
 namespace net {
 namespace test {
 
 namespace {
 
 class DummyProofVerifierCallback : public ProofVerifierCallback {
  public:
   DummyProofVerifierCallback() {}
@@ skipping 86 matching lines @@
     QuicCryptoServerConfig::ConfigOptions old_config_options;
     old_config_options.id = kOldConfigId;
     delete config_.AddDefaultConfig(rand_, &clock_, old_config_options);
     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000));
     std::unique_ptr<QuicServerConfigProtobuf> primary_config(
         config_.GenerateConfig(rand_, &clock_, config_options_));
     primary_config->set_primary_time(clock_.WallNow().ToUNIXSeconds());
     std::unique_ptr<CryptoHandshakeMessage> msg(
         config_.AddConfig(std::move(primary_config), clock_.WallNow()));
 
-    StringPiece orbit;
+    QuicStringPiece orbit;
     CHECK(msg->GetStringPiece(kORBT, &orbit));
     CHECK_EQ(sizeof(orbit_), orbit.size());
     memcpy(orbit_, orbit.data(), orbit.size());
 
     char public_value[32];
     memset(public_value, 42, sizeof(public_value));
 
     nonce_hex_ = "#" + QuicTextUtils::HexEncode(GenerateNonce());
     pub_hex_ =
         "#" + QuicTextUtils::HexEncode(public_value, sizeof(public_value));
 
     CryptoHandshakeMessage client_hello =
         crypto_test_utils::CreateCHLO({{"PDMD", "X509"},
                                        {"AEAD", "AESG"},
                                        {"KEXS", "C255"},
                                        {"PUBS", pub_hex_},
                                        {"NONC", nonce_hex_},
                                        {"CSCT", ""},
                                        {"VER\0", client_version_string_}},
                                       kClientHelloMinimumSize);
     ShouldSucceed(client_hello);
     // The message should be rejected because the source-address token is
     // missing.
     CheckRejectTag();
     const HandshakeFailureReason kRejectReasons[] = {
         SERVER_CONFIG_INCHOATE_HELLO_FAILURE};
     CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
     CheckForServerDesignatedConnectionId();
 
-    StringPiece srct;
+    QuicStringPiece srct;
     ASSERT_TRUE(out_.GetStringPiece(kSourceAddressTokenTag, &srct));
     srct_hex_ = "#" + QuicTextUtils::HexEncode(srct);
 
-    StringPiece scfg;
+    QuicStringPiece scfg;
     ASSERT_TRUE(out_.GetStringPiece(kSCFG, &scfg));
     server_config_ = CryptoFramer::ParseMessage(scfg);
 
-    StringPiece scid;
+    QuicStringPiece scid;
     ASSERT_TRUE(server_config_->GetStringPiece(kSCID, &scid));
     scid_hex_ = "#" + QuicTextUtils::HexEncode(scid);
 
     signed_config_ = QuicReferenceCountedPointer<QuicSignedServerConfig>(
         new QuicSignedServerConfig());
     DCHECK(signed_config_->chain.get() == nullptr);
   }
 
   // Helper used to accept the result of ValidateClientHello and pass
   // it on to ProcessClientHello.
@@ skipping 27 matching lines @@
 
   void CheckServerHello(const CryptoHandshakeMessage& server_hello) {
     const QuicTag* versions;
     size_t num_versions;
     server_hello.GetTaglist(kVER, &versions, &num_versions);
     ASSERT_EQ(supported_versions_.size(), num_versions);
     for (size_t i = 0; i < num_versions; ++i) {
       EXPECT_EQ(QuicVersionToQuicTag(supported_versions_[i]), versions[i]);
     }
 
-    StringPiece address;
+    QuicStringPiece address;
     ASSERT_TRUE(server_hello.GetStringPiece(kCADR, &address));
     QuicSocketAddressCoder decoder;
     ASSERT_TRUE(decoder.Decode(address.data(), address.size()));
     EXPECT_EQ(client_address_.host(), decoder.ip());
     EXPECT_EQ(client_address_.port(), decoder.port());
   }
 
   void ShouldSucceed(const CryptoHandshakeMessage& message) {
     bool called = false;
     QuicSocketAddress server_address;
@@ skipping 86 matching lines @@
         /*total_framing_overhead=*/50, chlo_packet_size_,
         std::unique_ptr<ProcessCallback>(new ProcessCallback(
             result, should_succeed, error_substr, &called, &out_)));
     EXPECT_TRUE(called);
   }
 
   string GenerateNonce() {
     string nonce;
     CryptoUtils::GenerateNonce(
         clock_.WallNow(), rand_,
-        StringPiece(reinterpret_cast<const char*>(orbit_), sizeof(orbit_)),
+        QuicStringPiece(reinterpret_cast<const char*>(orbit_), sizeof(orbit_)),
         &nonce);
     return nonce;
   }
 
   void CheckRejectReasons(
       const HandshakeFailureReason* expected_handshake_failures,
       size_t expected_count) {
     const uint32_t* reject_reasons;
     size_t num_reject_reasons;
     static_assert(sizeof(QuicTag) == sizeof(uint32_t), "header out of sync");
@@ skipping 105 matching lines @@
   CryptoHandshakeMessage msg =
       crypto_test_utils::CreateCHLO({{"AEAD", "AESG"},
                                      {"KEXS", "C255"},
                                      {"PUBS", pub_hex_},
                                      {"NONC", nonce_hex_},
                                      {"PDMD", "X509"},
                                      {"VER\0", client_version_string_}},
                                     kClientHelloMinimumSize);
 
   ShouldSucceed(msg);
-  StringPiece cert, proof, cert_sct;
+  QuicStringPiece cert, proof, cert_sct;
   EXPECT_TRUE(out_.GetStringPiece(kCertificateTag, &cert));
   EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof));
   EXPECT_TRUE(out_.GetStringPiece(kCertificateSCTTag, &cert_sct));
   EXPECT_NE(0u, cert.size());
   EXPECT_NE(0u, proof.size());
   const HandshakeFailureReason kRejectReasons[] = {
       SERVER_CONFIG_INCHOATE_HELLO_FAILURE};
   CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
   EXPECT_LT(0u, cert_sct.size());
 }
 
 TEST_P(CryptoServerTest, RejectTooLarge) {
   // Check that the server replies with no certificate when a CHLO is
   // constructed with a PDMD but no SKT when the REJ would be too large.
   CryptoHandshakeMessage msg =
       crypto_test_utils::CreateCHLO({{"PDMD", "X509"},
                                      {"AEAD", "AESG"},
                                      {"KEXS", "C255"},
                                      {"PUBS", pub_hex_},
                                      {"NONC", nonce_hex_},
                                      {"PDMD", "X509"},
                                      {"VER\0", client_version_string_}},
                                     kClientHelloMinimumSize);
 
   // The REJ will be larger than the CHLO so no PROF or CRT will be sent.
   config_.set_chlo_multiplier(1);
 
   ShouldSucceed(msg);
-  StringPiece cert, proof, cert_sct;
+  QuicStringPiece cert, proof, cert_sct;
   EXPECT_FALSE(out_.GetStringPiece(kCertificateTag, &cert));
   EXPECT_FALSE(out_.GetStringPiece(kPROF, &proof));
   EXPECT_FALSE(out_.GetStringPiece(kCertificateSCTTag, &cert_sct));
   const HandshakeFailureReason kRejectReasons[] = {
       SERVER_CONFIG_INCHOATE_HELLO_FAILURE};
   CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
 }
 
 TEST_P(CryptoServerTest, RejectNotTooLarge) {
   // When the CHLO packet is large enough, ensure that a full REJ is sent.
   chlo_packet_size_ *= 2;
 
   CryptoHandshakeMessage msg =
       crypto_test_utils::CreateCHLO({{"PDMD", "X509"},
                                      {"AEAD", "AESG"},
                                      {"KEXS", "C255"},
                                      {"PUBS", pub_hex_},
                                      {"NONC", nonce_hex_},
                                      {"PDMD", "X509"},
                                      {"VER\0", client_version_string_}},
                                     kClientHelloMinimumSize);
 
   // The REJ will be larger than the CHLO so no PROF or CRT will be sent.
   config_.set_chlo_multiplier(1);
 
   ShouldSucceed(msg);
-  StringPiece cert, proof, cert_sct;
+  QuicStringPiece cert, proof, cert_sct;
   EXPECT_TRUE(out_.GetStringPiece(kCertificateTag, &cert));
   EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof));
   EXPECT_TRUE(out_.GetStringPiece(kCertificateSCTTag, &cert_sct));
   const HandshakeFailureReason kRejectReasons[] = {
       SERVER_CONFIG_INCHOATE_HELLO_FAILURE};
   CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
 }
 
 TEST_P(CryptoServerTest, RejectTooLargeButValidSTK) {
   // Check that the server replies with no certificate when a CHLO is
   // constructed with a PDMD but no SKT when the REJ would be too large.
   CryptoHandshakeMessage msg =
       crypto_test_utils::CreateCHLO({{"PDMD", "X509"},
                                      {"AEAD", "AESG"},
                                      {"KEXS", "C255"},
                                      {"PUBS", pub_hex_},
                                      {"NONC", nonce_hex_},
                                      {"#004b5453", srct_hex_},
                                      {"PDMD", "X509"},
                                      {"VER\0", client_version_string_}},
                                     kClientHelloMinimumSize);
 
   // The REJ will be larger than the CHLO so no PROF or CRT will be sent.
   config_.set_chlo_multiplier(1);
 
   ShouldSucceed(msg);
-  StringPiece cert, proof, cert_sct;
+  QuicStringPiece cert, proof, cert_sct;
   EXPECT_TRUE(out_.GetStringPiece(kCertificateTag, &cert));
   EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof));
   EXPECT_TRUE(out_.GetStringPiece(kCertificateSCTTag, &cert_sct));
   EXPECT_NE(0u, cert.size());
   EXPECT_NE(0u, proof.size());
   const HandshakeFailureReason kRejectReasons[] = {
       SERVER_CONFIG_INCHOATE_HELLO_FAILURE};
   CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
 }
 
@@ skipping 254 matching lines @@
                                     kClientHelloMinimumSize);
 
   ShouldSucceed(msg);
   // The message should be rejected because the source-address token is no
   // longer valid.
   CheckRejectTag();
   const HandshakeFailureReason kRejectReasons[] = {
       SOURCE_ADDRESS_TOKEN_DIFFERENT_IP_ADDRESS_FAILURE};
   CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
 
-  StringPiece cert, proof, scfg_str;
+  QuicStringPiece cert, proof, scfg_str;
   EXPECT_TRUE(out_.GetStringPiece(kCertificateTag, &cert));
   EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof));
   EXPECT_TRUE(out_.GetStringPiece(kSCFG, &scfg_str));
   std::unique_ptr<CryptoHandshakeMessage> scfg(
       CryptoFramer::ParseMessage(scfg_str));
-  StringPiece scid;
+  QuicStringPiece scid;
   EXPECT_TRUE(scfg->GetStringPiece(kSCID, &scid));
   EXPECT_NE(scid, kOldConfigId);
 
   // Get certs from compressed certs.
   const CommonCertSets* common_cert_sets(CommonCertSets::GetInstanceQUIC());
   std::vector<string> cached_certs;
 
   std::vector<string> certs;
   ASSERT_TRUE(CertCompressor::DecompressChain(cert, cached_certs,
                                               common_cert_sets, &certs));
@@ skipping 78 matching lines @@
                                     kClientHelloMinimumSize);
 
   // If replay protection isn't disabled, then
   // QuicCryptoServerConfig::EvaluateClientHello will leave info.unique as false
   // and cause ProcessClientHello to exit early (and generate a REJ message).
   config_.set_replay_protection(false);
 
   ShouldSucceed(msg);
   EXPECT_EQ(kSHLO, out_.tag());
 
-  StringPiece nonce;
+  QuicStringPiece nonce;
   EXPECT_TRUE(out_.GetStringPiece(kServerNonceTag, &nonce));
 }
 
 TEST_P(CryptoServerTest, ProofSourceFailure) {
   // Install a ProofSource which will unconditionally fail
   peer_.ResetProofSource(std::unique_ptr<ProofSource>(new FailingProofSource));
 
   CryptoHandshakeMessage msg =
       crypto_test_utils::CreateCHLO({{"AEAD", "AESG"},
                                      {"KEXS", "C255"},
@@ skipping 39 matching lines @@
   QuicCryptoServerConfig a(QuicCryptoServerConfig::TESTING, &rand_a,
                            crypto_test_utils::ProofSourceForTesting());
   rand_b.ChangeValue();
   QuicCryptoServerConfig b(QuicCryptoServerConfig::TESTING, &rand_b,
                            crypto_test_utils::ProofSourceForTesting());
   std::unique_ptr<CryptoHandshakeMessage> scfg_a(
       a.AddDefaultConfig(&rand_a, &clock, options));
   std::unique_ptr<CryptoHandshakeMessage> scfg_b(
       b.AddDefaultConfig(&rand_b, &clock, options));
 
-  StringPiece scid_a, scid_b;
+  QuicStringPiece scid_a, scid_b;
   EXPECT_TRUE(scfg_a->GetStringPiece(kSCID, &scid_a));
   EXPECT_TRUE(scfg_b->GetStringPiece(kSCID, &scid_b));
 
   EXPECT_NE(scid_a, scid_b);
 }
 
 TEST(CryptoServerConfigGenerationTest, SCIDIsHashOfServerConfig) {
   MockRandom rand_a;
   const QuicCryptoServerConfig::ConfigOptions options;
   MockClock clock;
 
   QuicCryptoServerConfig a(QuicCryptoServerConfig::TESTING, &rand_a,
                            crypto_test_utils::ProofSourceForTesting());
   std::unique_ptr<CryptoHandshakeMessage> scfg(
       a.AddDefaultConfig(&rand_a, &clock, options));
 
-  StringPiece scid;
+  QuicStringPiece scid;
   EXPECT_TRUE(scfg->GetStringPiece(kSCID, &scid));
   // Need to take a copy of |scid| has we're about to call |Erase|.
   const string scid_str(scid.as_string());
 
   scfg->Erase(kSCID);
   scfg->MarkDirty();
   const QuicData& serialized(scfg->GetSerialized());
 
   uint8_t digest[SHA256_DIGEST_LENGTH];
   SHA256(reinterpret_cast<const uint8_t*>(serialized.data()),
@@ skipping 71 matching lines @@
   // QuicCryptoServerConfig::EvaluateClientHello will leave info.unique as false
   // and cause ProcessClientHello to exit early (and generate a REJ message).
   config_.set_replay_protection(false);
 
   ShouldSucceed(msg);
   EXPECT_EQ(kSHLO, out_.tag());
 }
 
 }  // namespace test
 }  // namespace net