Add QuicStringPiece which is actually StringPiece.

net/tools/quic/quic_simple_client_bin.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.
 
 // A binary wrapper for QuicClient.
 // Connects to a host using QUIC, sends a request to the provided URL, and
 // displays the response.
 //
 // Some usage examples:
 //
@@ skipping 39 matching lines @@
 #include "net/cert/ct_known_logs.h"
 #include "net/cert/ct_log_verifier.h"
 #include "net/cert/multi_log_ct_verifier.h"
 #include "net/http/transport_security_state.h"
 #include "net/quic/chromium/crypto/proof_verifier_chromium.h"
 #include "net/quic/core/quic_error_codes.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_server_id.h"
 #include "net/quic/platform/api/quic_socket_address.h"
 #include "net/quic/platform/api/quic_str_cat.h"
+#include "net/quic/platform/api/quic_string_piece.h"
 #include "net/quic/platform/api/quic_text_utils.h"
 #include "net/spdy/spdy_header_block.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/tools/quic/quic_simple_client.h"
 #include "net/tools/quic/synchronous_host_resolver.h"
 #include "url/gurl.h"
 
-using base::StringPiece;
 using net::CertVerifier;
 using net::CTPolicyEnforcer;
 using net::CTVerifier;
 using net::MultiLogCTVerifier;
 using net::ProofVerifier;
 using net::ProofVerifierChromium;
+using net::QuicStringPiece;
 using net::QuicTextUtils;
 using net::SpdyHeaderBlock;
 using net::TransportSecurityState;
 using std::cout;
 using std::cerr;
 using std::endl;
 using std::string;
 
 // The IP or hostname the quic client will connect to.
 string FLAGS_host = "";
@@ skipping 20 matching lines @@
 // Initial MTU of the connection.
 int32_t FLAGS_initial_mtu = 0;
 
 class FakeProofVerifier : public ProofVerifier {
  public:
   net::QuicAsyncStatus VerifyProof(
       const string& hostname,
       const uint16_t port,
       const string& server_config,
       net::QuicVersion quic_version,
-      StringPiece chlo_hash,
+      QuicStringPiece chlo_hash,
       const std::vector<string>& certs,
       const string& cert_sct,
       const string& signature,
       const net::ProofVerifyContext* context,
       string* error_details,
       std::unique_ptr<net::ProofVerifyDetails>* details,
       std::unique_ptr<net::ProofVerifierCallback> callback) override {
     return net::QUIC_SUCCESS;
   }
 
@@ skipping 176 matching lines @@
   }
 
   // Construct a GET or POST request for supplied URL.
   SpdyHeaderBlock header_block;
   header_block[":method"] = body.empty() ? "GET" : "POST";
   header_block[":scheme"] = url.scheme();
   header_block[":authority"] = url.host();
   header_block[":path"] = url.path();
 
   // Append any additional headers supplied on the command line.
-  for (StringPiece sp : QuicTextUtils::Split(FLAGS_headers, ';')) {
+  for (QuicStringPiece sp : QuicTextUtils::Split(FLAGS_headers, ';')) {
     QuicTextUtils::RemoveLeadingAndTrailingWhitespace(&sp);
     if (sp.empty()) {
       continue;
     }
-    std::vector<StringPiece> kv = QuicTextUtils::Split(sp, ':');
+    std::vector<QuicStringPiece> kv = QuicTextUtils::Split(sp, ':');
     QuicTextUtils::RemoveLeadingAndTrailingWhitespace(&kv[0]);
     QuicTextUtils::RemoveLeadingAndTrailingWhitespace(&kv[1]);
     header_block[kv[0]] = kv[1];
   }
 
   // Make sure to store the response, for later output.
   client.set_store_response(true);
 
   // Send the request.
   client.SendRequestAndWaitForResponse(header_block, body, /*fin=*/true);
@@ skipping 33 matching lines @@
       return 0;
     } else {
       cout << "Request failed (redirect " << response_code << ")." << endl;
       return 1;
     }
   } else {
     cerr << "Request failed (" << response_code << ")." << endl;
     return 1;
   }
 }