Move some parts of ProcessReader (in snapshot) to ProcessInfo (in util)

snapshot/mac/process_reader.cc

 // Copyright 2014 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,
@@ skipping 72 matching lines @@
       priority(0) {
 }
 
 ProcessReader::Module::Module() : name(), reader(nullptr), timestamp(0) {
 }
 
 ProcessReader::Module::~Module() {
 }
 
 ProcessReader::ProcessReader()
-    : kern_proc_info_(),
+    : process_info_(),
       threads_(),
       modules_(),
       module_readers_(),
       task_memory_(),
       task_(TASK_NULL),
       initialized_(),
       is_64_bit_(false),
       initialized_threads_(false),
       initialized_modules_(false) {
 }
 
 ProcessReader::~ProcessReader() {
   for (const Thread& thread : threads_) {
     kern_return_t kr = mach_port_deallocate(mach_task_self(), thread.port);
     MACH_LOG_IF(ERROR, kr != KERN_SUCCESS, kr) << "mach_port_deallocate";
   }
 }
 
 bool ProcessReader::Initialize(task_t task) {
   INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
 
-  pid_t pid;
-  kern_return_t kr = pid_for_task(task, &pid);
-  if (kr != KERN_SUCCESS) {
-    MACH_LOG(ERROR, kr) << "pid_for_task";
+  if (!process_info_.InitializeFromTask(task)) {
     return false;
   }
 
-  int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};
-  size_t len = sizeof(kern_proc_info_);
-  if (sysctl(mib, arraysize(mib), &kern_proc_info_, &len, nullptr, 0) != 0) {
-    PLOG(ERROR) << "sysctl for pid " << pid;
-    return false;
-  }
-
-  DCHECK_EQ(kern_proc_info_.kp_proc.p_pid, pid);
-
-  is_64_bit_ = kern_proc_info_.kp_proc.p_flag & P_LP64;
+  is_64_bit_ = process_info_.Is64Bit();
 
   task_memory_.reset(new TaskMemory(task));
   task_ = task;
 
   INITIALIZATION_STATE_SET_VALID(initialized_);
   return true;
 }
 
-void ProcessReader::StartTime(timeval* start_time) const {
-  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
-  *start_time = kern_proc_info_.kp_proc.p_starttime;
-}
-
 bool ProcessReader::CPUTimes(timeval* user_time, timeval* system_time) const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
 
   // Calculate user and system time the same way the kernel does for
   // getrusage(). See 10.9.2 xnu-2422.90.20/bsd/kern/kern_resource.c calcru().
   timerclear(user_time);
   timerclear(system_time);
 
   // As of the 10.8 SDK, the preferred routine is MACH_TASK_BASIC_INFO.
   // TASK_BASIC_INFO_64 is equivalent and works on earlier systems.
@@ skipping 553 matching lines @@
       // The red zone would go lower into another region in memory, but no
       // region was found. Memory can only be captured to an address as low as
       // the base address of the region already found.
       *start_address = *region_base;
     }
   }
 #endif
 }
 
 }  // namespace crashpad