Add QuicStringPiece which is actually StringPiece.

net/tools/quic/test_tools/quic_test_client.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/tools/quic/test_tools/quic_test_client.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 11 matching lines @@
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_stream_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
 #include "net/tools/quic/quic_packet_writer_wrapper.h"
 #include "net/tools/quic/quic_spdy_client_stream.h"
 #include "net/tools/quic/test_tools/quic_client_peer.h"
 #include "third_party/boringssl/src/include/openssl/x509.h"
 
-using base::StringPiece;
 using std::string;
 using testing::_;
 using testing::Invoke;
 
 namespace net {
 namespace test {
 namespace {
 
 // RecordingProofVerifier accepts any certificate chain and records the common
 // name of the leaf and then delegates the actual verfication to an actual
 // verifier. If no optional verifier is provided, then VerifyProof will return
 // success.
 class RecordingProofVerifier : public ProofVerifier {
  public:
   explicit RecordingProofVerifier(std::unique_ptr<ProofVerifier> verifier)
       : verifier_(std::move(verifier)) {}
 
   // ProofVerifier interface.
   QuicAsyncStatus VerifyProof(
       const string& hostname,
       const uint16_t port,
       const string& server_config,
       QuicVersion quic_version,
-      StringPiece chlo_hash,
+      QuicStringPiece chlo_hash,
       const std::vector<string>& certs,
       const string& cert_sct,
       const string& signature,
       const ProofVerifyContext* context,
       string* error_details,
       std::unique_ptr<ProofVerifyDetails>* details,
       std::unique_ptr<ProofVerifierCallback> callback) override {
     common_name_.clear();
     if (certs.empty()) {
       return QUIC_FAILURE;
     }
 
     // Convert certs to X509Certificate.
-    std::vector<StringPiece> cert_pieces(certs.size());
+    std::vector<QuicStringPiece> cert_pieces(certs.size());
     for (unsigned i = 0; i < certs.size(); i++) {
-      cert_pieces[i] = StringPiece(certs[i]);
+      cert_pieces[i] = QuicStringPiece(certs[i]);
     }
     // TODO(rtenneti): Fix after adding support for real certs. Currently,
     // cert_pieces are "leaf" and "intermediate" and CreateFromDERCertChain
     // fails to return cert from these cert_pieces.
     //    bssl::UniquePtr<X509> cert(d2i_X509(nullptr, &data, certs[0].size()));
     //    if (!cert.get()) {
     //      return QUIC_FAILURE;
     //    }
     //
     //    common_name_ = cert->subject().GetDisplayName();
@@ skipping 200 matching lines @@
   for (const string& url : url_list) {
     SendRequest(url);
   }
   while (client()->WaitForEvents()) {
   }
   return;
 }
 
 ssize_t QuicTestClient::GetOrCreateStreamAndSendRequest(
     const SpdyHeaderBlock* headers,
-    StringPiece body,
+    QuicStringPiece body,
     bool fin,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   if (headers) {
     QuicClientPushPromiseIndex::TryHandle* handle;
     QuicAsyncStatus rv =
         client()->push_promise_index()->Try(*headers, this, &handle);
     if (rv == QUIC_SUCCESS)
       return 1;
     if (rv == QUIC_PENDING) {
       // May need to retry request if asynchronous rendezvous fails.
@@ skipping 32 matching lines @@
     }
     std::unique_ptr<QuicClientBase::QuicDataToResend> data_to_resend(
         new TestClientDataToResend(std::move(new_headers), body, fin, this,
                                    ack_listener));
     client()->MaybeAddQuicDataToResend(std::move(data_to_resend));
   }
   return ret;
 }
 
 ssize_t QuicTestClient::SendMessage(const SpdyHeaderBlock& headers,
-                                    StringPiece body) {
+                                    QuicStringPiece body) {
   return SendMessage(headers, body, /*fin=*/true);
 }
 
 ssize_t QuicTestClient::SendMessage(const SpdyHeaderBlock& headers,
-                                    StringPiece body,
+                                    QuicStringPiece body,
                                     bool fin) {
   stream_ = nullptr;  // Always force creation of a stream for SendMessage.
   // Any response we might have received for a previous request would no longer
   // be valid.  TODO(jeffpiazza): There's probably additional client state that
   // should be reset here, too, if we were being more careful.
   response_complete_ = false;
 
   // If we're not connected, try to find an sni hostname.
   if (!connected()) {
     QuicUrl url(SpdyUtils::GetUrlFromHeaderBlock(headers));
     if (override_sni_set_) {
       client_->set_server_id(
           QuicServerId(override_sni_, url.port(), PRIVACY_MODE_DISABLED));
     }
   }
 
   ssize_t ret = GetOrCreateStreamAndSendRequest(&headers, body, fin, nullptr);
   WaitForWriteToFlush();
   return ret;
 }
 
 ssize_t QuicTestClient::SendData(const string& data, bool last_data) {
   return SendData(data, last_data, nullptr);
 }
 
 ssize_t QuicTestClient::SendData(
     const string& data,
     bool last_data,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
-  return GetOrCreateStreamAndSendRequest(nullptr, StringPiece(data), last_data,
-                                         std::move(ack_listener));
+  return GetOrCreateStreamAndSendRequest(nullptr, QuicStringPiece(data),
+                                         last_data, std::move(ack_listener));
 }
 
 bool QuicTestClient::response_complete() const {
   return response_complete_;
 }
 
 int64_t QuicTestClient::response_body_size() const {
   return response_body_size_;
 }
 
@@ skipping 283 matching lines @@
 }
 
 void QuicTestClient::WaitForWriteToFlush() {
   while (connected() && client()->session()->HasDataToWrite()) {
     client_->WaitForEvents();
   }
 }
 
 QuicTestClient::TestClientDataToResend::TestClientDataToResend(
     std::unique_ptr<SpdyHeaderBlock> headers,
-    base::StringPiece body,
+    QuicStringPiece body,
     bool fin,
     QuicTestClient* test_client,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener)
     : QuicClient::QuicDataToResend(std::move(headers), body, fin),
       test_client_(test_client),
       ack_listener_(std::move(ack_listener)) {}
 
 QuicTestClient::TestClientDataToResend::~TestClientDataToResend() {}
 
 void QuicTestClient::TestClientDataToResend::Resend() {
@@ skipping 11 matching lines @@
   } else if (uri[0] == '/') {
     url = "https://" + client_->server_id().host() + uri;
   } else {
     url = "https://" + uri;
   }
   return SpdyUtils::PopulateHeaderBlockFromUrl(url, headers);
 }
 
 }  // namespace test
 }  // namespace net