Add ProcessSnapshotMac

snapshot/process_snapshot_mac.cc

Index: snapshot/process_snapshot_mac.cc
diff --git a/snapshot/process_snapshot_mac.cc b/snapshot/process_snapshot_mac.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c7e6bea984b22d9741c73b84cc339f37f830fa48
--- /dev/null
+++ b/snapshot/process_snapshot_mac.cc
@@ -0,0 +1,157 @@
+// 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.
+
+#include "snapshot/process_snapshot_mac.h"
+
+namespace crashpad {
+
+ProcessSnapshotMac::ProcessSnapshotMac()
+    : ProcessSnapshot(),
+      system_(),
+      threads_(),
+      modules_(),
+      exception_(),
+      process_reader_(),
+      snapshot_time_(),
+      initialized_() {
+}
+
+ProcessSnapshotMac::~ProcessSnapshotMac() {
+}
+
+bool ProcessSnapshotMac::Initialize(task_t task) {
+  INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
+
+  if (gettimeofday(&snapshot_time_, nullptr) != 0) {
+    PLOG(ERROR) << "gettimeofday";
+    return false;
+  }
+
+  if (!process_reader_.Initialize(task)) {
+    return false;
+  }
+
+  system_.Initialize(&process_reader_, &snapshot_time_);
+
+  InitializeThreads();
+  InitializeModules();
+
+  INITIALIZATION_STATE_SET_VALID(initialized_);
+  return true;
+}
+
+void ProcessSnapshotMac::InitializeException(
+    thread_t exception_thread,
+    exception_type_t exception,
+    const mach_exception_data_type_t* code,
+    mach_msg_type_number_t code_count,
+    thread_state_flavor_t flavor,
+    const natural_t* state,
+    mach_msg_type_number_t state_count) {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+
+  exception_.reset(new internal::ExceptionSnapshotMac());
+  if (!exception_->Initialize(&process_reader_,

[Robert Sesek, 2014/10/15 20:53:05]

You could report the result out of this method, too. Not sure that'd be useful,
though.

+                              exception_thread,
+                              exception,
+                              code,
+                              code_count,
+                              flavor,
+                              state,
+                              state_count)) {
+    exception_.reset();
+  }
+}
+
+pid_t ProcessSnapshotMac::ProcessID() const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  return process_reader_.ProcessID();
+}
+
+pid_t ProcessSnapshotMac::ParentProcessID() const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  return process_reader_.ProcessID();
+}
+
+void ProcessSnapshotMac::SnapshotTime(timeval* snapshot_time) const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  *snapshot_time = snapshot_time_;
+}
+
+void ProcessSnapshotMac::ProcessStartTime(timeval* start_time) const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  process_reader_.StartTime(start_time);
+}
+
+void ProcessSnapshotMac::ProcessCPUTimes(timeval* user_time,
+                                         timeval* system_time) const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  process_reader_.CPUTimes(user_time, system_time);
+}
+
+const SystemSnapshot* ProcessSnapshotMac::System() const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  return &system_;
+}
+
+std::vector<const ThreadSnapshot*> ProcessSnapshotMac::Threads() const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  std::vector<const ThreadSnapshot*> threads;
+  for (internal::ThreadSnapshotMac* thread : threads_) {

[Robert Sesek, 2014/10/15 20:53:05]

You could use more auto here and in the loops below, if you wanted.

[Mark Mentovai, 2014/10/15 21:36:21]

Robert Sesek wrote:
I still think it’s kind of nice to see the type written out where it’s known and
not cumbersome. I’ve been saving auto for cases where the type is difficult to
know or difficult to parse.

(And I think you’ve asked me to change auto to not be auto in the past…)

[Robert Sesek, 2014/10/15 22:35:50]

I figured that's why you didn't, which is why I phrased it as optional. Fine to
not use auto here.

+    threads.push_back(thread);
+  }
+  return threads;
+}
+
+std::vector<const ModuleSnapshot*> ProcessSnapshotMac::Modules() const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  std::vector<const ModuleSnapshot*> modules;
+  for (internal::ModuleSnapshotMac* module : modules_) {
+    modules.push_back(module);
+  }
+  return modules;
+}
+
+const ExceptionSnapshot* ProcessSnapshotMac::Exception() const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  return exception_.get();
+}
+
+void ProcessSnapshotMac::InitializeThreads() {
+  const std::vector<ProcessReader::Thread>& process_reader_threads =
+      process_reader_.Threads();
+  for (const ProcessReader::Thread& process_reader_thread :
+       process_reader_threads) {
+    internal::ThreadSnapshotMac* thread = new internal::ThreadSnapshotMac();
+    threads_.push_back(thread);
+    if (!thread->Initialize(&process_reader_, process_reader_thread)) {
+      threads_.pop_back();
+    }
+  }
+}
+
+void ProcessSnapshotMac::InitializeModules() {
+  const std::vector<ProcessReader::Module>& process_reader_modules =
+      process_reader_.Modules();
+  for (const ProcessReader::Module& process_reader_module :
+       process_reader_modules) {
+    internal::ModuleSnapshotMac* module = new internal::ModuleSnapshotMac();
+    modules_.push_back(module);
+    if (!module->Initialize(&process_reader_, process_reader_module)) {
+      modules_.pop_back();
+    }
+  }
+}
+
+}  // namespace crashpad