Add QuicStringPiece which is actually StringPiece.

net/tools/quic/quic_client_base.cc

 // 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.
 
 #include "net/tools/quic/quic_client_base.h"
 
 #include "net/quic/core/crypto/quic_random.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_server_id.h"
 #include "net/quic/core/spdy_utils.h"
 #include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_text_utils.h"
 
-using base::StringPiece;
 using base::StringToInt;
 using std::string;
 
 namespace net {
 
 void QuicClientBase::ClientQuicDataToResend::Resend() {
   client_->SendRequest(*headers_, body_, fin_);
   headers_ = nullptr;
 }
 
 QuicClientBase::QuicDataToResend::QuicDataToResend(
     std::unique_ptr<SpdyHeaderBlock> headers,
-    StringPiece body,
+    QuicStringPiece body,
     bool fin)
     : headers_(std::move(headers)), body_(body), fin_(fin) {}
 
 QuicClientBase::QuicDataToResend::~QuicDataToResend() {}
 
 QuicClientBase::QuicClientBase(const QuicServerId& server_id,
                                const QuicVersionVector& supported_versions,
                                const QuicConfig& config,
                                QuicConnectionHelperInterface* helper,
                                QuicAlarmFactory* alarm_factory,
@@ skipping 162 matching lines @@
   }
   return session_.get();
 }
 
 bool QuicClientBase::EncryptionBeingEstablished() {
   return !session_->IsEncryptionEstablished() &&
          session_->connection()->connected();
 }
 
 void QuicClientBase::SendRequest(const SpdyHeaderBlock& headers,
-                                 StringPiece body,
+                                 QuicStringPiece body,
                                  bool fin) {
   QuicClientPushPromiseIndex::TryHandle* handle;
   QuicAsyncStatus rv = push_promise_index()->Try(headers, this, &handle);
   if (rv == QUIC_SUCCESS)
     return;
 
   if (rv == QUIC_PENDING) {
     // May need to retry request if asynchronous rendezvous fails.
     AddPromiseDataToResend(headers, body, fin);
     return;
   }
 
   QuicSpdyClientStream* stream = CreateClientStream();
   if (stream == nullptr) {
     QUIC_BUG << "stream creation failed!";
     return;
   }
   stream->SendRequest(headers.Clone(), body, fin);
   // Record this in case we need to resend.
   MaybeAddDataToResend(headers, body, fin);
 }
 
 void QuicClientBase::SendRequestAndWaitForResponse(
     const SpdyHeaderBlock& headers,
-    StringPiece body,
+    QuicStringPiece body,
     bool fin) {
   SendRequest(headers, body, fin);
   while (WaitForEvents()) {
   }
 }
 
 void QuicClientBase::SendRequestsAndWaitForResponse(
     const std::vector<string>& url_list) {
   for (size_t i = 0; i < url_list.size(); ++i) {
     SpdyHeaderBlock headers;
@@ skipping 142 matching lines @@
   return cached->has_server_designated_connection_id()
              ? cached->GetNextServerDesignatedConnectionId()
              : 0;
 }
 
 QuicConnectionId QuicClientBase::GenerateNewConnectionId() {
   return QuicRandom::GetInstance()->RandUint64();
 }
 
 void QuicClientBase::MaybeAddDataToResend(const SpdyHeaderBlock& headers,
-                                          StringPiece body,
+                                          QuicStringPiece body,
                                           bool fin) {
   if (!FLAGS_quic_reloadable_flag_enable_quic_stateless_reject_support) {
     return;
   }
 
   if (session()->IsCryptoHandshakeConfirmed()) {
     // The handshake is confirmed.  No need to continue saving requests to
     // resend.
     data_to_resend_on_connect_.clear();
     return;
@@ skipping 21 matching lines @@
   // Calling Resend will re-enqueue the data, so swap out
   //  data_to_resend_on_connect_ before iterating.
   std::vector<std::unique_ptr<QuicDataToResend>> old_data;
   old_data.swap(data_to_resend_on_connect_);
   for (const auto& data : old_data) {
     data->Resend();
   }
 }
 
 void QuicClientBase::AddPromiseDataToResend(const SpdyHeaderBlock& headers,
-                                            StringPiece body,
+                                            QuicStringPiece body,
                                             bool fin) {
   std::unique_ptr<SpdyHeaderBlock> new_headers(
       new SpdyHeaderBlock(headers.Clone()));
   push_promise_data_to_resend_.reset(
       new ClientQuicDataToResend(std::move(new_headers), body, fin, this));
 }
 
 bool QuicClientBase::CheckVary(const SpdyHeaderBlock& client_request,
                                const SpdyHeaderBlock& promise_request,
                                const SpdyHeaderBlock& promise_response) {
@@ skipping 35 matching lines @@
   QUIC_BUG_IF(!store_response_) << "Response not stored!";
   return latest_response_body_;
 }
 
 const string& QuicClientBase::latest_response_trailers() const {
   QUIC_BUG_IF(!store_response_) << "Response not stored!";
   return latest_response_trailers_;
 }
 
 }  // namespace net