Add QuicStringPiece which is actually StringPiece.

net/quic/core/crypto/cert_compressor.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/cert_compressor.h"
 
 #include <cstdint>
 #include <memory>
 
 #include "net/quic/core/quic_utils.h"
 #include "third_party/zlib/zlib.h"
 
-using base::StringPiece;
 using std::string;
 
 namespace net {
 
 namespace {
 
 // kCommonCertSubstrings contains ~1500 bytes of common certificate substrings
 // in order to help zlib. This was generated via a fairly dumb algorithm from
 // the Alexa Top 5000 set - we could probably do better.
 static const unsigned char kCommonCertSubstrings[] = {
@@ skipping 145 matching lines @@
   uint64_t hash;
   uint64_t set_hash;
   uint32_t index;
 };
 
 // MatchCerts returns a vector of CertEntries describing how to most
 // efficiently represent |certs| to a peer who has the common sets identified
 // by |client_common_set_hashes| and who has cached the certificates with the
 // 64-bit, FNV-1a hashes in |client_cached_cert_hashes|.
 std::vector<CertEntry> MatchCerts(const std::vector<string>& certs,
-                                  StringPiece client_common_set_hashes,
-                                  StringPiece client_cached_cert_hashes,
+                                  QuicStringPiece client_common_set_hashes,
+                                  QuicStringPiece client_cached_cert_hashes,
                                   const CommonCertSets* common_sets) {
   std::vector<CertEntry> entries;
   entries.reserve(certs.size());
 
   const bool cached_valid =
       client_cached_cert_hashes.size() % sizeof(uint64_t) == 0 &&
       !client_cached_cert_hashes.empty();
 
   for (std::vector<string>::const_iterator i = certs.begin(); i != certs.end();
        ++i) {
@@ skipping 136 matching lines @@
     ret.push_back(QuicUtils::FNV1a_64_Hash(*i));
   }
 
   return ret;
 }
 
 // ParseEntries parses the serialised form of a vector of CertEntries from
 // |in_out| and writes them to |out_entries|. CACHED and COMMON entries are
 // resolved using |cached_certs| and |common_sets| and written to |out_certs|.
 // |in_out| is updated to contain the trailing data.
-bool ParseEntries(StringPiece* in_out,
+bool ParseEntries(QuicStringPiece* in_out,
                   const std::vector<string>& cached_certs,
                   const CommonCertSets* common_sets,
                   std::vector<CertEntry>* out_entries,
                   std::vector<string>* out_certs) {
-  StringPiece in = *in_out;
+  QuicStringPiece in = *in_out;
   std::vector<uint64_t> cached_hashes;
 
   out_entries->clear();
   out_certs->clear();
 
   for (;;) {
     if (in.empty()) {
       return false;
     }
     CertEntry entry;
@@ skipping 38 matching lines @@
           return false;
         }
         if (in.size() < sizeof(uint64_t) + sizeof(uint32_t)) {
           return false;
         }
         memcpy(&entry.set_hash, in.data(), sizeof(uint64_t));
         in.remove_prefix(sizeof(uint64_t));
         memcpy(&entry.index, in.data(), sizeof(uint32_t));
         in.remove_prefix(sizeof(uint32_t));
 
-        StringPiece cert = common_sets->GetCert(entry.set_hash, entry.index);
+        QuicStringPiece cert =
+            common_sets->GetCert(entry.set_hash, entry.index);
         if (cert.empty()) {
           return false;
         }
         out_certs->push_back(cert.as_string());
         break;
       }
       default:
         return false;
     }
     out_entries->push_back(entry);
@@ skipping 35 matching lines @@
   }
 
   z_stream* z_;
   const Type type_;
 };
 
 }  // anonymous namespace
 
 // static
 string CertCompressor::CompressChain(const std::vector<string>& certs,
-                                     StringPiece client_common_set_hashes,
-                                     StringPiece client_cached_cert_hashes,
+                                     QuicStringPiece client_common_set_hashes,
+                                     QuicStringPiece client_cached_cert_hashes,
                                      const CommonCertSets* common_sets) {
   const std::vector<CertEntry> entries = MatchCerts(
       certs, client_common_set_hashes, client_cached_cert_hashes, common_sets);
   DCHECK_EQ(entries.size(), certs.size());
 
   size_t uncompressed_size = 0;
   for (size_t i = 0; i < entries.size(); i++) {
     if (entries[i].type == CertEntry::COMPRESSED) {
       uncompressed_size += 4 /* uint32_t length */ + certs[i].size();
     }
@@ skipping 78 matching lines @@
   DCHECK_EQ(Z_STREAM_END, rv);
   if (rv != Z_STREAM_END) {
     return "";
   }
 
   result.resize(result.size() - z.avail_out);
   return result;
 }
 
 // static
-bool CertCompressor::DecompressChain(StringPiece in,
+bool CertCompressor::DecompressChain(QuicStringPiece in,
                                      const std::vector<string>& cached_certs,
                                      const CommonCertSets* common_sets,
                                      std::vector<string>* out_certs) {
   std::vector<CertEntry> entries;
   if (!ParseEntries(&in, cached_certs, common_sets, &entries, out_certs)) {
     return false;
   }
   DCHECK_EQ(entries.size(), out_certs->size());
 
   std::unique_ptr<uint8_t[]> uncompressed_data;
-  StringPiece uncompressed;
+  QuicStringPiece uncompressed;
 
   if (!in.empty()) {
     if (in.size() < sizeof(uint32_t)) {
       return false;
     }
 
     uint32_t uncompressed_size;
     memcpy(&uncompressed_size, in.data(), sizeof(uncompressed_size));
     in.remove_prefix(sizeof(uint32_t));
 
@@ skipping 24 matching lines @@
       if (Z_OK != inflateSetDictionary(&z, dict, zlib_dict.size())) {
         return false;
       }
       rv = inflate(&z, Z_FINISH);
     }
 
     if (Z_STREAM_END != rv || z.avail_out > 0 || z.avail_in > 0) {
       return false;
     }
 
-    uncompressed = StringPiece(reinterpret_cast<char*>(uncompressed_data.get()),
-                               uncompressed_size);
+    uncompressed = QuicStringPiece(
+        reinterpret_cast<char*>(uncompressed_data.get()), uncompressed_size);
   }
 
   for (size_t i = 0; i < entries.size(); i++) {
     switch (entries[i].type) {
       case CertEntry::COMPRESSED:
         if (uncompressed.size() < sizeof(uint32_t)) {
           return false;
         }
         uint32_t cert_len;
         memcpy(&cert_len, uncompressed.data(), sizeof(cert_len));
@@ skipping 11 matching lines @@
   }
 
   if (!uncompressed.empty()) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace net