A simple minidump writer for postmortem stability reports.

Enables writing a minimal minidump for wrapping a StabilityReport protocol buffer. The minidump is meant to be valid for registration with the Crashpad reporter (includes the Crashpad info stream).

BUG=620813

Review-Url: https://codereview.chromium.org/2327043002
Cr-Commit-Position: refs/heads/master@{#418863}

components/browser_watcher/BUILD.gn

@@ -2,6 +2,14 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+import("//third_party/protobuf/proto_library.gni")
+
+proto_library("stability_report_proto") {
+  sources = [
+    "stability_report.proto",
+  ]
+}
+
 static_library("browser_watcher") {
   # This is a separate lib to minimize the dependencies for its
   # hosting binary "chrome_watcher.dll".
@@ -33,12 +41,28 @@ static_library("browser_watcher_client") {
   ]
 }
 
+static_library("postmortem_minidump_writer") {
+  # TODO(manzagop): remove this lib once Crashpad writes the minidumps.
+  sources = [
+    "postmortem_minidump_writer.h",
+    "postmortem_minidump_writer_win.cc",
+  ]
+  deps = [
+    ":stability_report_proto",
+    "//base",
+    "//third_party/crashpad/crashpad/client",
+    "//third_party/crashpad/crashpad/minidump",
+    "//third_party/crashpad/crashpad/util",
+  ]
+}
+
 source_set("unit_tests") {
   testonly = true
   sources = [
     "endsession_watcher_window_win_unittest.cc",
     "exit_code_watcher_win_unittest.cc",
     "exit_funnel_win_unittest.cc",
+    "postmortem_minidump_writer_win_unittest.cc",
     "watcher_client_win_unittest.cc",
     "watcher_metrics_provider_win_unittest.cc",
     "window_hang_monitor_win_unittest.cc",
@@ -47,8 +71,17 @@ source_set("unit_tests") {
   deps = [
     ":browser_watcher",
     ":browser_watcher_client",
+    ":postmortem_minidump_writer",
+    ":stability_report_proto",
     "//base",
     "//base/test:test_support",
     "//testing/gtest",
+    "//third_party/crashpad/crashpad/client",
+
+    # TODO(manzagop): remove this lib once Crashpad writes the minidumps.
+    "//third_party/crashpad/crashpad/compat",
+    "//third_party/crashpad/crashpad/minidump",
+    "//third_party/crashpad/crashpad/snapshot",
+    "//third_party/crashpad/crashpad/util",
   ]
 }

components/browser_watcher/DEPS

 include_rules = [
-  "+components/metrics"
+  "+components/metrics",
+  "+third_party/crashpad/crashpad",
 ]

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 <string>
+
+#include "base/files/file.h"
+#include "components/browser_watcher/stability_report.pb.h"
+#include "third_party/crashpad/crashpad/util/misc/uuid.h"
+
+namespace browser_watcher {
+
+// Minidump information required by the Crashpad reporter.
+struct MinidumpInfo {
+  crashpad::UUID client_id;    // The client's identifier.
+  crashpad::UUID report_id;    // The report's identifier.
+  std::string product_name;    // The product name to be used by the reporter.
+  std::string version_number;  // The product's version number.
+};
+
+// 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 function's duration. |minidump_file| is expected to be empty
+// and a binary stream.
+bool WritePostmortemDump(base::PlatformFile minidump_file,
+                         const StabilityReport& report,
+                         const MinidumpInfo& minidump_info);
+
+}  // namespace browser_watcher
+
+#endif  // COMPONENTS_BROWSER_WATCHER_POSTMORTEM_MINIDUMP_WRITER_H_

components/browser_watcher/postmortem_minidump_writer_win_unittest.cc

+// 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.
+
+#include "components/browser_watcher/postmortem_minidump_writer.h"
+
+#include <windows.h>  // NOLINT
+#include <dbghelp.h>
+
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/files/scoped_file.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/win/scoped_handle.h"
+#include "components/browser_watcher/stability_report.pb.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/crashpad/crashpad/snapshot/minidump/process_snapshot_minidump.h"
+#include "third_party/crashpad/crashpad/util/file/file_reader.h"
+#include "third_party/crashpad/crashpad/util/misc/uuid.h"
+
+namespace browser_watcher {
+
+using crashpad::UUID;
+
+const char kProductName[] = "some-product";
+const char kExpectedProductName[] = "some-product_Postmortem";
+const char kVersion[] = "51.0.2704.106";
+
+class WritePostmortemDumpTest : public testing::Test {
+ public:
+  void SetUp() override {
+    testing::Test::SetUp();
+
+    expected_client_id_ = UUID(UUID::InitializeWithNewTag{});
+    expected_report_id_ = UUID(UUID::InitializeWithNewTag{});
+
+    // Create a stability report.
+    // TODO(manzagop): flesh out the report once proto is more detailed.
+    ProcessState* process_state = expected_report_.add_process_states();
+    CodeModule* module = process_state->add_modules();
+    module->set_base_address(1024);
+    module->set_code_file("some_code_file.dll");
+
+    // Write the minidump.
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+    minidump_path_ = temp_dir_.path().AppendASCII("minidump.dmp");
+  }
+
+  bool WriteDump() {
+    base::win::ScopedHandle file_handle(::CreateFile(
+        minidump_path_.value().c_str(), GENERIC_READ | GENERIC_WRITE,
+        FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, CREATE_NEW,
+        FILE_ATTRIBUTE_NORMAL, nullptr));
+    if (!file_handle.IsValid())
+      return false;
+
+    MinidumpInfo mindump_info;
+    mindump_info.client_id = expected_client_id_;
+    mindump_info.report_id = expected_report_id_;
+    mindump_info.product_name = kProductName;
+    mindump_info.version_number = kVersion;
+
+    return WritePostmortemDump(file_handle.Get(), expected_report_,
+                               mindump_info);
+  }
+
+  const base::FilePath& minidump_path() { return minidump_path_; }
+  const UUID& expected_client_id() { return expected_client_id_; }
+  const UUID& expected_report_id() { return expected_report_id_; }
+  const StabilityReport& expected_report() { return expected_report_; }
+
+ private:
+  base::ScopedTempDir temp_dir_;
+  base::FilePath minidump_path_;
+  UUID expected_client_id_;
+  UUID expected_report_id_;
+  StabilityReport expected_report_;
+};
+
+TEST_F(WritePostmortemDumpTest, ValidateStabilityReportTest) {
+  ASSERT_TRUE(WriteDump());
+
+  // Read back the minidump to extract the proto.
+  // TODO(manzagop): rely on crashpad for reading the proto once crashpad
+  //     supports it (https://crashpad.chromium.org/bug/10).
+  base::ScopedFILE minidump_file;
+  minidump_file.reset(base::OpenFile(minidump_path(), "rb"));
+  ASSERT_TRUE(minidump_file.get());
+
+  MINIDUMP_HEADER header = {};
+  ASSERT_EQ(1U, fread(&header, sizeof(header), 1, minidump_file.get()));
+  ASSERT_EQ(static_cast<ULONG32>(MINIDUMP_SIGNATURE), header.Signature);
+  ASSERT_EQ(2U, header.NumberOfStreams);
+  RVA directory_rva = header.StreamDirectoryRva;
+
+  MINIDUMP_DIRECTORY directory = {};
+  ASSERT_EQ(0, fseek(minidump_file.get(), directory_rva, SEEK_SET));
+  ASSERT_EQ(1U, fread(&directory, sizeof(directory), 1, minidump_file.get()));
+  ASSERT_EQ(0x4B6B0002U, directory.StreamType);
+  RVA report_rva = directory.Location.Rva;
+  ULONG32 report_size_bytes = directory.Location.DataSize;
+
+  std::string recovered_serialized_report;
+  recovered_serialized_report.resize(report_size_bytes);
+  ASSERT_EQ(0, fseek(minidump_file.get(), report_rva, SEEK_SET));
+  ASSERT_EQ(report_size_bytes, fread(&recovered_serialized_report.at(0), 1,
+                                     report_size_bytes, minidump_file.get()));
+
+  // Validate the recovered report.
+  std::string expected_serialized_report;
+  expected_report().SerializeToString(&expected_serialized_report);
+  ASSERT_EQ(expected_serialized_report, recovered_serialized_report);
+
+  StabilityReport recovered_report;
+  ASSERT_TRUE(recovered_report.ParseFromString(recovered_serialized_report));
+}
+
+TEST_F(WritePostmortemDumpTest, CrashpadCanReadTest) {
+  ASSERT_TRUE(WriteDump());
+
+  // Validate crashpad can read the produced minidump.
+  crashpad::FileReader minidump_file_reader;
+  ASSERT_TRUE(minidump_file_reader.Open(minidump_path()));
+
+  crashpad::ProcessSnapshotMinidump minidump_process_snapshot;
+  ASSERT_TRUE(minidump_process_snapshot.Initialize(&minidump_file_reader));
+
+  // Validate the crashpadinfo.
+  UUID client_id;
+  minidump_process_snapshot.ClientID(&client_id);
+  ASSERT_EQ(expected_client_id(), client_id);
+
+  UUID report_id;
+  minidump_process_snapshot.ReportID(&report_id);
+  ASSERT_EQ(expected_report_id(), report_id);
+
+  std::map<std::string, std::string> parameters =
+      minidump_process_snapshot.AnnotationsSimpleMap();
+  auto it = parameters.find("product");
+  ASSERT_NE(parameters.end(), it);
+  ASSERT_EQ(kExpectedProductName, it->second);
+
+  it = parameters.find("version");
+  ASSERT_NE(parameters.end(), it);
+  ASSERT_EQ(kVersion, it->second);
+}
+
+}  // namespace browser_watcher

components/browser_watcher/stability_report.proto

+// 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.
+
+syntax = "proto2";
+
+option optimize_for = LITE_RUNTIME;
+
+package browser_watcher;
+
+// The state of the system on which Chrome is running (shutting down, battery
+// level, load, etc.).
+message SystemState {
+  // TODO(manzagop): flesh out.
+}
+
+message CodeModule {
+  // The base address of this code module as it was loaded by the process.
+  optional int64 base_address = 1;
+
+  // The size of the code module.
+  optional int64 size = 2;
+
+  // The path or file name that the code module was loaded from.
+  optional string code_file = 3;
+
+  // An identifying string used to discriminate between multiple versions and
+  // builds of the same code module.  This may contain a uuid, timestamp,
+  // version number, or any combination of this or other information, in an
+  // implementation-defined format.
+  optional string code_identifier = 4;
+
+  // The filename containing debugging information associated with the code
+  // module.  If debugging information is stored in a file separate from the
+  // code module itself (as is the case when .pdb or .dSYM files are used),
+  // this will be different from code_file.  If debugging information is
+  // stored in the code module itself (possibly prior to stripping), this
+  // will be the same as code_file.
+  optional string debug_file = 5;
+
+  // An identifying string similar to code_identifier, but identifies a
+  // specific version and build of the associated debug file.  This may be
+  // the same as code_identifier when the debug_file and code_file are
+  // identical or when the same identifier is used to identify distinct
+  // debug and code files.
+  optional string debug_identifier = 6;
+
+  // A human-readable representation of the code module's version.
+  optional string version = 7;
+}
+
+// The state of a thread.
+message ThreadState {
+  optional string thread_name = 1;
+  // TODO(manzagop): flesh out.
+}
+
+// The state of a process.
+message ProcessState {
+  // Note: likely only a subset of modules of interest (e.g. Chromium's own
+  // modules).
+  repeated CodeModule modules = 1;
+  repeated ThreadState threads = 2;
+  // TODO(manzagop): add experiment state.
+}
+
+// A stability report contains information pertaining to the execution of a
+// single logical instance of a "chrome browser". It is comprised of information
+// about the system state and about the chrome browser's processes.
+message StabilityReport {
+  optional SystemState system_state = 1;
+  // TODO(manzagop): revisit whether a single repeated field should contain all
+  //     processes, or whether it's preferable to have separate fields per type.
+  // TODO(manzagop): add information about the type of process, pid, process
+  //     times (e.g. start time), hierarchical relationships (e.g. parent pid),
+  //     command line, etc.
+  repeated ProcessState process_states = 2;
+}