Use portable typedef for PIDs (process IDs).

base/process_util_win.cc

 // Copyright (c) 2006-2008 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/process_util.h"
 
 #include <windows.h>
 #include <winternl.h>
 #include <psapi.h>
 
 #include "base/histogram.h"
 #include "base/logging.h"
 #include "base/scoped_handle_win.h"
 #include "base/scoped_ptr.h"
 
 namespace {
 
 // System pagesize. This value remains constant on x86/64 architectures.
 const int PAGESIZE_KB = 4;
 
 // HeapSetInformation function pointer.
 typedef BOOL (WINAPI* HeapSetFn)(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T);
 
 }  // namespace
 
 namespace base {
 
-int GetCurrentProcId() {
+ProcessId GetCurrentProcId() {
   return ::GetCurrentProcessId();
 }
 
 ProcessHandle GetCurrentProcessHandle() {
   return ::GetCurrentProcess();
 }
 
-ProcessHandle OpenProcessHandle(int pid) {
+ProcessHandle OpenProcessHandle(ProcessId pid) {
   return OpenProcess(PROCESS_DUP_HANDLE | PROCESS_TERMINATE, FALSE, pid);
 }
 
 void CloseProcessHandle(ProcessHandle process) {
   CloseHandle(process);
 }
 
 // Helper for GetProcId()
 bool GetProcIdViaGetProcessId(ProcessHandle process, DWORD* id) {
   // Dynamically get a pointer to GetProcessId().
@@ skipping 46 matching lines @@
                                                     ProcessBasicInformation,
                                                     &info, sizeof info,
                                                     &bytes_returned);
   if (!SUCCEEDED(status) || (bytes_returned != (sizeof info)))
     return false;
 
   *id = static_cast<DWORD>(info.UniqueProcessId);
   return true;
 }
 
-int GetProcId(ProcessHandle process) {
+ProcessId GetProcId(ProcessHandle process) {
   // Get a handle to |process| that has PROCESS_QUERY_INFORMATION rights.
   HANDLE current_process = GetCurrentProcess();
   HANDLE process_with_query_rights;
   if (DuplicateHandle(current_process, process, current_process,
                       &process_with_query_rights, PROCESS_QUERY_INFORMATION,
                       false, 0)) {
     // Try to use GetProcessId(), if it exists.  Fall back on
     // NtQueryInformationProcess() otherwise (< Win XP SP1).
     DWORD id;
     bool success =
@@ skipping 39 matching lines @@
 
 bool LaunchApp(const CommandLine& cl,
                bool wait, bool start_hidden, ProcessHandle* process_handle) {
   return LaunchApp(cl.command_line_string(), wait,
                    start_hidden, process_handle);
 }
 
 // Attempts to kill the process identified by the given process
 // entry structure, giving it the specified exit code.
 // Returns true if this is successful, false otherwise.
-bool KillProcessById(DWORD process_id, int exit_code, bool wait) {
+bool KillProcessById(ProcessId process_id, int exit_code, bool wait) {
   HANDLE process = OpenProcess(PROCESS_TERMINATE | SYNCHRONIZE,
                                FALSE,  // Don't inherit handle
                                process_id);
   if (!process)
     return false;
 
   bool ret = KillProcess(process, exit_code, wait);
   CloseHandle(process);
   return ret;
 }
@@ skipping 468 matching lines @@
 void EnableTerminationOnHeapCorruption() {
   // Ignore the result code. Supported on XP SP3 and Vista.
   HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);
 }
 
 void RaiseProcessToHighPriority() {
   SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
 }
 
 }  // namespace base