Add MinidumpSystemInfoWriter and its test

minidump/minidump_system_info_writer.cc

Index: minidump/minidump_system_info_writer.cc
diff --git a/minidump/minidump_system_info_writer.cc b/minidump/minidump_system_info_writer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e2a81a673283a063a4bd48757f671d22b58757a0
--- /dev/null
+++ b/minidump/minidump_system_info_writer.cc
@@ -0,0 +1,153 @@
+// 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 "minidump/minidump_system_info_writer.h"
+
+#include <string.h>
+
+#include "base/logging.h"
+
+namespace crashpad {
+
+MinidumpSystemInfoWriter::MinidumpSystemInfoWriter()
+    : MinidumpStreamWriter(), system_info_(), csd_version_() {
+  system_info_.ProcessorArchitecture = kMinidumpCPUArchitectureUnknown;
+}
+
+MinidumpSystemInfoWriter::~MinidumpSystemInfoWriter() {
+}
+
+void MinidumpSystemInfoWriter::SetCSDVersion(const std::string& csd_version) {
+  DCHECK_EQ(state(), kStateMutable);
+
+  if (!csd_version_) {
+    csd_version_.reset(new internal::MinidumpUTF16StringWriter());
+  }
+
+  csd_version_->SetUTF8(csd_version);
+}
+
+void MinidumpSystemInfoWriter::SetCPUX86Vendor(uint32_t ebx,
+                                               uint32_t edx,
+                                               uint32_t ecx) {
+  DCHECK_EQ(state(), kStateMutable);
+  DCHECK(system_info_.ProcessorArchitecture == kMinidumpCPUArchitectureX86 ||

[Robert Sesek, 2014/08/06 17:35:46]

Not kMinidumpCPUArchitectureAMD64 here or the other x86-related methods? This
seems a little contradictory with
https://chromium.googlesource.com/crashpad/crashpad/+/master/compat/non_win/d....

Maybe clarify this at SetCPUOtherFeatures(), since that's what the test has
AMD64 using.

[Mark Mentovai, 2014/08/06 18:14:02]

rsesek wrote:
This is correct. The CPU architecture reported in a minidump is the architecture
of the process, not of the CPU itself, so a 32-bit process on x86_64 will have
kMinidumpCPUArchitectureX86, not kMinidumpCPUArchitectureAMD64. This is
explained at
https://chromium.googlesource.com/crashpad/crashpad/+/master/compat/non_win/d....

I think the docs at SetCPUOtherFeatures() are correct too, but I admit that the
situation is a little confusing. If there’s something you think I could do to
clarify it, I’ll do it.

[Robert Sesek, 2014/08/07 16:48:14]

The only thing I can think of would maybe explicitly call out
kMinidumpCPUArchitectureAMD64 at SetCPUOtherFeatures(), but that may be a little
out of place. I agree all the docs are technically correct, though.

+         system_info_.ProcessorArchitecture ==
+             kMinidumpCPUArchitectureX86Win64);
+
+  COMPILE_ASSERT(arraysize(system_info_.Cpu.X86CpuInfo.VendorId) == 3,
+                 vendor_id_must_have_3_elements);
+
+  system_info_.Cpu.X86CpuInfo.VendorId[0] = ebx;
+  system_info_.Cpu.X86CpuInfo.VendorId[1] = edx;
+  system_info_.Cpu.X86CpuInfo.VendorId[2] = ecx;
+}
+
+void MinidumpSystemInfoWriter::SetCPUX86VendorString(
+    const std::string& vendor) {
+  DCHECK_EQ(state(), kStateMutable);
+  CHECK_EQ(vendor.size(), sizeof(system_info_.Cpu.X86CpuInfo.VendorId));
+
+  uint32_t registers[3];
+  COMPILE_ASSERT(
+      sizeof(registers) == sizeof(system_info_.Cpu.X86CpuInfo.VendorId),
+      vendor_id_sizes_must_be_equal);
+
+  for (size_t index = 0; index < arraysize(registers); ++index) {
+    memcpy(&registers[index],
+           &vendor[index * sizeof(*registers)],
+           sizeof(*registers));
+  }
+
+  SetCPUX86Vendor(registers[0], registers[1], registers[2]);
+}
+
+void MinidumpSystemInfoWriter::SetCPUX86VersionAndFeatures(uint32_t version,
+                                                           uint32_t features) {
+  DCHECK_EQ(state(), kStateMutable);
+  DCHECK(system_info_.ProcessorArchitecture == kMinidumpCPUArchitectureX86 ||
+         system_info_.ProcessorArchitecture ==
+             kMinidumpCPUArchitectureX86Win64);
+
+  system_info_.Cpu.X86CpuInfo.VersionInformation = version;
+  system_info_.Cpu.X86CpuInfo.FeatureInformation = features;
+}
+
+void MinidumpSystemInfoWriter::SetCPUX86AMDExtendedFeatures(
+    uint32_t extended_features) {
+  DCHECK_EQ(state(), kStateMutable);
+  DCHECK(system_info_.ProcessorArchitecture == kMinidumpCPUArchitectureX86 ||
+         system_info_.ProcessorArchitecture ==
+             kMinidumpCPUArchitectureX86Win64);
+  DCHECK(system_info_.Cpu.X86CpuInfo.VendorId[0] == 'htuA' &&
+         system_info_.Cpu.X86CpuInfo.VendorId[1] == 'itne' &&
+         system_info_.Cpu.X86CpuInfo.VendorId[2] == 'DMAc');
+
+  system_info_.Cpu.X86CpuInfo.AMDExtendedCpuFeatures = extended_features;
+}
+
+void MinidumpSystemInfoWriter::SetCPUOtherFeatures(uint64_t features_0,
+                                                   uint64_t features_1) {
+  DCHECK_EQ(state(), kStateMutable);
+  DCHECK(system_info_.ProcessorArchitecture != kMinidumpCPUArchitectureX86 &&
+         system_info_.ProcessorArchitecture !=
+             kMinidumpCPUArchitectureX86Win64);
+
+  COMPILE_ASSERT(
+      arraysize(system_info_.Cpu.OtherCpuInfo.ProcessorFeatures) == 2,
+      processor_features_must_have_2_elements);
+
+  system_info_.Cpu.OtherCpuInfo.ProcessorFeatures[0] = features_0;
+  system_info_.Cpu.OtherCpuInfo.ProcessorFeatures[1] = features_1;
+}
+
+bool MinidumpSystemInfoWriter::Freeze() {
+  DCHECK_EQ(state(), kStateMutable);
+
+  if (!MinidumpStreamWriter::Freeze()) {
+    return false;
+  }
+
+  CHECK(csd_version_);
+
+  csd_version_->RegisterRVA(&system_info_.CSDVersionRva);
+
+  return true;
+}
+
+size_t MinidumpSystemInfoWriter::SizeOfObject() {
+  DCHECK_GE(state(), kStateFrozen);
+
+  return sizeof(system_info_);
+}
+
+std::vector<internal::MinidumpWritable*> MinidumpSystemInfoWriter::Children() {
+  DCHECK_GE(state(), kStateFrozen);
+  DCHECK(csd_version_);
+
+  std::vector<MinidumpWritable*> children(1, csd_version_.get());

[Robert Sesek, 2014/08/06 17:35:46]

Could you use a C++11 initializer list here?

http://en.cppreference.com/w/cpp/utility/initializer_list

[Mark Mentovai, 2014/08/06 18:14:02]

rsesek wrote:
We only have C++11 language support, not library support, thanks to having to
support Mac OS X 10.6. We don’t have <initializer_list>.

I’d love to do this and more (like using emplace, unique_ptr, etc.) if we could
use proper library support.

+  return children;
+}
+
+bool MinidumpSystemInfoWriter::WriteObject(FileWriterInterface* file_writer) {
+  DCHECK_EQ(state(), kStateWritable);
+
+  return file_writer->Write(&system_info_, sizeof(system_info_));
+}
+
+MinidumpStreamType MinidumpSystemInfoWriter::StreamType() const {
+  return kMinidumpStreamTypeSystemInfo;
+}
+
+}  // namespace crashpad