Add QuicStringPiece which is actually StringPiece.

net/quic/quartc/quartc_session_test.cc

 // Copyright (c) 2016 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/quartc/quartc_session.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/core/crypto/crypto_server_config_protobuf.h"
 #include "net/quic/core/crypto/proof_source.h"
 #include "net/quic/core/crypto/proof_verifier.h"
 #include "net/quic/core/crypto/quic_crypto_client_config.h"
 #include "net/quic/core/crypto/quic_crypto_server_config.h"
 #include "net/quic/core/crypto/quic_random.h"
 #include "net/quic/core/quic_crypto_client_stream.h"
 #include "net/quic/core/quic_crypto_server_stream.h"
 #include "net/quic/core/quic_simple_buffer_allocator.h"
+#include "net/quic/platform/api/quic_string_piece.h"
 #include "net/quic/platform/impl/quic_chromium_clock.h"
 #include "net/quic/quartc/quartc_alarm_factory.h"
 #include "net/quic/quartc/quartc_packet_writer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace test {
 namespace {
 
@@ skipping 19 matching lines @@
 // canned response equal to |success|.
 class FakeProofSource : public net::ProofSource {
  public:
   explicit FakeProofSource(bool success) : success_(success) {}
 
   // ProofSource override.
   void GetProof(const QuicSocketAddress& server_ip,
                 const std::string& hostname,
                 const std::string& server_config,
                 net::QuicVersion quic_version,
-                base::StringPiece chlo_hash,
+                QuicStringPiece chlo_hash,
                 const net::QuicTagVector& connection_options,
                 std::unique_ptr<Callback> callback) override {
     QuicReferenceCountedPointer<net::ProofSource::Chain> chain;
     net::QuicCryptoProof proof;
     if (success_) {
       std::vector<std::string> certs;
       certs.push_back("Required to establish handshake");
       chain = new ProofSource::Chain(certs);
       proof.signature = "Signature";
       proof.leaf_cert_scts = "Time";
@@ skipping 11 matching lines @@
 class FakeProofVerifier : public net::ProofVerifier {
  public:
   explicit FakeProofVerifier(bool success) : success_(success) {}
 
   // ProofVerifier override
   net::QuicAsyncStatus VerifyProof(
       const std::string& hostname,
       const uint16_t port,
       const std::string& server_config,
       net::QuicVersion quic_version,
-      base::StringPiece chlo_hash,
+      QuicStringPiece chlo_hash,
       const std::vector<std::string>& certs,
       const std::string& cert_sct,
       const std::string& signature,
       const ProofVerifyContext* context,
       std::string* error_details,
       std::unique_ptr<net::ProofVerifyDetails>* verify_details,
       std::unique_ptr<net::ProofVerifierCallback> callback) override {
     return success_ ? net::QUIC_SUCCESS : net::QUIC_FAILURE;
   }
 
@@ skipping 391 matching lines @@
   EXPECT_FALSE(client_peer_->IsClosedStream(id));
   stream->SetDelegate(client_peer_->stream_delegate());
   stream->Close();
   RunLoopWithTimeout();
   EXPECT_TRUE(client_peer_->IsClosedStream(id));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net