Add QuicStringPiece which is actually StringPiece.

net/quic/quartc/quartc_session.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/rand_util.h"
+#include "net/quic/platform/api/quic_string_piece.h"
 
 namespace {
 
 // Default priority for incoming QUIC streams.
 // TODO(zhihuang): Determine if this value is correct.
 static const net::SpdyPriority kDefaultPriority = 3;
 
 // Arbitrary server port number for net::QuicCryptoClientConfig.
 const int kQuicServerPort = 0;
 
 // Length of HKDF input keying material, equal to its number of bytes.
 // https://tools.ietf.org/html/rfc5869#section-2.2.
 // TODO(zhihuang): Verify that input keying material length is correct.
 const size_t kInputKeyingMaterialLength = 32;
 
 // Used by QuicCryptoServerConfig to provide dummy proof credentials.
 // TODO(zhihuang): Remove when secure P2P QUIC handshake is possible.
 class DummyProofSource : public net::ProofSource {
  public:
   DummyProofSource() {}
   ~DummyProofSource() override {}
 
   // ProofSource override.
   void GetProof(const net::QuicSocketAddress& server_addr,
                 const std::string& hostname,
                 const std::string& server_config,
                 net::QuicVersion quic_version,
-                base::StringPiece chlo_hash,
+                net::QuicStringPiece chlo_hash,
                 const net::QuicTagVector& connection_options,
                 std::unique_ptr<Callback> callback) override {
     net::QuicReferenceCountedPointer<net::ProofSource::Chain> chain;
     net::QuicCryptoProof proof;
     std::vector<std::string> certs;
     certs.push_back("Dummy cert");
     chain = new ProofSource::Chain(certs);
     proof.signature = "Dummy signature";
     proof.leaf_cert_scts = "Dummy timestamp";
     callback->Run(true, chain, proof, nullptr /* details */);
   }
 };
 
 // Used by QuicCryptoClientConfig to ignore the peer's credentials
 // and establish an insecure QUIC connection.
 // TODO(zhihuang): Remove when secure P2P QUIC handshake is possible.
 class InsecureProofVerifier : public net::ProofVerifier {
  public:
   InsecureProofVerifier() {}
   ~InsecureProofVerifier() override {}
 
   // 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,
+      net::QuicStringPiece chlo_hash,
       const std::vector<std::string>& certs,
       const std::string& cert_sct,
       const std::string& signature,
       const net::ProofVerifyContext* context,
       std::string* error_details,
       std::unique_ptr<net::ProofVerifyDetails>* verify_details,
       std::unique_ptr<net::ProofVerifierCallback> callback) override {
     return net::QUIC_SUCCESS;
   }
 
@@ skipping 201 matching lines @@
     ActivateStream(std::unique_ptr<QuicStream>(stream));
     // Register the stream to the QuicWriteBlockedList. |priority| is clamped
     // between 0 and 7, with 0 being the highest priority and 7 the lowest
     // priority.
     write_blocked_streams()->RegisterStream(stream->id(), priority);
   }
   return stream;
 }
 
 }  // namespace net