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

snapshot/mac/process_reader.h

 // 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,
 // 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_SNAPSHOT_MAC_PROCESS_READER_H_
 #define CRASHPAD_SNAPSHOT_MAC_PROCESS_READER_H_
 
 #include <mach/mach.h>
-#include <sys/sysctl.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <time.h>
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "util/mach/task_memory.h"
 #include "util/misc/initialization_state_dcheck.h"
+#include "util/posix/process_info.h"
 #include "util/stdlib/pointer_container.h"
 
 namespace crashpad {
 
 class MachOImageReader;
 
 //! \brief Accesses information about another process, identified by a Mach
 //!     task.
 class ProcessReader {
  public:
@@ skipping 63 matching lines @@
   //!
   //! \return `true` on success, indicating that this object will respond
   //!     validly to further method calls. `false` on failure. On failure, no
   //!     further method calls should be made.
   bool Initialize(task_t task);
 
   //! \return `true` if the target task is a 64-bit process.
   bool Is64Bit() const { return is_64_bit_; }
 
   //! \return The target task’s process ID.
-  pid_t ProcessID() const { return kern_proc_info_.kp_proc.p_pid; }
+  pid_t ProcessID() const { return process_info_.ProcessID(); }
 
   //! \return The target task’s parent process ID.
-  pid_t ParentProcessID() const { return kern_proc_info_.kp_eproc.e_ppid; }
+  pid_t ParentProcessID() const { return process_info_.ParentProcessID(); }
 
+  //! \brief Determines the target process’ start time.
+  //!
   //! \param[out] start_time The time that the process started.
-  void StartTime(timeval* start_time) const;
+  void StartTime(timeval* start_time) const {
+    process_info_.StartTime(start_time);
+  }
 
+  //! \brief Determines the target process’ execution time.
+  //!
   //! \param[out] user_time The amount of time the process has executed code in
   //!     user mode.
   //! \param[out] system_time The amount of time the process has executed code
   //!     in system mode.
   //!
   //! \return `true` on success, `false` on failure, with a warning logged. On
   //!     failure, \a user_time and \a system_time will be set to represent no
   //!     time spent executing code in user or system mode.
   bool CPUTimes(timeval* user_time, timeval* system_time) const;
 
@@ skipping 66 matching lines @@
   //! \param[in] user_tag The Mach VM system’s user tag for the region described
   //!     by the initial values of \a region_base and \a region_size. The red
   //!     zone will only be allowed to extend out of the region described by
   //!     these initial values if the user tag is appropriate for stack memory
   //!     and the expanded region has the same user tag value.
   void LocateRedZone(mach_vm_address_t* start_address,
                      mach_vm_address_t* region_base,
                      mach_vm_address_t* region_size,
                      unsigned int user_tag);
 
-  kinfo_proc kern_proc_info_;
+  ProcessInfo process_info_;
   std::vector<Thread> threads_;  // owns send rights
   std::vector<Module> modules_;
   PointerVector<MachOImageReader> module_readers_;
   scoped_ptr<TaskMemory> task_memory_;
   task_t task_;  // weak
   InitializationStateDcheck initialized_;
 
-  // This shadows a bit in kern_proc_info_, but it’s accessed so frequently that
-  // it’s given a first-class field to save a few bit operations on each access.
+  // This shadows a method of process_info_, but it’s accessed so frequently
+  // that it’s given a first-class field to save a call and a few bit operations
+  // on each access.
   bool is_64_bit_;
 
   bool initialized_threads_;
   bool initialized_modules_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessReader);
 };
 
 }  // namespace crashpad
 
 #endif  // CRASHPAD_SNAPSHOT_MAC_PROCESS_READER_H_