Switch to standard integer types in tools/.

tools/cygprofile/cygprofile.cc

 // Copyright (c) 2011 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 "tools/cygprofile/cygprofile.h"
 
 #include <fcntl.h>
 #include <pthread.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <sys/stat.h>
 #include <sys/syscall.h>
 #include <sys/time.h>
 #include <sys/types.h>
 
 #include <cstdio>
 #include <fstream>
 #include <string>
 #include <vector>
 
@@ skipping 59 matching lines @@
 
   const std::string value;
 
  private:
   // Returns whether the integer representation of the hexadecimal address
   // stored in |line| at position |start_offset| was successfully stored in
   // |result|.
   static bool ParseAddress(const std::string& line,
                            size_t start_offset,
                            size_t length,
-                           uint64* result) {
+                           uint64_t* result) {
     if (start_offset >= line.length())
       return false;
 
-    uint64 address;
+    uint64_t address;
     const bool ret = HexStringToUInt64(
         base::StringPiece(line.c_str() + start_offset, length), &address);
     if (!ret)
       return false;
 
     *result = address;
     return true;
   }
 
   // Parses /proc/self/maps and returns a two line string such as:
   // 758c6000-79f4b000 r-xp 00000000 b3:17 309475 libchrome.2009.0.so
   // secs    usecs   pid:threadid    func
   static std::string MakeFileHeaderLine() {
     std::ifstream mapsfile("/proc/self/maps");
     CHECK(mapsfile.good());
     std::string result;
 
     for (std::string line; std::getline(mapsfile, line); ) {
       if (line.find("r-xp") == std::string::npos)
         continue;
 
       const size_t address_length = line.find('-');
-      uint64 start_address = 0;
+      uint64_t start_address = 0;
       CHECK(ParseAddress(line, 0, address_length, &start_address));
 
-      uint64 end_address = 0;
+      uint64_t end_address = 0;
       CHECK(ParseAddress(line, address_length + 1, address_length,
                          &end_address));
 
       const uintptr_t current_func_addr = reinterpret_cast<uintptr_t>(
           &MakeFileHeaderLine);
       if (current_func_addr >= start_address &&
           current_func_addr < end_address) {
         result.swap(line);
         break;
       }
@@ skipping 235 matching lines @@
   }
 
   if (g_tls_log != kMagicBeingConstructed)
     g_tls_log->AddEntry(this_fn);
 }
 
 void __cyg_profile_func_exit(void* this_fn, void* call_site) {}
 
 }  // extern "C"
 }  // namespace cygprofile