Wire in postmortem report collection

components/browser_watcher/watcher_metrics_provider_win.cc

 // Copyright (c) 2014 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/watcher_metrics_provider_win.h"
 
 #include <stddef.h>
 
 #include <limits>
+#include <memory>
+#include <set>
 #include <vector>
 
 #include "base/bind.h"
+#include "base/feature_list.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/process/process.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/registry.h"
+#include "components/browser_watcher/features.h"
+#include "components/browser_watcher/postmortem_report_collector.h"
+#include "components/browser_watcher/stability_debugging_win.h"
+#include "third_party/crashpad/crashpad/client/crash_report_database.h"
 
 namespace browser_watcher {
 
 namespace {
 
 // Process ID APIs on Windows talk in DWORDs, whereas for string formatting
 // and parsing, this code uses int. In practice there are no process IDs with
 // the high bit set on Windows, so there's no danger of overflow if this is
 // done consistently.
 static_assert(sizeof(DWORD) == sizeof(int),
@@ skipping 149 matching lines @@
   LONG res = key.Open(HKEY_CURRENT_USER, registry_path.c_str(),
                       KEY_QUERY_VALUE | KEY_SET_VALUE);
   if (res == ERROR_SUCCESS) {
     DeleteAllValues(&key);
     res = key.DeleteEmptyKey(L"");
   }
   if (res != ERROR_FILE_NOT_FOUND && res != ERROR_SUCCESS)
     DVLOG(1) << "Failed to delete exit code key " << registry_path;
 }
 
+enum CollectionInitializationStatus {
+  INIT_SUCCESS = 0,
+  UNKNOWN_DIR = 1,
+  GET_STABILITY_FILE_PATH_FAILED = 2,
+  CRASHPAD_DATABASE_INIT_FAILED = 3,
+  INIT_STATUS_MAX = 4
+};
+
 }  // namespace
 
 const char WatcherMetricsProviderWin::kBrowserExitCodeHistogramName[] =
     "Stability.BrowserExitCodes";
 
 WatcherMetricsProviderWin::WatcherMetricsProviderWin(
     const base::string16& registry_path,
-    base::TaskRunner* cleanup_io_task_runner)
+    const base::FilePath& user_data_dir,
+    const base::FilePath& crash_dir,
+    base::TaskRunner* io_task_runner)
     : recording_enabled_(false),
       cleanup_scheduled_(false),
       registry_path_(registry_path),
-      cleanup_io_task_runner_(cleanup_io_task_runner) {
-  DCHECK(cleanup_io_task_runner_);
+      user_data_dir_(user_data_dir),
+      crash_dir_(crash_dir),
+      io_task_runner_(io_task_runner),
+      weak_ptr_factory_(this) {
+  DCHECK(io_task_runner_);
 }
 
 WatcherMetricsProviderWin::~WatcherMetricsProviderWin() {
 }
 
 void WatcherMetricsProviderWin::OnRecordingEnabled() {
   recording_enabled_ = true;
 }
 
 void WatcherMetricsProviderWin::OnRecordingDisabled() {
   if (!recording_enabled_ && !cleanup_scheduled_) {
     // When metrics reporting is disabled, the providers get an
     // OnRecordingDisabled notification at startup. Use that first notification
     // to issue the cleanup task.
-    cleanup_io_task_runner_->PostTask(
+    io_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DeleteExitCodeRegistryKey, registry_path_));
 
     cleanup_scheduled_ = true;
   }
 }
 
 void WatcherMetricsProviderWin::ProvideStabilityMetrics(
     metrics::SystemProfileProto* /* system_profile_proto */) {
   // Note that if there are multiple instances of Chrome running in the same
   // user account, there's a small race that will double-report the exit codes
   // from both/multiple instances. This ought to be vanishingly rare and will
   // only manifest as low-level "random" noise. To work around this it would be
   // necessary to implement some form of global locking, which is not worth it
   // here.
   RecordExitCodes(registry_path_);
   DeleteExitFunnels(registry_path_);
 }
 
+void WatcherMetricsProviderWin::CollectPostmortemReports(
+    const base::Closure& done_callback) {
+  io_task_runner_->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(
+          &WatcherMetricsProviderWin::CollectPostmortemReportsOnBlockingPool,
+          weak_ptr_factory_.GetWeakPtr()),
+      done_callback);
+}
+
+void WatcherMetricsProviderWin::CollectPostmortemReportsOnBlockingPool() {
+  // Note: the feature controls both instrumentation and collection.
+  bool is_stability_debugging_on =
+      base::FeatureList::IsEnabled(browser_watcher::kStabilityDebuggingFeature);
+  if (!is_stability_debugging_on) {
+    // TODO(manzagop): delete possible leftover data.
+    return;
+  }
+
+  SCOPED_UMA_HISTOGRAM_TIMER("ActivityTracker.Collect.TotalTime");
+
+  if (user_data_dir_.empty() || crash_dir_.empty()) {
+    LOG(ERROR) << "User data directory or crash directory is unknown.";
+    UMA_HISTOGRAM_ENUMERATION("ActivityTracker.Collect.InitStatus",

[Sigurður Ásgeirsson, 2016/09/22 13:06:12]

It irks me to see these macros used for code that'll only add one count to a
bucket in the program's lifetime. These macros go through all kinds of
contortions to provide caching for reuse. This adds code and data to the
executable - is this really how we swing? Is there anything like
UMA_GET_HISTOGRAM_POINTER()... that would allow you to retrieve the Histogram*
and then use it as appropriate below?

[manzagop (departed), 2016/09/22 15:41:57]

There doesn't seem to be, so I went with a manual version of it. 

rkaplow@ says they're working on histogram_macros.h this week and might add
something.

+      UNKNOWN_DIR, INIT_STATUS_MAX);
+    return;
+  }
+
+  // Determine the stability directory and the stability file for the current
+  // process.
+  base::FilePath stability_dir = StabilityDebugging::GetDir(user_data_dir_);
+  base::FilePath current_stability_file;
+  if (!StabilityDebugging::GetFileForProcess(
+          base::Process::Current(), user_data_dir_, &current_stability_file)) {
+    LOG(ERROR) << "Failed to get the current stability file.";
+    UMA_HISTOGRAM_ENUMERATION("ActivityTracker.Collect.InitStatus",
+        GET_STABILITY_FILE_PATH_FAILED, INIT_STATUS_MAX);
+    return;
+  }
+  const std::set<base::FilePath>& excluded_debug_files = {
+      current_stability_file};
+
+  // Create a database. Note: Chrome already has a g_database in crashpad.cc but
+  // it has internal linkage. Create a new one.
+  std::unique_ptr<crashpad::CrashReportDatabase> crashpad_database =
+      crashpad::CrashReportDatabase::InitializeWithoutCreating(crash_dir_);
+  if (!crashpad_database) {
+    LOG(ERROR) << "Failed to initialize a CrashPad database.";
+    UMA_HISTOGRAM_ENUMERATION("ActivityTracker.Collect.InitStatus",
+        CRASHPAD_DATABASE_INIT_FAILED, INIT_STATUS_MAX);
+    return;
+  }
+  UMA_HISTOGRAM_ENUMERATION("ActivityTracker.Collect.InitStatus",
+      INIT_SUCCESS, INIT_STATUS_MAX);
+
+  // TODO(manzagop): fix incorrect version attribution on update.
+  PostmortemReportCollector collector;
+  collector.CollectAndSubmitForUpload(
+      stability_dir, StabilityDebugging::GetFilePattern(), excluded_debug_files,
+      crashpad_database.get());
+}
+
 }  // namespace browser_watcher