Use portable typedef for PIDs (process IDs).

base/process_util.h

 // 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.
 
 // This file/namespace contains utility functions for enumerating, ending and
 // computing statistics of processes.
 
 #ifndef BASE_PROCESS_UTIL_H_
 #define BASE_PROCESS_UTIL_H_
 
@@ skipping 44 matching lines @@
 // A minimalistic but hopefully cross-platform set of exit codes.
 // Do not change the enumeration values or you will break third-party
 // installers.
 enum {
   PROCESS_END_NORMAL_TERMINATON = 0,
   PROCESS_END_KILLED_BY_USER    = 1,
   PROCESS_END_PROCESS_WAS_HUNG  = 2
 };
 
 // Returns the id of the current process.
-int GetCurrentProcId();
+ProcessId GetCurrentProcId();
 
 // Returns the ProcessHandle of the current process.
 ProcessHandle GetCurrentProcessHandle();
 
 // Converts a PID to a process handle. This handle must be closed by
 // CloseProcessHandle when you are done with it.
-ProcessHandle OpenProcessHandle(int pid);
+ProcessHandle OpenProcessHandle(ProcessId pid);
 
 // Closes the process handle opened by OpenProcessHandle.
 void CloseProcessHandle(ProcessHandle process);
 
 // Returns the unique ID for the specified process. This is functionally the
 // same as Windows' GetProcessId(), but works on versions of Windows before
 // Win XP SP1 as well.
-int GetProcId(ProcessHandle process);
+ProcessId GetProcId(ProcessHandle process);
 
 #if defined(OS_POSIX)
 // Sets all file descriptors to close on exec except for stdin, stdout
 // and stderr.
 void SetAllFDsToCloseOnExec();
 #endif
 
 #if defined(OS_WIN)
 // Runs the given application name with the given command line. Normally, the
 // first command line argument should be the path to the process, and don't
@@ skipping 31 matching lines @@
 // Execute the application specified by cl. This function delegates to one
 // of the above two platform-specific functions.
 bool LaunchApp(const CommandLine& cl,
                bool wait, bool start_hidden, ProcessHandle* process_handle);
 
 // Used to filter processes by process ID.
 class ProcessFilter {
  public:
   // Returns true to indicate set-inclusion and false otherwise.  This method
   // should not have side-effects and should be idempotent.
-  virtual bool Includes(uint32 pid, uint32 parent_pid) const = 0;
+  virtual bool Includes(ProcessId pid, ProcessId parent_pid) const = 0;
   virtual ~ProcessFilter() { }
 };
 
 // Returns the number of processes on the machine that are running from the
 // given executable name.  If filter is non-null, then only processes selected
 // by the filter will be counted.
 int GetProcessCount(const std::wstring& executable_name,
                     const ProcessFilter* filter);
 
 // Attempts to kill all the processes on the current machine that were launched
 // from the given executable name, ending them with the given exit code.  If
 // filter is non-null, then only processes selected by the filter are killed.
 // Returns false if all processes were able to be killed off, false if at least
 // one couldn't be killed.
 bool KillProcesses(const std::wstring& executable_name, int exit_code,
                    const ProcessFilter* filter);
 
 // Attempts to kill the process identified by the given process
 // entry structure, giving it the specified exit code. If |wait| is true, wait
 // for the process to be actually terminated before returning.
 // Returns true if this is successful, false otherwise.
 bool KillProcess(ProcessHandle process, int exit_code, bool wait);
 #if defined(OS_WIN)
-bool KillProcessById(DWORD process_id, int exit_code, bool wait);
+bool KillProcessById(ProcessId process_id, int exit_code, bool wait);
 #endif
 
 // Get the termination status (exit code) of the process and return true if the
 // status indicates the process crashed.  It is an error to call this if the
 // process hasn't terminated yet.
 bool DidProcessCrash(ProcessHandle handle);
 
 // Waits for process to exit. In POSIX systems, if the process hasn't been
 // signaled then puts the exit code in |exit_code|; otherwise it's considered
 // a failure. On Windows |exit_code| is always filled. Returns true on success,
@@ skipping 186 matching lines @@
 // overflow. Has no effect if the OS doesn't provide the necessary facility.
 void EnableTerminationOnHeapCorruption();
 
 // If supported on the platform, and the user has sufficent rights, increase
 // the current process's scheduling priority to a high priority.
 void RaiseProcessToHighPriority();
 
 }  // namespace base
 
 #endif  // BASE_PROCESS_UTIL_H_