Switch stability reports to use the crashed version's details

components/browser_watcher/postmortem_report_collector.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_report_collector.h"
 
 #include <utility>
 
 #include "base/debug/activity_analyzer.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/browser_watcher/postmortem_minidump_writer.h"
+#include "components/browser_watcher/stability_data_names.h"
 #include "third_party/crashpad/crashpad/client/settings.h"
 #include "third_party/crashpad/crashpad/util/misc/uuid.h"
 
 using base::FilePath;
 
 namespace browser_watcher {
 
 using ActivitySnapshot = base::debug::ThreadActivityAnalyzer::Snapshot;
 using base::debug::ActivityUserData;
 using base::debug::GlobalActivityAnalyzer;
@@ skipping 189 matching lines @@
   CrashReportDatabase::OperationStatus database_status =
       report_database->PrepareNewCrashReport(&new_report);
   if (database_status != CrashReportDatabase::kNoError) {
     LOG(ERROR) << "PrepareNewCrashReport failed";
     return PREPARE_NEW_CRASH_REPORT_FAILED;
   }
   CrashReportDatabase::CallErrorWritingCrashReport
       call_error_writing_crash_report(report_database, new_report);
 
   // Write the report to a minidump.
-  if (!WriteReportToMinidump(*report_proto, client_id, new_report->uuid,
+  if (!WriteReportToMinidump(report_proto.get(), client_id, new_report->uuid,
                              reinterpret_cast<FILE*>(new_report->handle))) {
     return WRITE_TO_MINIDUMP_FAILED;
   }
 
   // If the file cannot be deleted, do not report its contents. Note this can
   // lead to under reporting and retries. However, under reporting is
   // preferable to the over reporting that would happen with a file that
   // cannot be deleted.
   // TODO(manzagop): metrics for the number of non-deletable files.
   if (!base::DeleteFile(file, false)) {
@@ skipping 40 matching lines @@
 
   // Create the report, then flesh it out.
   report->reset(new StabilityReport());
 
   // Collect log messages.
   for (const std::string& message : log_messages) {
     (*report)->add_log_messages(message);
   }
 
   // Collect global user data.
-  CollectUserData(global_data_snapshot, (*report)->mutable_global_data());
+  google::protobuf::Map<std::string, TypedValue>* global_data =

[bcwhite, 2017/02/13 13:16:59]

You can change this to a reference type and then dereference the pointer here
and so avoid (*global_data) everywhere below.

[manzagop (departed), 2017/02/13 17:07:45]

Done.

+      (*report)->mutable_global_data();
+  CollectUserData(global_data_snapshot, global_data);
+
+  // Add the reporting Chrome's details to the report.
+  (*global_data)[kStabilityReporterChannel].set_string_value(channel_name());
+#if defined(ARCH_CPU_X86)
+  (*global_data)[kStabilityReporterPlatform].set_string_value(
+      std::string("Win32"));
+#elif defined(ARCH_CPU_X86_64)
+  (*global_data)[kStabilityReporterPlatform].set_string_value(
+      std::string("Win64"));
+#endif
+  (*global_data)[kStabilityReporterProduct].set_string_value(product_name());
+  (*global_data)[kStabilityReporterVersion].set_string_value(version_number());
 
   // Collect thread activity data.
   // Note: a single process is instrumented.
   ProcessState* process_state = (*report)->add_process_states();
   for (; thread_analyzer != nullptr;
        thread_analyzer = global_analyzer->GetNextAnalyzer()) {
     // Only valid analyzers are expected per contract of GetFirstAnalyzer /
     // GetNextAnalyzer.
     DCHECK(thread_analyzer->IsValid());
 
@@ skipping 56 matching lines @@
 
     // Collect user data
     if (i < snapshot.user_data_stack.size()) {
       CollectUserData(snapshot.user_data_stack[i],
                       collected->mutable_user_data());
     }
   }
 }
 
 bool PostmortemReportCollector::WriteReportToMinidump(
-    const StabilityReport& report,
+    StabilityReport* report,
     const crashpad::UUID& client_id,
     const crashpad::UUID& report_id,
     base::PlatformFile minidump_file) {
-  MinidumpInfo minidump_info;
-  minidump_info.client_id = client_id;
-  minidump_info.report_id = report_id;
-  // TODO(manzagop): replace this information, i.e. the reporter's attributes,
-  // by that of the reportee. Doing so requires adding this information to the
-  // stability report. In the meantime, there is a tolerable information
-  // mismatch after upgrades.
-  minidump_info.product_name = product_name();
-  minidump_info.version_number = version_number();
-  minidump_info.channel_name = channel_name();
-#if defined(ARCH_CPU_X86)
-  minidump_info.platform = std::string("Win32");
-#elif defined(ARCH_CPU_X86_64)
-  minidump_info.platform = std::string("Win64");
-#endif
+  DCHECK(report);
 
-  return WritePostmortemDump(minidump_file, report, minidump_info);
+  return WritePostmortemDump(minidump_file, client_id, report_id, report);
 }
 
 }  // namespace browser_watcher