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

net/base/address_tracker_linux_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 "base/memory/scoped_ptr.h"
 #include "net/base/address_tracker_linux.h"
 
 #include <linux/if.h>
 
 #include <vector>
@@ skipping 95 matching lines @@
 
   base::hash_set<std::string> ignored_interfaces_;
   scoped_ptr<AddressTrackerLinux> tracker_;
   AddressTrackerLinux::GetInterfaceNameFunction original_get_interface_name_;
 };
 
 namespace {
 
 class NetlinkMessage {
  public:
-  explicit NetlinkMessage(uint16 type) : buffer_(NLMSG_HDRLEN) {
+  explicit NetlinkMessage(uint16_t type) : buffer_(NLMSG_HDRLEN) {
     header()->nlmsg_type = type;
     Align();
   }
 
   void AddPayload(const void* data, size_t length) {
     CHECK_EQ(static_cast<size_t>(NLMSG_HDRLEN),
              buffer_.size()) << "Payload must be added first";
     Append(data, length);
     Align();
   }
 
-  void AddAttribute(uint16 type, const void* data, size_t length) {
+  void AddAttribute(uint16_t type, const void* data, size_t length) {
     struct nlattr attr;
     attr.nla_len = NLA_HDRLEN + length;
     attr.nla_type = type;
     Append(&attr, sizeof(attr));
     Align();
     Append(data, length);
     Align();
   }
 
   void AppendTo(Buffer* output) const {
@@ skipping 17 matching lines @@
 
   struct nlmsghdr* header() {
     return reinterpret_cast<struct nlmsghdr*>(&buffer_[0]);
   }
 
   Buffer buffer_;
 };
 
 #define INFINITY_LIFE_TIME 0xFFFFFFFF
 
-void MakeAddrMessageWithCacheInfo(uint16 type,
-                                  uint8 flags,
-                                  uint8 family,
+void MakeAddrMessageWithCacheInfo(uint16_t type,
+                                  uint8_t flags,
+                                  uint8_t family,
                                   int index,
                                   const IPAddressNumber& address,
                                   const IPAddressNumber& local,
-                                  uint32 preferred_lifetime,
+                                  uint32_t preferred_lifetime,
                                   Buffer* output) {
   NetlinkMessage nlmsg(type);
   struct ifaddrmsg msg = {};
   msg.ifa_family = family;
   msg.ifa_flags = flags;
   msg.ifa_index = index;
   nlmsg.AddPayload(&msg, sizeof(msg));
   if (address.size())
     nlmsg.AddAttribute(IFA_ADDRESS, &address[0], address.size());
   if (local.size())
     nlmsg.AddAttribute(IFA_LOCAL, &local[0], local.size());
   struct ifa_cacheinfo cache_info = {};
   cache_info.ifa_prefered = preferred_lifetime;
   cache_info.ifa_valid = INFINITY_LIFE_TIME;
   nlmsg.AddAttribute(IFA_CACHEINFO, &cache_info, sizeof(cache_info));
   nlmsg.AppendTo(output);
 }
 
-void MakeAddrMessage(uint16 type,
-                     uint8 flags,
-                     uint8 family,
+void MakeAddrMessage(uint16_t type,
+                     uint8_t flags,
+                     uint8_t family,
                      int index,
                      const IPAddressNumber& address,
                      const IPAddressNumber& local,
                      Buffer* output) {
   MakeAddrMessageWithCacheInfo(type, flags, family, index, address, local,
                                INFINITY_LIFE_TIME, output);
 }
 
-void MakeLinkMessage(uint16 type, uint32 flags, uint32 index, Buffer* output) {
+void MakeLinkMessage(uint16_t type,
+                     uint32_t flags,
+                     uint32_t index,
+                     Buffer* output) {
   NetlinkMessage nlmsg(type);
   struct ifinfomsg msg = {};
   msg.ifi_index = index;
   msg.ifi_flags = flags;
   nlmsg.AddPayload(&msg, sizeof(msg));
   output->clear();
   nlmsg.AppendTo(output);
 }
 
 const unsigned char kAddress0[] = { 127, 0, 0, 1 };
@@ skipping 419 matching lines @@
 
 TEST_F(AddressTrackerLinuxTest, NonTrackingModeInit) {
   AddressTrackerLinux tracker;
   tracker.Init();
 }
 
 }  // namespace
 
 }  // namespace internal
 }  // namespace net