Switch to standard integer types in base/process/.

base/process/process_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.
 
 #define _CRT_SECURE_NO_WARNINGS
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/debug/stack_trace.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/process/memory.h"
 #include "base/process/process.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 390 matching lines @@
 }
 
 static const char kEventToTriggerHandleSwitch[] = "event-to-trigger-handle";
 
 MULTIPROCESS_TEST_MAIN(TriggerEventChildProcess) {
   std::string handle_value_string =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           kEventToTriggerHandleSwitch);
   CHECK(!handle_value_string.empty());
 
-  uint64 handle_value_uint64;
+  uint64_t handle_value_uint64;
   CHECK(base::StringToUint64(handle_value_string, &handle_value_uint64));
   // Give ownership of the handle to |event|.
   base::WaitableEvent event(base::win::ScopedHandle(
       reinterpret_cast<HANDLE>(handle_value_uint64)));
 
   event.Signal();
 
   return 0;
 }
 
 TEST_F(ProcessUtilTest, InheritSpecifiedHandles) {
   // Manually create the event, so that it can be inheritable.
   SECURITY_ATTRIBUTES security_attributes = {};
   security_attributes.nLength = static_cast<DWORD>(sizeof(security_attributes));
   security_attributes.lpSecurityDescriptor = NULL;
   security_attributes.bInheritHandle = true;
 
   // Takes ownership of the event handle.
   base::WaitableEvent event(base::win::ScopedHandle(
       CreateEvent(&security_attributes, true, false, NULL)));
   base::HandlesToInheritVector handles_to_inherit;
   handles_to_inherit.push_back(event.handle());
   base::LaunchOptions options;
   options.handles_to_inherit = &handles_to_inherit;
 
   base::CommandLine cmd_line = MakeCmdLine("TriggerEventChildProcess");
-  cmd_line.AppendSwitchASCII(kEventToTriggerHandleSwitch,
-      base::Uint64ToString(reinterpret_cast<uint64>(event.handle())));
+  cmd_line.AppendSwitchASCII(
+      kEventToTriggerHandleSwitch,
+      base::Uint64ToString(reinterpret_cast<uint64_t>(event.handle())));
 
   // This functionality actually requires Vista or later. Make sure that it
   // fails properly on XP.
   if (base::win::GetVersion() < base::win::VERSION_VISTA) {
     EXPECT_FALSE(base::LaunchProcess(cmd_line, options).IsValid());
     return;
   }
 
   // Launch the process and wait for it to trigger the event.
   ASSERT_TRUE(base::LaunchProcess(cmd_line, options).IsValid());
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
 }
 #endif  // defined(OS_WIN)
 
 #if defined(OS_POSIX)
 
 namespace {
 
 // Returns the maximum number of files that a process can have open.
 // Returns 0 on error.
 int GetMaxFilesOpenInProcess() {
   struct rlimit rlim;
   if (getrlimit(RLIMIT_NOFILE, &rlim) != 0) {
     return 0;
   }
 
-  // rlim_t is a uint64 - clip to maxint. We do this since FD #s are ints
+  // rlim_t is a uint64_t - clip to maxint. We do this since FD #s are ints
   // which are all 32 bits on the supported platforms.
-  rlim_t max_int = static_cast<rlim_t>(std::numeric_limits<int32>::max());
+  rlim_t max_int = static_cast<rlim_t>(std::numeric_limits<int32_t>::max());
   if (rlim.rlim_cur > max_int) {
     return max_int;
   }
 
   return rlim.rlim_cur;
 }
 
 const int kChildPipe = 20;  // FD # for write end of pipe in child process.
 
 #if defined(OS_MACOSX)
@@ skipping 626 matching lines @@
   options.current_directory = base::FilePath("/dev/null");
 
   base::Process process(SpawnChildWithOptions("SimpleChildProcess", options));
   ASSERT_TRUE(process.IsValid());
 
   int exit_code = kSuccess;
   EXPECT_TRUE(process.WaitForExit(&exit_code));
   EXPECT_NE(kSuccess, exit_code);
 }
 #endif