Add QuicStringPiece which is actually StringPiece.

net/tools/quic/test_tools/quic_test_client.h

 // 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.
 
 #ifndef NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_
 #define NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_
 
 #include <cstdint>
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
 #include "net/quic/core/proto/cached_network_parameters.pb.h"
 #include "net/quic/core/quic_framer.h"
 #include "net/quic/core/quic_packet_creator.h"
 #include "net/quic/core/quic_packets.h"
+#include "net/quic/platform/api/quic_string_piece.h"
 #include "net/tools/quic/quic_client.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
-using base::StringPiece;
-
 namespace net {
 
 class ProofVerifier;
 class QuicPacketWriterWrapper;
 
 namespace test {
 
 // A quic client which allows mocking out reads and writes.
 class MockableQuicClient : public QuicClient {
  public:
@@ skipping 78 matching lines @@
   // Clears any outstanding state and sends a simple GET of 'uri' to the
   // server.  Returns 0 if the request failed and no bytes were written.
   ssize_t SendRequest(const std::string& uri);
   // Sends requests for all the urls and waits for the responses.  To process
   // the individual responses as they are returned, the caller should use the
   // set the response_listener on the client().
   void SendRequestsAndWaitForResponses(
       const std::vector<std::string>& url_list);
   // Sends a request containing |headers| and |body| and returns the number of
   // bytes sent (the size of the serialized request headers and body).
-  ssize_t SendMessage(const SpdyHeaderBlock& headers, base::StringPiece body);
+  ssize_t SendMessage(const SpdyHeaderBlock& headers, QuicStringPiece body);
   // Sends a request containing |headers| and |body| with the fin bit set to
   // |fin| and returns the number of bytes sent (the size of the serialized
   // request headers and body).
   ssize_t SendMessage(const SpdyHeaderBlock& headers,
-                      base::StringPiece body,
+                      QuicStringPiece body,
                       bool fin);
   // Sends a request containing |headers| and |body|, waits for the response,
   // and returns the response body.
   std::string SendCustomSynchronousRequest(const SpdyHeaderBlock& headers,
                                            const std::string& body);
   // Sends a GET request for |uri|, waits for the response, and returns the
   // response body.
   std::string SendSynchronousRequest(const std::string& uri);
   void Connect();
   void ResetConnection();
@@ skipping 65 matching lines @@
   // Update internal stream_ pointer and perform accompanying housekeeping.
   void SetStream(QuicSpdyClientStream* stream);
   // Returns nullptr if the maximum number of streams have already been created.
   QuicSpdyClientStream* GetOrCreateStream();
 
   // Calls GetOrCreateStream(), sends the request on the stream, and
   // stores the request in case it needs to be resent.  If |headers| is
   // null, only the body will be sent on the stream.
   ssize_t GetOrCreateStreamAndSendRequest(
       const SpdyHeaderBlock* headers,
-      base::StringPiece body,
+      QuicStringPiece body,
       bool fin,
       QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
 
   QuicRstStreamErrorCode stream_error() { return stream_error_; }
   QuicErrorCode connection_error();
 
   MockableQuicClient* client();
 
   // cert_common_name returns the common name value of the server's certificate,
   // or the empty string if no certificate was presented.
@@ skipping 42 matching lines @@
   void set_client(MockableQuicClient* client) { client_.reset(client); }
 
  protected:
   QuicTestClient();
 
  private:
   class TestClientDataToResend : public QuicClient::QuicDataToResend {
    public:
     TestClientDataToResend(
         std::unique_ptr<SpdyHeaderBlock> headers,
-        base::StringPiece body,
+        QuicStringPiece body,
         bool fin,
         QuicTestClient* test_client,
         QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
 
     ~TestClientDataToResend() override;
 
     void Resend() override;
 
    protected:
     QuicTestClient* test_client_;
@@ skipping 54 matching lines @@
   std::string override_sni_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicTestClient);
 };
 
 }  // namespace test
 
 }  // namespace net
 
 #endif  // NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_