Add QuicStringPiece which is actually StringPiece.

net/quic/core/quic_utils.cc

 // 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.
 
 #include "net/quic/core/quic_utils.h"
 
 #include <algorithm>
 #include <cstdint>
 #include <vector>
 
 #include "base/containers/adapters.h"
 #include "base/logging.h"
 #include "net/quic/core/quic_constants.h"
 #include "net/quic/core/quic_flags.h"
 
-using base::StringPiece;
 using std::string;
 
 namespace net {
 namespace {
 
 // We know that >= GCC 4.8 and Clang have a __uint128_t intrinsic. Other
 // compilers don't necessarily, notably MSVC.
 #if defined(__x86_64__) &&                                         \
     ((defined(__GNUC__) &&                                         \
       (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))) || \
      defined(__clang__))
 #define QUIC_UTIL_HAS_UINT128 1
 #endif
 
 #ifdef QUIC_UTIL_HAS_UINT128
-uint128 IncrementalHashFast(uint128 uhash, StringPiece data) {
+uint128 IncrementalHashFast(uint128 uhash, QuicStringPiece data) {
   // This code ends up faster than the naive implementation for 2 reasons:
   // 1. uint128 from base/int128.h is sufficiently complicated that the compiler
   //    cannot transform the multiplication by kPrime into a shift-multiply-add;
   //    it has go through all of the instructions for a 128-bit multiply.
   // 2. Because there are so fewer instructions (around 13), the hot loop fits
   //    nicely in the instruction queue of many Intel CPUs.
   // kPrime = 309485009821345068724781371
   static const __uint128_t kPrime =
       (static_cast<__uint128_t>(16777216) << 64) + 315;
   __uint128_t xhash = (static_cast<__uint128_t>(Uint128High64(uhash)) << 64) +
                       Uint128Low64(uhash);
   const uint8_t* octets = reinterpret_cast<const uint8_t*>(data.data());
   for (size_t i = 0; i < data.length(); ++i) {
     xhash = (xhash ^ octets[i]) * kPrime;
   }
   return MakeUint128(
       static_cast<uint64_t>(xhash >> 64),
       static_cast<uint64_t>(xhash & UINT64_C(0xFFFFFFFFFFFFFFFF)));
 }
 #endif
 
 #ifndef QUIC_UTIL_HAS_UINT128
 // Slow implementation of IncrementalHash. In practice, only used by Chromium.
-uint128 IncrementalHashSlow(uint128 hash, StringPiece data) {
+uint128 IncrementalHashSlow(uint128 hash, QuicStringPiece data) {
   // kPrime = 309485009821345068724781371
   static const uint128 kPrime = MakeUint128(16777216, 315);
   const uint8_t* octets = reinterpret_cast<const uint8_t*>(data.data());
   for (size_t i = 0; i < data.length(); ++i) {
     hash = hash ^ MakeUint128(0, octets[i]);
     hash = hash * kPrime;
   }
   return hash;
 }
 #endif
 
-uint128 IncrementalHash(uint128 hash, StringPiece data) {
+uint128 IncrementalHash(uint128 hash, QuicStringPiece data) {
 #ifdef QUIC_UTIL_HAS_UINT128
   return IncrementalHashFast(hash, data);
 #else
   return IncrementalHashSlow(hash, data);
 #endif
 }
 
 }  // namespace
 
 // static
-uint64_t QuicUtils::FNV1a_64_Hash(StringPiece data) {
+uint64_t QuicUtils::FNV1a_64_Hash(QuicStringPiece data) {
   static const uint64_t kOffset = UINT64_C(14695981039346656037);
   static const uint64_t kPrime = UINT64_C(1099511628211);
 
   const uint8_t* octets = reinterpret_cast<const uint8_t*>(data.data());
 
   uint64_t hash = kOffset;
 
   for (size_t i = 0; i < data.length(); ++i) {
     hash = hash ^ octets[i];
     hash = hash * kPrime;
   }
 
   return hash;
 }
 
 // static
-uint128 QuicUtils::FNV1a_128_Hash(StringPiece data) {
-  return FNV1a_128_Hash_Three(data, StringPiece(), StringPiece());
+uint128 QuicUtils::FNV1a_128_Hash(QuicStringPiece data) {
+  return FNV1a_128_Hash_Three(data, QuicStringPiece(), QuicStringPiece());
 }
 
 // static
-uint128 QuicUtils::FNV1a_128_Hash_Two(StringPiece data1, StringPiece data2) {
-  return FNV1a_128_Hash_Three(data1, data2, StringPiece());
+uint128 QuicUtils::FNV1a_128_Hash_Two(QuicStringPiece data1,
+                                      QuicStringPiece data2) {
+  return FNV1a_128_Hash_Three(data1, data2, QuicStringPiece());
 }
 
 // static
-uint128 QuicUtils::FNV1a_128_Hash_Three(StringPiece data1,
-                                        StringPiece data2,
-                                        StringPiece data3) {
+uint128 QuicUtils::FNV1a_128_Hash_Three(QuicStringPiece data1,
+                                        QuicStringPiece data2,
+                                        QuicStringPiece data3) {
   // The two constants are defined as part of the hash algorithm.
   // see http://www.isthe.com/chongo/tech/comp/fnv/
   // kOffset = 144066263297769815596495629667062367629
   const uint128 kOffset =
       MakeUint128(UINT64_C(7809847782465536322), UINT64_C(7113472399480571277));
 
   uint128 hash = IncrementalHash(kOffset, data1);
   if (data2.empty()) {
     return hash;
   }
@@ skipping 83 matching lines @@
   if (old_address.host().InSameSubnet(new_address.host(), kSubnetMaskLength)) {
     // Subnet part does not change (here, we use /24), which is considered to be
     // caused by NATs.
     return IPV4_SUBNET_CHANGE;
   }
 
   return IPV4_TO_IPV4_CHANGE;
 }
 
 }  // namespace net