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

net/base/net_util_unittest.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/net_util.h"
 
 #include <string.h>
 
 #include <ostream>
 
@@ skipping 38 matching lines @@
 
 namespace {
 
 struct HeaderCase {
   const char* const header_name;
   const char* const expected;
 };
 
 // Fills in sockaddr for the given 32-bit address (IPv4.)
 // |bytes| should be an array of length 4.
-void MakeIPv4Address(const uint8* bytes, int port, SockaddrStorage* storage) {
+void MakeIPv4Address(const uint8_t* bytes, int port, SockaddrStorage* storage) {
   memset(&storage->addr_storage, 0, sizeof(storage->addr_storage));
   storage->addr_len = sizeof(struct sockaddr_in);
   struct sockaddr_in* addr4 = reinterpret_cast<sockaddr_in*>(storage->addr);
   addr4->sin_port = base::HostToNet16(port);
   addr4->sin_family = AF_INET;
   memcpy(&addr4->sin_addr, bytes, 4);
 }
 
 // Fills in sockaddr for the given 128-bit address (IPv6.)
 // |bytes| should be an array of length 16.
-void MakeIPv6Address(const uint8* bytes, int port, SockaddrStorage* storage) {
+void MakeIPv6Address(const uint8_t* bytes, int port, SockaddrStorage* storage) {
   memset(&storage->addr_storage, 0, sizeof(storage->addr_storage));
   storage->addr_len = sizeof(struct sockaddr_in6);
   struct sockaddr_in6* addr6 = reinterpret_cast<sockaddr_in6*>(storage->addr);
   addr6->sin6_port = base::HostToNet16(port);
   addr6->sin6_family = AF_INET6;
   memcpy(&addr6->sin6_addr, bytes, 16);
 }
 
 }  // anonymous namespace
 
@@ skipping 244 matching lines @@
     { GURL("http://[::a]:33/x"), "[::a]:33"},
   };
   for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string host_and_port = GetHostAndOptionalPort(tests[i].url);
     EXPECT_EQ(std::string(tests[i].expected_host_and_port), host_and_port);
   }
 }
 
 TEST(NetUtilTest, NetAddressToString_IPv4) {
   const struct {
-    uint8 addr[4];
+    uint8_t addr[4];
     const char* const result;
   } tests[] = {
     {{0, 0, 0, 0}, "0.0.0.0"},
     {{127, 0, 0, 1}, "127.0.0.1"},
     {{192, 168, 0, 1}, "192.168.0.1"},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     SockaddrStorage storage;
     MakeIPv4Address(tests[i].addr, 80, &storage);
     std::string result = NetAddressToString(storage.addr, storage.addr_len);
     EXPECT_EQ(std::string(tests[i].result), result);
   }
 }
 
 TEST(NetUtilTest, NetAddressToString_IPv6) {
   const struct {
-    uint8 addr[16];
+    uint8_t addr[16];
     const char* const result;
   } tests[] = {
     {{0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0xFE, 0xDC, 0xBA,
       0x98, 0x76, 0x54, 0x32, 0x10},
      "fedc:ba98:7654:3210:fedc:ba98:7654:3210"},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     SockaddrStorage storage;
     MakeIPv6Address(tests[i].addr, 80, &storage);
     EXPECT_EQ(std::string(tests[i].result),
         NetAddressToString(storage.addr, storage.addr_len));
   }
 }
 
 TEST(NetUtilTest, NetAddressToStringWithPort_IPv4) {
-  uint8 addr[] = {127, 0, 0, 1};
+  uint8_t addr[] = {127, 0, 0, 1};
   SockaddrStorage storage;
   MakeIPv4Address(addr, 166, &storage);
   std::string result = NetAddressToStringWithPort(storage.addr,
                                                   storage.addr_len);
   EXPECT_EQ("127.0.0.1:166", result);
 }
 
 TEST(NetUtilTest, NetAddressToStringWithPort_IPv6) {
-  uint8 addr[] = {
+  uint8_t addr[] = {
       0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0xFE, 0xDC, 0xBA,
       0x98, 0x76, 0x54, 0x32, 0x10
   };
   SockaddrStorage storage;
   MakeIPv6Address(addr, 361, &storage);
   std::string result = NetAddressToStringWithPort(storage.addr,
                                                   storage.addr_len);
 
   // May fail on systems that don't support IPv6.
   if (!result.empty())
@@ skipping 234 matching lines @@
 TEST_P(NetUtilNonUniqueNameTest, IsHostnameNonUnique) {
   const NonUniqueNameTestData& test_data = GetParam();
 
   EXPECT_EQ(test_data.is_unique, IsUnique(test_data.hostname));
 }
 
 INSTANTIATE_TEST_CASE_P(, NetUtilNonUniqueNameTest,
                         testing::ValuesIn(kNonUniqueNameTestData));
 
 }  // namespace net