Use the exact-width integer types defined in <stdint.h> rather than

net/base/ip_address_number.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/base/ip_address_number.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
@@ skipping 74 matching lines @@
   if (!array)
     return false;
   size_t width = host_addr.size() + 1;
   for (size_t i = 0; i < array_size; ++i, array += width) {
     if (IPNumberPrefixCheck(host_addr, array, array[width-1]))
       return true;
   }
   return false;
 }
 
-std::string IPAddressToString(const uint8* address,
-                              size_t address_len) {
+std::string IPAddressToString(const uint8_t* address, size_t address_len) {
   std::string str;
   url::StdStringCanonOutput output(&str);
 
   if (address_len == kIPv4AddressSize) {
     url::AppendIPv4Address(address, &output);
   } else if (address_len == kIPv6AddressSize) {
     url::AppendIPv6Address(address, &output);
   } else {
     CHECK(false) << "Invalid IP address with length: " << address_len;
   }
 
   output.Complete();
   return str;
 }
 
-std::string IPAddressToStringWithPort(const uint8* address,
+std::string IPAddressToStringWithPort(const uint8_t* address,
                                       size_t address_len,
-                                      uint16 port) {
+                                      uint16_t port) {
   std::string address_str = IPAddressToString(address, address_len);
 
   if (address_len == kIPv6AddressSize) {
     // Need to bracket IPv6 addresses since they contain colons.
     return base::StringPrintf("[%s]:%d", address_str.c_str(), port);
   }
   return base::StringPrintf("%s:%d", address_str.c_str(), port);
 }
 
 std::string IPAddressToString(const IPAddressNumber& addr) {
   return IPAddressToString(&addr.front(), addr.size());
 }
 
 std::string IPAddressToStringWithPort(const IPAddressNumber& addr,
-                                      uint16 port) {
+                                      uint16_t port) {
   return IPAddressToStringWithPort(&addr.front(), addr.size(), port);
 }
 
 std::string IPAddressToPackedString(const IPAddressNumber& addr) {
   return std::string(reinterpret_cast<const char *>(&addr.front()),
                      addr.size());
 }
 
 bool ParseURLHostnameToNumber(const std::string& hostname,
                               IPAddressNumber* ip_number) {
@@ skipping 147 matching lines @@
   }
   return a1.size() * CHAR_BIT;
 }
 
 unsigned MaskPrefixLength(const IPAddressNumber& mask) {
   IPAddressNumber all_ones(mask.size(), 0xFF);
   return CommonPrefixLength(mask, all_ones);
 }
 
 }  // namespace net