net: Remove the remaining use of GG_(U)INTn_C macros.

net/quic/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/quic_utils.h"
 
 #include <ctype.h>
+#include <stdint.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/containers/adapters.h"
 #include "base/logging.h"
-#include "base/port.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "net/quic/quic_write_blocked_list.h"
 
 using base::StringPiece;
 using std::string;
 
 namespace net {
 
 // static
 uint64 QuicUtils::FNV1a_64_Hash(const char* data, int len) {
-  static const uint64 kOffset = GG_UINT64_C(14695981039346656037);
-  static const uint64 kPrime = GG_UINT64_C(1099511628211);
+  static const uint64 kOffset = UINT64_C(14695981039346656037);
+  static const uint64 kPrime = UINT64_C(1099511628211);
 
   const uint8* octets = reinterpret_cast<const uint8*>(data);
 
   uint64 hash = kOffset;
 
   for (int i = 0; i < len; ++i) {
     hash = hash ^ octets[i];
     hash = hash * kPrime;
   }
 
   return hash;
 }
 
 // static
 uint128 QuicUtils::FNV1a_128_Hash(const char* data, int len) {
   return FNV1a_128_Hash_Two(data, len, nullptr, 0);
 }
 
 // static
 uint128 QuicUtils::FNV1a_128_Hash_Two(const char* data1,
                                       int len1,
                                       const char* data2,
                                       int len2) {
   // The two constants are defined as part of the hash algorithm.
   // see http://www.isthe.com/chongo/tech/comp/fnv/
   // 144066263297769815596495629667062367629
-  const uint128 kOffset(GG_UINT64_C(7809847782465536322),
-                        GG_UINT64_C(7113472399480571277));
+  const uint128 kOffset(UINT64_C(7809847782465536322),
+                        UINT64_C(7113472399480571277));
 
   uint128 hash = IncrementalHash(kOffset, data1, len1);
   if (data2 == nullptr) {
     return hash;
   }
   return IncrementalHash(hash, data2, len2);
 }
 
 // static
 uint128 QuicUtils::IncrementalHash(uint128 hash, const char* data, size_t len) {
@@ skipping 270 matching lines @@
   }
   return s;
 }
 
 // static
 QuicPriority QuicUtils::HighestPriority() {
   return QuicWriteBlockedList::kHighestPriority;
 }
 
 }  // namespace net