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 82 matching lines @@
 
   // 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;
   }
 
+  MOCK_METHOD0(GetProductName, const std::string&());
+  MOCK_METHOD0(GetProductVersion, const std::string&());
+  MOCK_METHOD0(GetProductChannel, const std::string&());
   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,
                     const crashpad::UUID& client_id,
                     const crashpad::UUID& report_id,
@@ skipping 12 matching lines @@
 // serialization.
 // TODO(manzagop): switch a matcher with guarantees.
 MATCHER_P(EqualsProto, message, "") {
   std::string expected_serialized;
   std::string actual_serialized;
   message.SerializeToString(&expected_serialized);
   arg.SerializeToString(&actual_serialized);
   return expected_serialized == actual_serialized;
 }
 
+class PostmortemReportCollectorForTest : public PostmortemReportCollector {
+ public:
+  PostmortemReportCollectorForTest()
+      : PostmortemReportCollector(),
+        product_name_("TestProduct"),
+        version_number_("TestVersionNumber"),
+        channel_name_("TestChannel") {}
+  ~PostmortemReportCollectorForTest() override = default;
+
+  const std::string& GetProductName() override { return product_name_; }
+  const std::string& GetProductVersion() override { return version_number_; }
+  const std::string& GetProductChannel() override { return channel_name_; }
+
+ private:
+  std::string product_name_;
+  std::string version_number_;
+  std::string channel_name_;
+
+  DISALLOW_COPY_AND_ASSIGN(PostmortemReportCollectorForTest);
+};
+
 }  // namespace
 
 class PostmortemReportCollectorCollectAndSubmitTest : public testing::Test {
  public:
   void SetUp() override {
     testing::Test::SetUp();
     // Create a dummy debug file.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     debug_file_ = temp_dir_.path().AppendASCII("foo-1.pma");
     {
@@ skipping 109 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;
+  PostmortemReportCollectorForTest collector;
   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;
+  PostmortemReportCollectorForTest collector;
   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;
+  PostmortemReportCollectorForTest collector;
   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;
+  PostmortemReportCollectorForTest collector;
   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