Add QuicStringPiece which is actually StringPiece.

net/quic/core/crypto/crypto_handshake_message.h

 // Copyright (c) 2013 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_CRYPTO_CRYPTO_HANDSHAKE_MESSAGE_H_
 #define NET_QUIC_CORE_CRYPTO_CRYPTO_HANDSHAKE_MESSAGE_H_
 
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <vector>
 
-#include "base/strings/string_piece.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/platform/api/quic_export.h"
+#include "net/quic/platform/api/quic_string_piece.h"
 
 namespace net {
 
 // An intermediate format of a handshake message that's convenient for a
 // CryptoFramer to serialize from or parse into.
 class QUIC_EXPORT_PRIVATE CryptoHandshakeMessage {
  public:
   CryptoHandshakeMessage();
   CryptoHandshakeMessage(const CryptoHandshakeMessage& other);
   CryptoHandshakeMessage(CryptoHandshakeMessage&& other);
@@ skipping 32 matching lines @@
     }
   }
 
   // Returns the message tag.
   QuicTag tag() const { return tag_; }
   // Sets the message tag.
   void set_tag(QuicTag tag) { tag_ = tag; }
 
   const QuicTagValueMap& tag_value_map() const { return tag_value_map_; }
 
-  void SetStringPiece(QuicTag tag, base::StringPiece value);
+  void SetStringPiece(QuicTag tag, QuicStringPiece value);
 
   // Erase removes a tag/value, if present, from the message.
   void Erase(QuicTag tag);
 
   // GetTaglist finds an element with the given tag containing zero or more
   // tags. If such a tag doesn't exist, it returns an error code. Otherwise it
   // sets |out_tags| and |out_len| to point to the array of tags and returns
   // QUIC_NO_ERROR.  The array points into the CryptoHandshakeMessage and is
   // valid only for as long as the CryptoHandshakeMessage exists and is not
   // modified.
   QuicErrorCode GetTaglist(QuicTag tag,
                            const QuicTag** out_tags,
                            size_t* out_len) const;
 
-  bool GetStringPiece(QuicTag tag, base::StringPiece* out) const;
+  bool GetStringPiece(QuicTag tag, QuicStringPiece* out) const;
   bool HasStringPiece(QuicTag tag) const;
 
   // GetNthValue24 interprets the value with the given tag to be a series of
   // 24-bit, length prefixed values and it returns the subvalue with the given
   // index.
   QuicErrorCode GetNthValue24(QuicTag tag,
                               unsigned index,
-                              base::StringPiece* out) const;
+                              QuicStringPiece* out) const;
   QuicErrorCode GetUint32(QuicTag tag, uint32_t* out) const;
   QuicErrorCode GetUint64(QuicTag tag, uint64_t* out) const;
 
   // size returns 4 (message tag) + 2 (uint16_t, number of entries) +
   // (4 (tag) + 4 (end offset))*tag_value_map_.size() + ∑ value sizes.
   size_t size() const;
 
   // set_minimum_size sets the minimum number of bytes that the message should
   // consume. The CryptoFramer will add a PAD tag as needed when serializing in
   // order to ensure this. Setting a value of 0 disables padding.
@@ skipping 27 matching lines @@
   size_t minimum_size_;
 
   // The serialized form of the handshake message. This member is constructed
   // lasily.
   mutable std::unique_ptr<QuicData> serialized_;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_CRYPTO_CRYPTO_HANDSHAKE_MESSAGE_H_