Use the correct product/version for postmortem reports

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>
@@ skipping 28 matching lines @@
 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";
+
 // 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 25 matching lines @@
                    crashpad::Metrics::CrashSkippedReason reason));
   MOCK_METHOD1(DeleteReport,
                CrashReportDatabase::OperationStatus(const UUID& uuid));
   MOCK_METHOD1(RequestUpload,
                CrashReportDatabase::OperationStatus(const UUID& uuid));
 };
 
 // Used for testing CollectAndSubmitForUpload.
 class MockPostmortemReportCollector : public PostmortemReportCollector {
  public:
-  MockPostmortemReportCollector() {}
+  MockPostmortemReportCollector()
+      : PostmortemReportCollector(kProductName, kVersionNumber, kChannelName) {}
 
   // A function that returns a unique_ptr cannot be mocked, so mock a function
   // that returns a raw pointer instead.
   CollectionStatus Collect(const base::FilePath& debug_state_file,
                            std::unique_ptr<StabilityReport>* report) override {
     DCHECK_NE(nullptr, report);
     report->reset(CollectRaw(debug_state_file));
     return SUCCESS;
   }
 
@@ skipping 151 matching lines @@
     file.reset(base::OpenFile(path, "w"));
     ASSERT_NE(file.get(), nullptr);
     expected_paths.push_back(path);
 
     // Does not match the pattern.
     path = temp_dir.path().AppendASCII("bar.baz");
     file.reset(base::OpenFile(path, "w"));
     ASSERT_NE(file.get(), nullptr);
   }
 
-  PostmortemReportCollector collector;
+  PostmortemReportCollector collector(kProductName, kVersionNumber,
+                                      kChannelName);
   EXPECT_THAT(
       collector.GetDebugStateFilePaths(
           temp_dir.path(), FILE_PATH_LITERAL("foo*.pma"), excluded_paths),
       testing::UnorderedElementsAreArray(expected_paths));
 }
 
 TEST(PostmortemReportCollectorTest, CollectEmptyFile) {
   // Create an empty file.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath file_path = temp_dir.path().AppendASCII("empty.pma");
   {
     base::ScopedFILE file(base::OpenFile(file_path, "w"));
     ASSERT_NE(file.get(), nullptr);
   }
   ASSERT_TRUE(PathExists(file_path));
 
   // Validate collection: an empty file cannot suppport an analyzer.
-  PostmortemReportCollector collector;
+  PostmortemReportCollector collector(kProductName, kVersionNumber,
+                                      kChannelName);
   std::unique_ptr<StabilityReport> report;
   ASSERT_EQ(PostmortemReportCollector::ANALYZER_CREATION_FAILED,
             collector.Collect(file_path, &report));
 }
 
 TEST(PostmortemReportCollectorTest, CollectRandomFile) {
   // Create a file with content we don't expect to be valid for a debug file.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath file_path = temp_dir.path().AppendASCII("invalid_content.pma");
   {
     base::ScopedFILE file(base::OpenFile(file_path, "w"));
     ASSERT_NE(file.get(), nullptr);
     // Assuming this size is greater than the minimum size of a debug file.
     std::vector<uint8_t> data(1024);
     for (size_t i = 0; i < data.size(); ++i)
       data[i] = i % UINT8_MAX;
     ASSERT_EQ(data.size(),
               fwrite(&data.at(0), sizeof(uint8_t), data.size(), file.get()));
   }
   ASSERT_TRUE(PathExists(file_path));
 
   // Validate collection: random content appears as though there is not
   // stability data.
-  PostmortemReportCollector collector;
+  PostmortemReportCollector collector(kProductName, kVersionNumber,
+                                      kChannelName);
   std::unique_ptr<StabilityReport> report;
   ASSERT_EQ(PostmortemReportCollector::DEBUG_FILE_NO_DATA,
             collector.Collect(file_path, &report));
 }
 
 namespace {
 
 // Parameters for the activity tracking.
 const size_t kFileSize = 2 * 1024;
 const int kStackDepth = 4;
@@ skipping 73 matching lines @@
 
   const base::FilePath& debug_file_path() const { return debug_file_path_; }
 
  private:
   base::ScopedTempDir temp_dir_;
   base::FilePath debug_file_path_;
 };
 
 TEST_F(PostmortemReportCollectorCollectionTest, CollectSuccess) {
   // Validate collection returns the expected report.
-  PostmortemReportCollector collector;
+  PostmortemReportCollector collector(kProductName, kVersionNumber,
+                                      kChannelName);
   std::unique_ptr<StabilityReport> report;
   ASSERT_EQ(PostmortemReportCollector::SUCCESS,
             collector.Collect(debug_file_path(), &report));
   ASSERT_NE(nullptr, report);
 
   // Build the expected report.
   StabilityReport expected_report;
   ProcessState* process_state = expected_report.add_process_states();
   ThreadState* thread_state = process_state->add_threads();
   thread_state->set_thread_name(base::PlatformThread::GetName());
 
   ASSERT_EQ(expected_report.SerializeAsString(), report->SerializeAsString());
 }
 
 }  // namespace browser_watcher