snapshot: Add a minimal ModuleSnapshotMinidump and accessor from ProcessSnapshotMinidump

snapshot/minidump/module_snapshot_minidump.cc

+// Copyright 2014 The Crashpad Authors. All rights reserved.

[Robert Sesek, 2015/03/04 01:52:25]

2015

+//
+// 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/minidump/module_snapshot_minidump.h"
+
+#include "minidump/minidump_extensions.h"
+#include "snapshot/minidump/minidump_simple_string_dictionary_reader.h"
+#include "snapshot/minidump/minidump_string_list_reader.h"
+
+namespace crashpad {
+namespace internal {
+
+ModuleSnapshotMinidump::ModuleSnapshotMinidump()
+    : ModuleSnapshot(),
+      minidump_module_(),
+      annotations_vector_(),
+      annotations_simple_map_(),
+      initialized_() {
+}
+
+ModuleSnapshotMinidump::~ModuleSnapshotMinidump() {
+}
+
+bool ModuleSnapshotMinidump::Initialize(
+    FileReaderInterface* file_reader,
+    RVA minidump_module_rva,
+    const MINIDUMP_LOCATION_DESCRIPTOR*
+        minidump_module_crashpad_info_location) {
+  INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
+
+  if (!file_reader->SeekSet(minidump_module_rva)) {
+    return false;
+  }
+
+  if (!file_reader->ReadExactly(&minidump_module_, sizeof(minidump_module_))) {
+    return false;
+  }
+
+  InitializeModuleCrashpadInfo(file_reader,
+                               minidump_module_crashpad_info_location);
+
+  INITIALIZATION_STATE_SET_VALID(initialized_);
+  return true;
+}
+
+std::string ModuleSnapshotMinidump::Name() const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  NOTREACHED();

[Robert Sesek, 2015/03/04 01:52:25]

Are these going to be implemented eventually? If so, maybe NOTIMPLEMENETED()
would be better (does mini_chromium have that?).

[Mark Mentovai, 2015/03/04 16:24:24]

Robert Sesek wrote:
mini_chromium doesn’t have it. I don’t like that NOTIMPLEMENTED() in Chrome is
LOG(ERROR), where what I really want is more like DCHECK(false). NOTREACHED() is
DCHECK(false).

[Robert Sesek, 2015/03/04 17:06:25]

OK. Are these methods going to be implemented at some point, though?

[Mark Mentovai, 2015/03/04 17:10:21]

Robert Sesek wrote:
Yes, of course. Do you want to see comments?

[Robert Sesek, 2015/03/04 17:14:00]

Yeah TODO would probably be good (w/ associated bug). NOTIMPLEMENTED has the
nice property of being self-documenting, which is why I raised it.

+  return std::string();
+}
+
+uint64_t ModuleSnapshotMinidump::Address() const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  NOTREACHED();
+  return 0;
+}
+
+uint64_t ModuleSnapshotMinidump::Size() const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  NOTREACHED();
+  return 0;
+}
+
+time_t ModuleSnapshotMinidump::Timestamp() const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  NOTREACHED();
+  return 0;
+}
+
+void ModuleSnapshotMinidump::FileVersion(uint16_t* version_0,
+                                         uint16_t* version_1,
+                                         uint16_t* version_2,
+                                         uint16_t* version_3) const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  NOTREACHED();
+  *version_0 = 0;
+  *version_1 = 0;
+  *version_2 = 0;
+  *version_3 = 0;
+}
+
+void ModuleSnapshotMinidump::SourceVersion(uint16_t* version_0,
+                                           uint16_t* version_1,
+                                           uint16_t* version_2,
+                                           uint16_t* version_3) const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  NOTREACHED();
+  *version_0 = 0;
+  *version_1 = 0;
+  *version_2 = 0;
+  *version_3 = 0;
+}
+
+ModuleSnapshot::ModuleType ModuleSnapshotMinidump::GetModuleType() const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  NOTREACHED();
+  return kModuleTypeUnknown;
+}
+
+void ModuleSnapshotMinidump::UUID(crashpad::UUID* uuid) const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  NOTREACHED();
+  *uuid = crashpad::UUID();
+}
+
+std::vector<std::string> ModuleSnapshotMinidump::AnnotationsVector() const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  return annotations_vector_;
+}
+
+std::map<std::string, std::string>
+ModuleSnapshotMinidump::AnnotationsSimpleMap() const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  return annotations_simple_map_;
+}
+
+void ModuleSnapshotMinidump::InitializeModuleCrashpadInfo(
+    FileReaderInterface* file_reader,
+    const MINIDUMP_LOCATION_DESCRIPTOR*
+        minidump_module_crashpad_info_location) {
+  if (!minidump_module_crashpad_info_location ||
+      minidump_module_crashpad_info_location->Rva == 0) {
+    return;
+  }
+
+  MinidumpModuleCrashpadInfo minidump_module_crashpad_info;
+  if (minidump_module_crashpad_info_location->DataSize <
+      sizeof(minidump_module_crashpad_info)) {

[Robert Sesek, 2015/03/04 01:52:25]

nit: indent +4

+    LOG(ERROR) << "minidump_module_crashpad_info size mismatch";
+    return;
+  }
+
+  if (!file_reader->SeekSet(minidump_module_crashpad_info_location->Rva)) {
+    return;
+  }
+
+  if (!file_reader->ReadExactly(&minidump_module_crashpad_info,
+                                sizeof(minidump_module_crashpad_info))) {
+    return;
+  }
+
+  if (minidump_module_crashpad_info.version !=
+      MinidumpModuleCrashpadInfo::kVersion) {
+    LOG(ERROR) << "minidump_module_crashpad_info version mismatch";
+    return;
+  }
+
+  ReadMinidumpStringList(file_reader,

[Robert Sesek, 2015/03/04 01:52:25]

What if these functions return false? There's no way to tell if this object is
in a valid state or not beyond initialization.

This function should probably return bool and report that from ::Initialize()
proper.

[Mark Mentovai, 2015/03/04 16:24:24]

Robert Sesek wrote:
I’ve treated “crashpad info” as optional. This isn’t so much because it needs to
be optional, because if the file says the data should be there, it really should
be legible. It’s more because when I initially wrote this stuff, I wanted to
load stuff as lazily as possible, and there wasn’t an opportunity to return
false from Initialize() because these functions wouldn’t be called until well
after Initialize() returned.

I’ll change it so that they report success/failure and bubble it back up to
Initialize(), but I’d still like to make the lazy-loading change once the const
interface bug is fixed, and at that point, we’re back to Initialize() not
knowing about problems with these extension structures.

+                         minidump_module_crashpad_info.list_annotations,
+                         &annotations_vector_);
+
+  ReadMinidumpSimpleStringDictionary(
+      file_reader,
+      minidump_module_crashpad_info.simple_annotations,
+      &annotations_simple_map_);
+}
+
+}  // namespace internal
+}  // namespace crashpad