Switch stability reports to use the crashed version's details

components/browser_watcher/postmortem_report_collector_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_report_collector.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/debug/activity_analyzer.h"
 #include "base/debug/activity_tracker.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/persistent_memory_allocator.h"
 #include "base/process/process_handle.h"
 #include "base/stl_util.h"
 #include "base/threading/platform_thread.h"
+#include "components/browser_watcher/stability_data_names.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/crashpad/crashpad/client/crash_report_database.h"
 
 namespace browser_watcher {
 
 using base::debug::ActivityData;
 using base::debug::ActivityTrackerMemoryAllocator;
 using base::debug::ActivityUserData;
 using base::debug::GlobalActivityTracker;
 using base::debug::ThreadActivityTracker;
 using base::File;
 using base::FilePersistentMemoryAllocator;
 using base::MemoryMappedFile;
 using base::PersistentMemoryAllocator;
 using base::WrapUnique;
 using crashpad::CrashReportDatabase;
 using crashpad::Settings;
 using crashpad::UUID;
 using testing::_;
 using testing::Return;
 using testing::SetArgPointee;
 
 namespace {
 
 const char kProductName[] = "TestProduct";
 const char kVersionNumber[] = "TestVersionNumber";
 const char kChannelName[] = "TestChannel";
 
+void ContainsKeyValue(
+    const google::protobuf::Map<std::string, TypedValue>& data,
+    const std::string& key,
+    const std::string& value) {
+  auto it = data.find(key);
+  ASSERT_TRUE(it != data.end());
+  EXPECT_EQ(TypedValue::kStringValue, it->second.value_case());
+  EXPECT_EQ(value, it->second.string_value());
+}
+
 // Exposes a public constructor in order to create a dummy database.
 class MockCrashReportDatabase : public CrashReportDatabase {
  public:
   MockCrashReportDatabase() {}
   MOCK_METHOD0(GetSettings, Settings*());
   MOCK_METHOD1(PrepareNewCrashReport,
                CrashReportDatabase::CrashReportDatabase::OperationStatus(
                    NewReport** report));
   MOCK_METHOD2(FinishedWritingCrashReport,
                CrashReportDatabase::CrashReportDatabase::OperationStatus(
@@ skipping 44 matching lines @@
     return SUCCESS;
   }
 
   MOCK_METHOD3(GetDebugStateFilePaths,
                std::vector<base::FilePath>(
                    const base::FilePath& debug_info_dir,
                    const base::FilePath::StringType& debug_file_pattern,
                    const std::set<base::FilePath>&));
   MOCK_METHOD1(CollectRaw, StabilityReport*(const base::FilePath&));
   MOCK_METHOD4(WriteReportToMinidump,
-               bool(const StabilityReport& report,
+               bool(StabilityReport* report,
                     const crashpad::UUID& client_id,
                     const crashpad::UUID& report_id,
                     base::PlatformFile minidump_file));
 };
 
 // Checks if two proto messages are the same based on their serializations. Note
 // this only works if serialization is deterministic, which is not guaranteed.
 // In practice, serialization is deterministic (even for protocol buffers with
 // maps) and such matchers are common in the Chromium code base. Also note that
 // in the context of this test, false positive matches are the problem and these
@@ skipping 53 matching lines @@
     crashpad::UUID new_report_uuid;
     new_report_uuid.InitializeWithNew();
     crashpad_report_ = {minidump_file.GetPlatformFile(), new_report_uuid,
                         minidump_path};
     EXPECT_CALL(database_, PrepareNewCrashReport(_))
         .Times(1)
         .WillOnce(DoAll(SetArgPointee<0>(&crashpad_report_),
                         Return(CrashReportDatabase::kNoError)));
 
     EXPECT_CALL(collector_,
-                WriteReportToMinidump(EqualsProto(*stability_report), _, _,
+                WriteReportToMinidump(stability_report, _, _,
                                       minidump_file.GetPlatformFile()))
         .Times(1)
         .WillOnce(Return(true));
   }
 
  protected:
   base::ScopedTempDir temp_dir_;
   base::FilePath debug_file_;
   MockCrashReportDatabase database_;
   MockPostmortemReportCollector collector_;
@@ skipping 374 matching lines @@
   // Collect the stability report.
   PostmortemReportCollector collector(kProductName, kVersionNumber,
                                       kChannelName);
   std::unique_ptr<StabilityReport> report;
   ASSERT_EQ(PostmortemReportCollector::SUCCESS,
             collector.Collect(debug_file_path(), &report));
   ASSERT_NE(nullptr, report);
 
   // Validate the report's user data.
   const auto& collected_data = report->global_data();
-  ASSERT_EQ(8U, collected_data.size());
+  ASSERT_EQ(12U, collected_data.size());
 
   ASSERT_TRUE(base::ContainsKey(collected_data, "raw"));
   EXPECT_EQ(TypedValue::kBytesValue, collected_data.at("raw").value_case());
   EXPECT_EQ("foo", collected_data.at("raw").bytes_value());
 
   ASSERT_TRUE(base::ContainsKey(collected_data, "string"));
   EXPECT_EQ(TypedValue::kStringValue, collected_data.at("string").value_case());
   EXPECT_EQ("bar", collected_data.at("string").string_value());
 
   ASSERT_TRUE(base::ContainsKey(collected_data, "char"));
@@ skipping 18 matching lines @@
   EXPECT_EQ(reinterpret_cast<uintptr_t>(string1), ref.address());
   EXPECT_EQ(strlen(string1), static_cast<uint64_t>(ref.size()));
 
   ASSERT_TRUE(base::ContainsKey(collected_data, "sref"));
   EXPECT_EQ(TypedValue::kStringReference,
             collected_data.at("sref").value_case());
   const TypedValue::Reference& sref =
       collected_data.at("sref").string_reference();
   EXPECT_EQ(reinterpret_cast<uintptr_t>(string2), sref.address());
   EXPECT_EQ(strlen(string2), static_cast<uint64_t>(sref.size()));
+
+  // Reporter's version details.
+  ContainsKeyValue(collected_data, kStabilityReporterProduct, kProductName);
+  ContainsKeyValue(collected_data, kStabilityReporterChannel, kChannelName);
+#if defined(ARCH_CPU_X86)
+  ContainsKeyValue(collected_data, kStabilityReporterPlatform, "Win32");
+#elif defined(ARCH_CPU_X86_64)
+  ContainsKeyValue(collected_data, kStabilityReporterPlatform, "Win64");
+#endif
+  ContainsKeyValue(collected_data, kStabilityReporterVersion, kVersionNumber);
 }
 
 TEST_F(PostmortemReportCollectorCollectionFromGlobalTrackerTest,
        ModuleCollection) {
   // Record some module information.
   GlobalActivityTracker::CreateWithFile(debug_file_path(), kMemorySize, 0ULL,
                                         "", 3);
 
   base::debug::GlobalActivityTracker::ModuleInfo module_info = {};
   module_info.is_loaded = true;
@@ skipping 31 matching lines @@
   EXPECT_EQ("CAFECAFE2d000", collected_module.code_identifier());
   EXPECT_EQ(module_info.debug_file, collected_module.debug_file());
   EXPECT_EQ("1122334455667788ABCD0123456789AB1",
             collected_module.debug_identifier());
   EXPECT_EQ("", collected_module.version());
   EXPECT_EQ(0LL, collected_module.shrink_down_delta());
   EXPECT_EQ(!module_info.is_loaded, collected_module.is_unloaded());
 }
 
 }  // namespace browser_watcher