Add QuicStringPiece which is actually StringPiece.

net/quic/core/quic_packets.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_QUIC_CORE_QUIC_PACKETS_H_
 #define NET_QUIC_CORE_QUIC_PACKETS_H_
 
 #include <cstdint>
 #include <limits>
 #include <list>
 #include <memory>
 #include <ostream>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
-#include "base/strings/string_piece.h"
 #include "net/base/iovec.h"
 #include "net/quic/core/frames/quic_frame.h"
 #include "net/quic/core/quic_ack_listener_interface.h"
 #include "net/quic/core/quic_bandwidth.h"
 #include "net/quic/core/quic_constants.h"
 #include "net/quic/core/quic_error_codes.h"
 #include "net/quic/core/quic_time.h"
 #include "net/quic/core/quic_types.h"
 #include "net/quic/core/quic_versions.h"
 #include "net/quic/platform/api/quic_export.h"
 #include "net/quic/platform/api/quic_socket_address.h"
+#include "net/quic/platform/api/quic_string_piece.h"
 
 namespace net {
 
 class QuicPacket;
 struct QuicPacketHeader;
 
 // Size in bytes of the data packet header.
 QUIC_EXPORT_PRIVATE size_t GetPacketHeaderSize(QuicVersion version,
                                                const QuicPacketHeader& header);
 
@@ skipping 61 matching lines @@
 };
 
 typedef QuicPacketPublicHeader QuicVersionNegotiationPacket;
 
 class QUIC_EXPORT_PRIVATE QuicData {
  public:
   QuicData(const char* buffer, size_t length);
   QuicData(const char* buffer, size_t length, bool owns_buffer);
   virtual ~QuicData();
 
-  base::StringPiece AsStringPiece() const {
-    return base::StringPiece(data(), length());
+  QuicStringPiece AsStringPiece() const {
+    return QuicStringPiece(data(), length());
   }
 
   const char* data() const { return buffer_; }
   size_t length() const { return length_; }
 
  private:
   const char* buffer_;
   size_t length_;
   bool owns_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicData);
 };
 
 class QUIC_EXPORT_PRIVATE QuicPacket : public QuicData {
  public:
   // TODO(fayang): 3 fields from public header are passed in as arguments.
   // Consider to add a convenience method which directly accepts the entire
   // public header.
   QuicPacket(char* buffer,
              size_t length,
              bool owns_buffer,
              QuicConnectionIdLength connection_id_length,
              bool includes_version,
              bool includes_diversification_nonce,
              QuicPacketNumberLength packet_number_length);
 
-  base::StringPiece AssociatedData(QuicVersion version) const;
-  base::StringPiece Plaintext(QuicVersion version) const;
+  QuicStringPiece AssociatedData(QuicVersion version) const;
+  QuicStringPiece Plaintext(QuicVersion version) const;
 
   char* mutable_data() { return buffer_; }
 
  private:
   char* buffer_;
   const QuicConnectionIdLength connection_id_length_;
   const bool includes_version_;
   const bool includes_diversification_nonce_;
   const QuicPacketNumberLength packet_number_length_;
 
@@ skipping 97 matching lines @@
 QUIC_EXPORT_PRIVATE void ClearSerializedPacket(
     SerializedPacket* serialized_packet);
 
 // Allocates a new char[] of size |packet.encrypted_length| and copies in
 // |packet.encrypted_buffer|.
 QUIC_EXPORT_PRIVATE char* CopyBuffer(const SerializedPacket& packet);
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_QUIC_PACKETS_H_