Remove pid_t in platform-independent code.

Change-Id: Ia58e07bf85a09cd7e63784220800431ad1366584
Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1565273
Commit-Queue: Eric Astor <epastor@google.com>
Reviewed-by: Mark Mentovai <mark@chromium.org>

compat/win/sys/types.h

@@ -20,6 +20,4 @@
 
 #include <stdint.h>
 
-typedef unsigned int pid_t;
-
 #endif  // CRASHPAD_COMPAT_WIN_SYS_TYPES_H_

snapshot/fuchsia/process_snapshot_fuchsia.cc

@@ -98,12 +98,12 @@ void ProcessSnapshotFuchsia::GetCrashpadOptions(
   *options = local_options;
 }
 
-pid_t ProcessSnapshotFuchsia::ProcessID() const {
+crashpad::ProcessID ProcessSnapshotFuchsia::ProcessID() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return GetKoidForHandle(*zx::process::self());
 }
 
-pid_t ProcessSnapshotFuchsia::ParentProcessID() const {
+crashpad::ProcessID ProcessSnapshotFuchsia::ParentProcessID() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   NOTREACHED();  // TODO(scottmg): https://crashpad.chromium.org/bug/196
   return 0;

snapshot/fuchsia/process_snapshot_fuchsia.h

@@ -35,6 +35,7 @@
 #include "snapshot/process_snapshot.h"
 #include "snapshot/unloaded_module_snapshot.h"
 #include "util/misc/initialization_state_dcheck.h"
+#include "util/process/process_id.h"
 #include "util/process/process_memory_range.h"
 
 namespace crashpad {
@@ -105,8 +106,8 @@ class ProcessSnapshotFuchsia : public ProcessSnapshot {
   }
 
   // ProcessSnapshot:
-  pid_t ProcessID() const override;
+  crashpad::ProcessID ProcessID() const override;
-  pid_t ParentProcessID() const override;
+  crashpad::ProcessID ParentProcessID() const override;
   void SnapshotTime(timeval* snapshot_time) const override;
   void ProcessStartTime(timeval* start_time) const override;
   void ProcessCPUTimes(timeval* user_time, timeval* system_time) const override;

snapshot/linux/process_snapshot_linux.cc

@@ -155,12 +155,12 @@ void ProcessSnapshotLinux::GetCrashpadOptions(
   *options = local_options;
 }
 
-pid_t ProcessSnapshotLinux::ProcessID() const {
+crashpad::ProcessID ProcessSnapshotLinux::ProcessID() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return process_reader_.ProcessID();
 }
 
-pid_t ProcessSnapshotLinux::ParentProcessID() const {
+crashpad::ProcessID ProcessSnapshotLinux::ParentProcessID() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return process_reader_.ParentProcessID();
 }

snapshot/linux/process_snapshot_linux.h

@@ -39,6 +39,7 @@
 #include "util/linux/ptrace_connection.h"
 #include "util/misc/initialization_state_dcheck.h"
 #include "util/misc/uuid.h"
+#include "util/process/process_id.h"
 #include "util/process/process_memory_range.h"
 
 namespace crashpad {
@@ -106,8 +107,8 @@ class ProcessSnapshotLinux final : public ProcessSnapshot {
 
   // ProcessSnapshot:
 
-  pid_t ProcessID() const override;
+  crashpad::ProcessID ProcessID() const override;
-  pid_t ParentProcessID() const override;
+  crashpad::ProcessID ParentProcessID() const override;
   void SnapshotTime(timeval* snapshot_time) const override;
   void ProcessStartTime(timeval* start_time) const override;
   void ProcessCPUTimes(timeval* user_time, timeval* system_time) const override;

snapshot/minidump/process_snapshot_minidump.cc

@@ -58,7 +58,7 @@ ProcessSnapshotMinidump::ProcessSnapshotMinidump()
       arch_(CPUArchitecture::kCPUArchitectureUnknown),
       annotations_simple_map_(),
       file_reader_(nullptr),
-      process_id_(static_cast<pid_t>(-1)),
+      process_id_(kInvalidProcessID),
       initialized_() {}
 
 ProcessSnapshotMinidump::~ProcessSnapshotMinidump() {}
@@ -120,12 +120,12 @@ bool ProcessSnapshotMinidump::Initialize(FileReaderInterface* file_reader) {
   return true;
 }
 
-pid_t ProcessSnapshotMinidump::ProcessID() const {
+crashpad::ProcessID ProcessSnapshotMinidump::ProcessID() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return process_id_;
 }
 
-pid_t ProcessSnapshotMinidump::ParentProcessID() const {
+crashpad::ProcessID ProcessSnapshotMinidump::ParentProcessID() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   NOTREACHED();  // https://crashpad.chromium.org/bug/10
   return 0;

snapshot/minidump/process_snapshot_minidump.h

@@ -42,6 +42,7 @@
 #include "util/file/file_reader.h"
 #include "util/misc/initialization_state_dcheck.h"
 #include "util/misc/uuid.h"
+#include "util/process/process_id.h"
 
 namespace crashpad {
 
@@ -66,8 +67,8 @@ class ProcessSnapshotMinidump final : public ProcessSnapshot {
 
   // ProcessSnapshot:
 
-  pid_t ProcessID() const override;
+  crashpad::ProcessID ProcessID() const override;
-  pid_t ParentProcessID() const override;
+  crashpad::ProcessID ParentProcessID() const override;
   void SnapshotTime(timeval* snapshot_time) const override;
   void ProcessStartTime(timeval* start_time) const override;
   void ProcessCPUTimes(timeval* user_time, timeval* system_time) const override;
@@ -151,7 +152,7 @@ class ProcessSnapshotMinidump final : public ProcessSnapshot {
   std::map<std::string, std::string> annotations_simple_map_;
   std::string full_version_;
   FileReaderInterface* file_reader_;  // weak
-  pid_t process_id_;
+  crashpad::ProcessID process_id_;
   InitializationStateDcheck initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessSnapshotMinidump);

snapshot/minidump/process_snapshot_minidump_test.cc

@@ -544,7 +544,7 @@ TEST(ProcessSnapshotMinidump, ProcessID) {
   MINIDUMP_HEADER header = {};
   ASSERT_TRUE(string_file.Write(&header, sizeof(header)));
 
-  static const pid_t kTestProcessId = 42;
+  static const crashpad::ProcessID kTestProcessId = 42;
   MINIDUMP_MISC_INFO misc_info = {};
   misc_info.SizeOfInfo = sizeof(misc_info);
   misc_info.Flags1 = MINIDUMP_MISC1_PROCESS_ID;

snapshot/process_snapshot.h

@@ -24,6 +24,7 @@
 
 #include "snapshot/handle_snapshot.h"
 #include "util/misc/uuid.h"
+#include "util/process/process_id.h"
 
 namespace crashpad {
 
@@ -50,10 +51,10 @@ class ProcessSnapshot {
   virtual ~ProcessSnapshot() {}
 
   //! \brief Returns the snapshot process’ process ID.
-  virtual pid_t ProcessID() const = 0;
+  virtual crashpad::ProcessID ProcessID() const = 0;
 
   //! \brief Returns the snapshot process’ parent process’ process ID.
-  virtual pid_t ParentProcessID() const = 0;
+  virtual crashpad::ProcessID ParentProcessID() const = 0;
 
   //! \brief Returns the time that the snapshot was taken in \a snapshot_time.
   //!

snapshot/sanitized/process_snapshot_sanitized.cc

@@ -161,12 +161,12 @@ bool ProcessSnapshotSanitized::Initialize(
   return true;
 }
 
-pid_t ProcessSnapshotSanitized::ProcessID() const {
+crashpad::ProcessID ProcessSnapshotSanitized::ProcessID() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return snapshot_->ProcessID();
 }
 
-pid_t ProcessSnapshotSanitized::ParentProcessID() const {
+crashpad::ProcessID ProcessSnapshotSanitized::ParentProcessID() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return snapshot_->ParentProcessID();
 }

snapshot/sanitized/process_snapshot_sanitized.h

@@ -29,6 +29,7 @@
 #include "util/misc/address_types.h"
 #include "util/misc/initialization_state_dcheck.h"
 #include "util/misc/range_set.h"
+#include "util/process/process_id.h"
 
 namespace crashpad {
 
@@ -66,8 +67,8 @@ class ProcessSnapshotSanitized final : public ProcessSnapshot {
 
   // ProcessSnapshot:
 
-  pid_t ProcessID() const override;
+  crashpad::ProcessID ProcessID() const override;
-  pid_t ParentProcessID() const override;
+  crashpad::ProcessID ParentProcessID() const override;
   void SnapshotTime(timeval* snapshot_time) const override;
   void ProcessStartTime(timeval* start_time) const override;
   void ProcessCPUTimes(timeval* user_time, timeval* system_time) const override;

snapshot/test/test_process_snapshot.cc

@@ -42,11 +42,11 @@ TestProcessSnapshot::TestProcessSnapshot()
 TestProcessSnapshot::~TestProcessSnapshot() {
 }
 
-pid_t TestProcessSnapshot::ProcessID() const {
+crashpad::ProcessID TestProcessSnapshot::ProcessID() const {
   return process_id_;
 }
 
-pid_t TestProcessSnapshot::ParentProcessID() const {
+crashpad::ProcessID TestProcessSnapshot::ParentProcessID() const {
   return parent_process_id_;
 }
 

snapshot/test/test_process_snapshot.h

@@ -35,6 +35,7 @@
 #include "snapshot/thread_snapshot.h"
 #include "snapshot/unloaded_module_snapshot.h"
 #include "util/misc/uuid.h"
+#include "util/process/process_id.h"
 #include "util/process/process_memory.h"
 
 namespace crashpad {
@@ -47,8 +48,10 @@ class TestProcessSnapshot final : public ProcessSnapshot {
   TestProcessSnapshot();
   ~TestProcessSnapshot() override;
 
-  void SetProcessID(pid_t process_id) { process_id_ = process_id; }
+  void SetProcessID(crashpad::ProcessID process_id) {
-  void SetParentProcessID(pid_t parent_process_id) {
+    process_id_ = process_id;
+  }
+  void SetParentProcessID(crashpad::ProcessID parent_process_id) {
     parent_process_id_ = parent_process_id;
   }
   void SetSnapshotTime(const timeval& snapshot_time) {
@@ -146,8 +149,8 @@ class TestProcessSnapshot final : public ProcessSnapshot {
 
   // ProcessSnapshot:
 
-  pid_t ProcessID() const override;
+  crashpad::ProcessID ProcessID() const override;
-  pid_t ParentProcessID() const override;
+  crashpad::ProcessID ParentProcessID() const override;
   void SnapshotTime(timeval* snapshot_time) const override;
   void ProcessStartTime(timeval* start_time) const override;
   void ProcessCPUTimes(timeval* user_time, timeval* system_time) const override;
@@ -166,8 +169,8 @@ class TestProcessSnapshot final : public ProcessSnapshot {
   const ProcessMemory* Memory() const override;
 
  private:
-  pid_t process_id_;
+  crashpad::ProcessID process_id_;
-  pid_t parent_process_id_;
+  crashpad::ProcessID parent_process_id_;
   timeval snapshot_time_;
   timeval process_start_time_;
   timeval process_cpu_user_time_;

snapshot/win/process_snapshot_win.cc

@@ -123,12 +123,12 @@ void ProcessSnapshotWin::GetCrashpadOptions(
   *options = options_;
 }
 
-pid_t ProcessSnapshotWin::ProcessID() const {
+crashpad::ProcessID ProcessSnapshotWin::ProcessID() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return process_reader_.GetProcessInfo().ProcessID();
 }
 
-pid_t ProcessSnapshotWin::ParentProcessID() const {
+crashpad::ProcessID ProcessSnapshotWin::ParentProcessID() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return process_reader_.GetProcessInfo().ParentProcessID();
 }

snapshot/win/process_snapshot_win.h

@@ -44,6 +44,7 @@
 #include "snapshot/win/thread_snapshot_win.h"
 #include "util/misc/initialization_state_dcheck.h"
 #include "util/misc/uuid.h"
+#include "util/process/process_id.h"
 #include "util/win/address_types.h"
 #include "util/win/process_structs.h"
 
@@ -112,8 +113,8 @@ class ProcessSnapshotWin final : public ProcessSnapshot {
 
   // ProcessSnapshot:
 
-  pid_t ProcessID() const override;
+  crashpad::ProcessID ProcessID() const override;
-  pid_t ParentProcessID() const override;
+  crashpad::ProcessID ParentProcessID() const override;
   void SnapshotTime(timeval* snapshot_time) const override;
   void ProcessStartTime(timeval* start_time) const override;
   void ProcessCPUTimes(timeval* user_time, timeval* system_time) const override;

test/win/win_multiprocess_with_temp_dir.cc

@@ -17,6 +17,7 @@
 #include <tlhelp32.h>
 
 #include "test/errors.h"
+#include "util/process/process_id.h"
 #include "util/win/process_info.h"
 
 namespace crashpad {
@@ -28,20 +29,20 @@ constexpr wchar_t kTempDirEnvName[] = L"CRASHPAD_TEST_TEMP_DIR";
 
 // Returns the process IDs of all processes that have |parent_pid| as
 // parent process ID.
-std::vector<pid_t> GetPotentialChildProcessesOf(pid_t parent_pid) {
+std::vector<ProcessID> GetPotentialChildProcessesOf(ProcessID parent_pid) {
   ScopedFileHANDLE snapshot(CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0));
   if (!snapshot.is_valid()) {
     ADD_FAILURE() << ErrorMessage("CreateToolhelp32Snapshot");
-    return std::vector<pid_t>();
+    return std::vector<ProcessID>();
   }
 
   PROCESSENTRY32 entry = {sizeof(entry)};
   if (!Process32First(snapshot.get(), &entry)) {
     ADD_FAILURE() << ErrorMessage("Process32First");
-    return std::vector<pid_t>();
+    return std::vector<ProcessID>();
   }
 
-  std::vector<pid_t> child_pids;
+  std::vector<ProcessID> child_pids;
   do {
     if (entry.th32ParentProcessID == parent_pid)
       child_pids.push_back(entry.th32ProcessID);
@@ -68,11 +69,11 @@ ULARGE_INTEGER GetProcessCreationTime(HANDLE process) {
 // not their offspring. For this to work without race, |parent| has to be
 // suspended or have exited.
 void WaitForAllChildProcessesOf(HANDLE parent) {
-  pid_t parent_pid = GetProcessId(parent);
+  ProcessID parent_pid = GetProcessId(parent);
-  std::vector<pid_t> child_pids = GetPotentialChildProcessesOf(parent_pid);
+  std::vector<ProcessID> child_pids = GetPotentialChildProcessesOf(parent_pid);
 
   ULARGE_INTEGER parent_creationtime = GetProcessCreationTime(parent);
-  for (pid_t child_pid : child_pids) {
+  for (ProcessID child_pid : child_pids) {
     // Try and open the process. This may fail for reasons such as:
     // 1. The process isn't |parent|'s child process, but rather a
     //    higher-privilege sub-process of an earlier process that had

tools/generate_dump.cc

@@ -26,6 +26,7 @@
 #include "minidump/minidump_file_writer.h"
 #include "tools/tool_support.h"
 #include "util/file/file_writer.h"
+#include "util/process/process_id.h"
 #include "util/stdlib/string_number_conversion.h"
 
 #if defined(OS_POSIX)
@@ -92,7 +93,7 @@ int GenerateDumpMain(int argc, char* argv[]) {
 
   struct {
     std::string dump_path;
-    pid_t pid;
+    ProcessID pid;
     bool suspend;
   } options = {};
   options.suspend = true;
@@ -175,7 +176,8 @@ int GenerateDumpMain(int argc, char* argv[]) {
 #endif  // OS_MACOSX
 
   if (options.dump_path.empty()) {
-    options.dump_path = base::StringPrintf("minidump.%d", options.pid);
+    options.dump_path = base::StringPrintf("minidump.%" PRI_PROCESS_ID,
+                                           options.pid);
   }
 
   {

util/BUILD.gn

@@ -137,6 +137,7 @@ static_library("util") {
     "numeric/in_range_cast.h",
     "numeric/int128.h",
     "numeric/safe_assignment.h",
+    "process/process_id.h",
     "process/process_memory.cc",
     "process/process_memory.h",
     "process/process_memory_native.h",

util/process/process_id.h

@@ -0,0 +1,54 @@
+// Copyright 2019 The Crashpad Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef CRASHPAD_UTIL_PROCESS_PROCESS_ID_H_
+#define CRASHPAD_UTIL_PROCESS_PROCESS_ID_H_
+
+#include <type_traits>
+
+#include "base/format_macros.h"
+#include "build/build_config.h"
+
+#if defined(OS_POSIX)
+#include <sys/types.h>
+#elif defined(OS_WIN)
+#include <windows.h>
+#elif defined(OS_FUCHSIA)
+#include <zircon/types.h>
+#endif
+
+namespace crashpad {
+
+#if defined(OS_POSIX) || DOXYGEN
+//! \brief Alias for platform-specific type to represent a process.
+using ProcessID = pid_t;
+constexpr ProcessID kInvalidProcessID = -1;
+static_assert(std::is_same<ProcessID, int>::value, "Port.");
+#define PRI_PROCESS_ID "d"
+#elif defined(OS_WIN)
+using ProcessID = DWORD;
+constexpr ProcessID kInvalidProcessID = 0;
+#define PRI_PROCESS_ID "lu"
+#elif defined(OS_FUCHSIA)
+using ProcessID = zx_koid_t;
+constexpr ProcessID kInvalidProcessID = ZX_KOID_INVALID;
+static_assert(std::is_same<ProcessID, int64_t>::value, "Port.");
+#define PRI_PROCESS_ID PRId64
+#else
+#error Port.
+#endif
+
+}  // namespace crashpad
+
+#endif  // CRASHPAD_UTIL_PROCESS_PROCESS_ID_H_

util/util.gyp

@@ -209,6 +209,7 @@
         'posix/signals.h',
         'posix/symbolic_constants_posix.cc',
         'posix/symbolic_constants_posix.h',
+        'process/process_id.h',
         'process/process_memory.cc',
         'process/process_memory.h',
         'process/process_memory_linux.cc',

util/win/process_info.cc

@@ -565,12 +565,12 @@ bool ProcessInfo::IsWow64() const {
   return is_wow64_;
 }
 
-pid_t ProcessInfo::ProcessID() const {
+crashpad::ProcessID ProcessInfo::ProcessID() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return process_id_;
 }
 
-pid_t ProcessInfo::ParentProcessID() const {
+crashpad::ProcessID ProcessInfo::ParentProcessID() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return inherited_from_process_id_;
 }

util/win/process_info.h

@@ -24,6 +24,7 @@
 #include "base/macros.h"
 #include "util/misc/initialization_state_dcheck.h"
 #include "util/numeric/checked_range.h"
+#include "util/process/process_id.h"
 #include "util/stdlib/aligned_allocator.h"
 #include "util/win/address_types.h"
 
@@ -105,10 +106,10 @@ class ProcessInfo {
   bool IsWow64() const;
 
   //! \return The target process's process ID.
-  pid_t ProcessID() const;
+  crashpad::ProcessID ProcessID() const;
 
   //! \return The target process's parent process ID.
-  pid_t ParentProcessID() const;
+  crashpad::ProcessID ParentProcessID() const;
 
   //! \return The command line from the target process's Process Environment
   //!     Block.
@@ -173,8 +174,8 @@ class ProcessInfo {
   // This function is best-effort under low memory conditions.
   std::vector<Handle> BuildHandleVector(HANDLE process) const;
 
-  pid_t process_id_;
+  crashpad::ProcessID process_id_;
-  pid_t inherited_from_process_id_;
+  crashpad::ProcessID inherited_from_process_id_;
   HANDLE process_;
   std::wstring command_line_;
   WinVMAddress peb_address_;