Add QuicStringPiece which is actually StringPiece.

net/tools/quic/quic_client_base.h

 // Copyright (c) 2015 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 base class for the toy client, which connects to a specified port and sends
 // QUIC request to that endpoint.
 
 #ifndef NET_TOOLS_QUIC_QUIC_CLIENT_BASE_H_
 #define NET_TOOLS_QUIC_QUIC_CLIENT_BASE_H_
 
 #include <string>
 
 #include "base/macros.h"
 #include "net/quic/core/crypto/crypto_handshake.h"
 #include "net/quic/core/quic_client_push_promise_index.h"
 #include "net/quic/core/quic_config.h"
 #include "net/quic/platform/api/quic_socket_address.h"
+#include "net/quic/platform/api/quic_string_piece.h"
 #include "net/tools/quic/quic_client_session.h"
 #include "net/tools/quic/quic_spdy_client_stream.h"
 
 namespace net {
 
 class ProofVerifier;
 class QuicServerId;
 
 class QuicClientBase : public QuicClientPushPromiseIndex::Delegate,
                        public QuicSpdyStream::Visitor {
@@ skipping 12 matching lines @@
   // receipt of a stateless reject.  Recall that the client API allows callers
   // to optimistically send data to the server prior to handshake-confirmation.
   // If the client subsequently receives a stateless reject, it must tear down
   // its existing session, create a new session, and resend all previously sent
   // data.  It uses these objects to keep track of all the sent data, and to
   // resend the data upon a subsequent connection.
   class QuicDataToResend {
    public:
     // |headers| may be null, since it's possible to send data without headers.
     QuicDataToResend(std::unique_ptr<SpdyHeaderBlock> headers,
-                     base::StringPiece body,
+                     QuicStringPiece body,
                      bool fin);
 
     virtual ~QuicDataToResend();
 
     // Must be overridden by specific classes with the actual method for
     // re-sending data.
     virtual void Resend() = 0;
 
    protected:
     std::unique_ptr<SpdyHeaderBlock> headers_;
-    base::StringPiece body_;
+    QuicStringPiece body_;
     bool fin_;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(QuicDataToResend);
   };
 
   QuicClientBase(const QuicServerId& server_id,
                  const QuicVersionVector& supported_versions,
                  const QuicConfig& config,
                  QuicConnectionHelperInterface* helper,
@@ skipping 22 matching lines @@
   // Disconnects from the QUIC server.
   void Disconnect();
 
   // Returns true if the crypto handshake has yet to establish encryption.
   // Returns false if encryption is active (even if the server hasn't confirmed
   // the handshake) or if the connection has been closed.
   bool EncryptionBeingEstablished();
 
   // Sends an HTTP request and does not wait for response before returning.
   void SendRequest(const SpdyHeaderBlock& headers,
-                   base::StringPiece body,
+                   QuicStringPiece body,
                    bool fin);
 
   // Sends an HTTP request and waits for response before returning.
   void SendRequestAndWaitForResponse(const SpdyHeaderBlock& headers,
-                                     base::StringPiece body,
+                                     QuicStringPiece body,
                                      bool fin);
 
   // Sends a request simple GET for each URL in |url_list|, and then waits for
   // each to complete.
   void SendRequestsAndWaitForResponse(const std::vector<std::string>& url_list);
 
   // Returns a newly created QuicSpdyClientStream, owned by the
   // QuicSimpleClient.
   virtual QuicSpdyClientStream* CreateClientStream();
 
@@ skipping 194 matching lines @@
   QuicConnectionId GetNextServerDesignatedConnectionId();
 
   // Generates a new, random connection ID (as opposed to a server-designated
   // connection ID).
   virtual QuicConnectionId GenerateNewConnectionId();
 
   // If the crypto handshake has not yet been confirmed, adds the data to the
   // queue of data to resend if the client receives a stateless reject.
   // Otherwise, deletes the data.
   void MaybeAddDataToResend(const SpdyHeaderBlock& headers,
-                            base::StringPiece body,
+                            QuicStringPiece body,
                             bool fin);
 
   void ClearDataToResend();
 
   void ResendSavedData();
 
   void AddPromiseDataToResend(const SpdyHeaderBlock& headers,
-                              base::StringPiece body,
+                              QuicStringPiece body,
                               bool fin);
 
   QuicConnectionHelperInterface* helper() { return helper_.get(); }
 
   QuicAlarmFactory* alarm_factory() { return alarm_factory_.get(); }
 
   void set_num_sent_client_hellos(int num_sent_client_hellos) {
     num_sent_client_hellos_ = num_sent_client_hellos;
   }
 
   void set_num_stateless_rejects_received(int num_stateless_rejects_received) {
     num_stateless_rejects_received_ = num_stateless_rejects_received;
   }
 
  private:
   // Specific QuicClient class for storing data to resend.
   class ClientQuicDataToResend : public QuicDataToResend {
    public:
     ClientQuicDataToResend(std::unique_ptr<SpdyHeaderBlock> headers,
-                           base::StringPiece body,
+                           QuicStringPiece body,
                            bool fin,
                            QuicClientBase* client)
         : QuicDataToResend(std::move(headers), body, fin), client_(client) {
       DCHECK(headers_);
       DCHECK(client);
     }
 
     ~ClientQuicDataToResend() override {}
 
     void Resend() override;
@@ skipping 94 matching lines @@
   std::vector<std::unique_ptr<QuicDataToResend>> data_to_resend_on_connect_;
 
   std::unique_ptr<ClientQuicDataToResend> push_promise_data_to_resend_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicClientBase);
 };
 
 }  // namespace net
 
 #endif  // NET_TOOLS_QUIC_QUIC_CLIENT_BASE_H_