A simple minidump writer for postmortem stability reports.

components/browser_watcher/postmortem_minidump_writer.h

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_BROWSER_WATCHER_POSTMORTEM_MINIDUMP_WRITER_H_
+#define COMPONENTS_BROWSER_WATCHER_POSTMORTEM_MINIDUMP_WRITER_H_
+
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/files/file.h"
+#include "base/macros.h"
+#include "base/strings/string_piece.h"
+#include "components/browser_watcher/stability_report.pb.h"
+#include "third_party/crashpad/crashpad/minidump/minidump_extensions.h"
+#include "third_party/crashpad/crashpad/util/misc/uuid.h"
+
+namespace browser_watcher {
+
+// A class with functionality for writing minimal minidump containers to wrap
+// postmortem stability reports.
+// TODO(manzagop): remove this class once CrashPad takes over writing postmortem
+//     minidumps.
+// TODO(manzagop): revisit where the module information should be transported,
+//     in the protocol buffer or in a module stream.
+class PostmortemMinidumpWriter {
+ public:
+  struct ReportInfo;
+
+  PostmortemMinidumpWriter() = default;
+  ~PostmortemMinidumpWriter() = default;
+
+  // Write to |minidump_file| a minimal minidump that wraps |report|. Returns
+  // true on success, false otherwise.
+  // Note: the caller owns |minidump_file| and is responsible for keeping it
+  // valid for this object's lifetime. |minidump_file| is expected to be empty
+  // and a binary stream.
+  bool WriteDump(base::PlatformFile minidump_file,
+                 const StabilityReport& report,
+                 const ReportInfo& report_info);
+
+ private:
+  // An offset within a minidump file. Note: using this type to avoid including
+  // windows.h and relying on the RVA type.
+  using FilePosition = uint32_t;
+
+  // The minidump header is always located at the head.
+  static const FilePosition kHeaderPos = 0U;
+
+  void Initialize();
+
+  bool AppendCrashpadInfo(const crashpad::UUID& client_id,
+                          const crashpad::UUID& report_id,
+                          const std::map<std::string, std::string>& crash_keys);
+
+  bool AppendCrashpadDictionaryEntry(
+      const std::string& key,
+      const std::string& value,
+      std::vector<crashpad::MinidumpSimpleStringDictionaryEntry>* entries);
+
+  // Allocate |size_bytes| within the minidump. On success, |pos| contains the
+  // location of the allocation. Returns true on success, false otherwise.
+  bool Allocate(size_t size_bytes, FilePosition* pos);
+
+  // Seeks |cursor_|. The seek operation is kept separate from the write in
+  // order to make the call explicit. Seek operations can be costly and should
+  // be avoided.
+  bool SeekCursor(FilePosition destination);
+
+  // Write to pre-allocated space.
+  // Note: |pos| must match |cursor_|.
+  template <class DataType>
+  bool Write(FilePosition pos, const DataType& data);
+  bool WriteBytes(FilePosition pos, size_t size_bytes, const char* data);
+
+  // Allocate space for and write the contents of |data|. On success, |pos|
+  // contains the location of the write. Returns true on success, false
+  // otherwise.
+  template <class DataType>
+  bool Append(const DataType& data, FilePosition* pos);
+  template <class DataType>
+  bool AppendVec(const std::vector<DataType>& data, FilePosition* pos);
+  bool AppendUtf8String(base::StringPiece data, FilePosition* pos);
+  bool AppendBytes(base::StringPiece data, FilePosition* pos);
+
+  void RegisterDirectoryEntry(uint32_t stream_type,
+                              FilePosition pos,
+                              uint32_t size);
+
+  // The next allocatable FilePosition.
+  FilePosition next_available_byte_;
+
+  // Storage for the directory during writes.
+  std::vector<MINIDUMP_DIRECTORY> directory_;
+
+  // The file to write to.
+  std::unique_ptr<base::File> minidump_file_;

[Sigurður Ásgeirsson, 2016/09/13 14:57:09]

IMHO simpler to use a base::File* here, and scope the instance in the WriteDump
function, as mentioned below.

[manzagop (departed), 2016/09/13 16:22:44]

Done.

+
+  DISALLOW_COPY_AND_ASSIGN(PostmortemMinidumpWriter);
+};
+
+struct PostmortemMinidumpWriter::ReportInfo {
+  crashpad::UUID client_id;

[Sigurður Ásgeirsson, 2016/09/13 14:57:09]

nit: maybe a little bit of documentation?

[manzagop (departed), 2016/09/13 16:22:44]

Done.

+  crashpad::UUID report_id;
+  std::string product_name;
+  std::string version_number;
+};
+
+template <class DataType>
+bool PostmortemMinidumpWriter::Write(FilePosition pos, const DataType& data) {
+  // Note: we cannot static_assert that std::is_pod<DataType>::value, because
+  // MinidumpCrashpadInfo is in fact non-POD.
+  return WriteBytes(pos, sizeof(data), reinterpret_cast<const char*>(&data));
+}
+
+template <class DataType>
+bool PostmortemMinidumpWriter::Append(const DataType& data, FilePosition* pos) {
+  // Note: we cannot static_assert that std::is_pod<DataType>::value, because

[Sigurður Ásgeirsson, 2016/09/13 14:57:09]

No need for the note, if we can't do it, we can't do it.
Are there weaker <type_traits> or assertions we can usefully make (don't sweat
it overmuch, this is a nice-to-have)? 

[manzagop (departed), 2016/09/13 16:22:44]

Found is_trivially_copyable. Done.

+  // MinidumpCrashpadInfo is in fact non-POD.
+  DCHECK(pos);
+  if (!Allocate(sizeof(data), pos))
+    return false;
+  return Write(*pos, data);
+}
+
+template <class DataType>
+bool PostmortemMinidumpWriter::AppendVec(const std::vector<DataType>& data,
+                                         FilePosition* pos) {
+  static_assert(std::is_pod<DataType>::value, "restricted to POD");
+  DCHECK(!data.empty());
+  DCHECK(pos);
+
+  size_t size_bytes = sizeof(DataType) * data.size();
+  if (!Allocate(size_bytes, pos))
+    return false;
+  return WriteBytes(*pos, size_bytes,
+                    reinterpret_cast<const char*>(&data.at(0)));
+}
+
+}  // namespace browser_watcher
+
+#endif  // COMPONENTS_BROWSER_WATCHER_POSTMORTEM_MINIDUMP_WRITER_H_