Switch to standard integer types in net/.

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/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.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 = UINT64_C(14695981039346656037);
-  static const uint64 kPrime = UINT64_C(1099511628211);
+uint64_t QuicUtils::FNV1a_64_Hash(const char* data, int len) {
+  static const uint64_t kOffset = UINT64_C(14695981039346656037);
+  static const uint64_t kPrime = UINT64_C(1099511628211);
 
-  const uint8* octets = reinterpret_cast<const uint8*>(data);
+  const uint8_t* octets = reinterpret_cast<const uint8_t*>(data);
 
-  uint64 hash = kOffset;
+  uint64_t hash = kOffset;
 
   for (int i = 0; i < len; ++i) {
     hash = hash ^ octets[i];
     hash = hash * kPrime;
   }
 
   return hash;
 }
 
 // static
@@ skipping 16 matching lines @@
   if (data2 == nullptr) {
     return hash;
   }
   return IncrementalHash(hash, data2, len2);
 }
 
 // static
 uint128 QuicUtils::IncrementalHash(uint128 hash, const char* data, size_t len) {
   // 309485009821345068724781371
   const uint128 kPrime(16777216, 315);
-  const uint8* octets = reinterpret_cast<const uint8*>(data);
+  const uint8_t* octets = reinterpret_cast<const uint8_t*>(data);
   for (size_t i = 0; i < len; ++i) {
     hash = hash ^ uint128(0, octets[i]);
     hash = hash * kPrime;
   }
   return hash;
 }
 
 // static
 bool QuicUtils::FindMutualTag(const QuicTagVector& our_tags_vector,
                               const QuicTag* their_tags,
@@ skipping 35 matching lines @@
         }
         return true;
       }
     }
   }
 
   return false;
 }
 
 // static
-void QuicUtils::SerializeUint128Short(uint128 v, uint8* out) {
-  const uint64 lo = Uint128Low64(v);
-  const uint64 hi = Uint128High64(v);
+void QuicUtils::SerializeUint128Short(uint128 v, uint8_t* out) {
+  const uint64_t lo = Uint128Low64(v);
+  const uint64_t hi = Uint128High64(v);
   // This assumes that the system is little-endian.
   memcpy(out, &lo, sizeof(lo));
   memcpy(out + sizeof(lo), &hi, sizeof(hi) / 2);
 }
 
 #define RETURN_STRING_LITERAL(x) \
   case x:                        \
     return #x;
 
 // static
@@ skipping 154 matching lines @@
 
 // static
 QuicTagVector QuicUtils::ParseQuicConnectionOptions(
     const std::string& connection_options) {
   QuicTagVector options;
   // Tokens are expected to be no more than 4 characters long, but we
   // handle overflow gracefully.
   for (const base::StringPiece& token :
        base::SplitStringPiece(connection_options, ",", base::TRIM_WHITESPACE,
                               base::SPLIT_WANT_ALL)) {
-    uint32 option = 0;
+    uint32_t option = 0;
     for (char token_char : base::Reversed(token)) {
       option <<= 8;
       option |= static_cast<unsigned char>(token_char);
     }
     options.push_back(option);
   }
   return options;
 }
 
 // static
@@ skipping 23 matching lines @@
 
     bytes_remaining -= line_bytes;
     offset += line_bytes;
     p += line_bytes;
     s += '\n';
   }
   return s;
 }
 
 }  // namespace net