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>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "base/bind.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/threading/platform_thread.h"
@@ skipping 56 matching lines @@
   MOCK_METHOD2(SkipReportUpload,
                CrashReportDatabase::OperationStatus(
                    const UUID& uuid,
                    crashpad::Metrics::CrashSkippedReason reason));
   MOCK_METHOD1(DeleteReport,
                CrashReportDatabase::OperationStatus(const UUID& uuid));
   MOCK_METHOD1(RequestUpload,
                CrashReportDatabase::OperationStatus(const UUID& uuid));
 };
 
+void GetExecutableDetails(base::string16* product_name,
+                          base::string16* version_number,
+                          base::string16* channel_name) {
+  DCHECK_NE(nullptr, product_name);
+  DCHECK_NE(nullptr, version_number);
+  DCHECK_NE(nullptr, channel_name);
+
+  *product_name = L"TestProduct";
+  *version_number = L"TestVersionNumber";
+  *channel_name = L"TestChannel";
+}
+
 // Used for testing CollectAndSubmitForUpload.
 class MockPostmortemReportCollector : public PostmortemReportCollector {
  public:
-  MockPostmortemReportCollector() {}
+  MockPostmortemReportCollector()
+      : PostmortemReportCollector(base::Bind(&GetExecutableDetails)) {}
 
   // 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(base::Bind(&GetExecutableDetails));
   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(base::Bind(&GetExecutableDetails));
   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(base::Bind(&GetExecutableDetails));
   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(base::Bind(&GetExecutableDetails));
   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