Add QuicStringPiece which is actually StringPiece.

net/quic/core/crypto/crypto_handshake_message.cc

 // 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.
 
 #include "net/quic/core/crypto/crypto_handshake_message.h"
 
 #include <memory>
 
 #include "net/quic/core/crypto/crypto_framer.h"
 #include "net/quic/core/crypto/crypto_protocol.h"
 #include "net/quic/core/crypto/crypto_utils.h"
 #include "net/quic/core/quic_socket_address_coder.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/platform/api/quic_map_util.h"
 #include "net/quic/platform/api/quic_str_cat.h"
 #include "net/quic/platform/api/quic_text_utils.h"
 
-using base::StringPiece;
 using std::string;
 
 namespace net {
 
 CryptoHandshakeMessage::CryptoHandshakeMessage() : tag_(0), minimum_size_(0) {}
 
 CryptoHandshakeMessage::CryptoHandshakeMessage(
     const CryptoHandshakeMessage& other)
     : tag_(other.tag_),
       tag_value_map_(other.tag_value_map_),
@@ skipping 32 matching lines @@
   if (!serialized_.get()) {
     serialized_.reset(CryptoFramer::ConstructHandshakeMessage(*this));
   }
   return *serialized_;
 }
 
 void CryptoHandshakeMessage::MarkDirty() {
   serialized_.reset();
 }
 
-void CryptoHandshakeMessage::SetStringPiece(QuicTag tag, StringPiece value) {
+void CryptoHandshakeMessage::SetStringPiece(QuicTag tag,
+                                            QuicStringPiece value) {
   tag_value_map_[tag] = value.as_string();
 }
 
 void CryptoHandshakeMessage::Erase(QuicTag tag) {
   tag_value_map_.erase(tag);
 }
 
 QuicErrorCode CryptoHandshakeMessage::GetTaglist(QuicTag tag,
                                                  const QuicTag** out_tags,
                                                  size_t* out_len) const {
@@ skipping 11 matching lines @@
     *out_len = 0;
     return ret;
   }
 
   *out_tags = reinterpret_cast<const QuicTag*>(it->second.data());
   *out_len = it->second.size() / sizeof(QuicTag);
   return ret;
 }
 
 bool CryptoHandshakeMessage::GetStringPiece(QuicTag tag,
-                                            StringPiece* out) const {
+                                            QuicStringPiece* out) const {
   QuicTagValueMap::const_iterator it = tag_value_map_.find(tag);
   if (it == tag_value_map_.end()) {
     return false;
   }
   *out = it->second;
   return true;
 }
 
 bool CryptoHandshakeMessage::HasStringPiece(QuicTag tag) const {
   return QuicContainsKey(tag_value_map_, tag);
 }
 
-QuicErrorCode CryptoHandshakeMessage::GetNthValue24(QuicTag tag,
-                                                    unsigned index,
-                                                    StringPiece* out) const {
-  StringPiece value;
+QuicErrorCode CryptoHandshakeMessage::GetNthValue24(
+    QuicTag tag,
+    unsigned index,
+    QuicStringPiece* out) const {
+  QuicStringPiece value;
   if (!GetStringPiece(tag, &value)) {
     return QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND;
   }
 
   for (unsigned i = 0;; i++) {
     if (value.empty()) {
       return QUIC_CRYPTO_MESSAGE_INDEX_NOT_FOUND;
     }
     if (value.size() < 3) {
       return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
     }
 
     const unsigned char* data =
         reinterpret_cast<const unsigned char*>(value.data());
     size_t size = static_cast<size_t>(data[0]) |
                   (static_cast<size_t>(data[1]) << 8) |
                   (static_cast<size_t>(data[2]) << 16);
     value.remove_prefix(3);
 
     if (value.size() < size) {
       return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
     }
 
     if (i == index) {
-      *out = StringPiece(value.data(), size);
+      *out = QuicStringPiece(value.data(), size);
       return QUIC_NO_ERROR;
     }
 
     value.remove_prefix(size);
   }
 }
 
 QuicErrorCode CryptoHandshakeMessage::GetUint32(QuicTag tag,
                                                 uint32_t* out) const {
   return GetPOD(tag, out, sizeof(uint32_t));
@@ skipping 165 matching lines @@
       ret += "0x" + QuicTextUtils::HexEncode(it->second);
     }
     ret += "\n";
   }
   --indent;
   ret += string(2 * indent, ' ') + ">";
   return ret;
 }
 
 }  // namespace net