Use the correct product/version for postmortem reports

components/browser_watcher/watcher_metrics_provider_win_unittest.cc

 // Copyright (c) 2014 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/watcher_metrics_provider_win.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cstdlib>
 
+#include "base/memory/ptr_util.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/test_reg_util_win.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/win/registry.h"
 #include "components/browser_watcher/exit_funnel_win.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 48 matching lines @@
     ASSERT_EQ(key.WriteValue(name, &value, sizeof(value), REG_QWORD),
               ERROR_SUCCESS);
   }
 
  protected:
   registry_util::RegistryOverrideManager override_manager_;
   base::HistogramTester histogram_tester_;
   scoped_refptr<base::TestSimpleTaskRunner> test_task_runner_;
 };
 
+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
 
 TEST_F(WatcherMetricsProviderWinTest, RecordsStabilityHistogram) {
   // Record multiple success exits.
   for (size_t i = 0; i < 11; ++i)
     AddProcessExitCode(false, 0);
 
   // Record a single failure.
   AddProcessExitCode(false, 100);
 
-  WatcherMetricsProviderWin provider(kRegistryPath, base::FilePath(),
-                                     base::FilePath(), test_task_runner_.get());
+  WatcherMetricsProviderWin provider(
+      kRegistryPath, base::FilePath(), base::FilePath(),
+      base::WrapUnique(new PostmortemReportCollectorForTest()),
+      test_task_runner_.get());
 
   provider.ProvideStabilityMetrics(NULL);
   histogram_tester_.ExpectBucketCount(
         WatcherMetricsProviderWin::kBrowserExitCodeHistogramName, 0, 11);
   histogram_tester_.ExpectBucketCount(
         WatcherMetricsProviderWin::kBrowserExitCodeHistogramName, 100, 1);
   histogram_tester_.ExpectTotalCount(
         WatcherMetricsProviderWin::kBrowserExitCodeHistogramName, 12);
 
   // Verify that the reported values are gone.
   EXPECT_EQ(0u, ExitCodeRegistryPathValueCount());
 }
 
 TEST_F(WatcherMetricsProviderWinTest, DoesNotReportOwnProcessId) {
   // Record multiple success exits.
   for (size_t i = 0; i < 11; ++i)
     AddProcessExitCode(i, 0);
 
   // Record own process as STILL_ACTIVE.
   AddProcessExitCode(true, STILL_ACTIVE);
 
-  WatcherMetricsProviderWin provider(kRegistryPath, base::FilePath(),
-                                     base::FilePath(), test_task_runner_.get());
+  WatcherMetricsProviderWin provider(
+      kRegistryPath, base::FilePath(), base::FilePath(),
+      base::WrapUnique(new PostmortemReportCollectorForTest()),
+      test_task_runner_.get());
 
   provider.ProvideStabilityMetrics(NULL);
   histogram_tester_.ExpectUniqueSample(
         WatcherMetricsProviderWin::kBrowserExitCodeHistogramName, 0, 11);
 
   // Verify that the reported values are gone.
   EXPECT_EQ(1u, ExitCodeRegistryPathValueCount());
 }
 
 TEST_F(WatcherMetricsProviderWinTest, DeletesRecordedExitFunnelEvents) {
   // Record an exit funnel and make sure the registry is cleaned up on
   // reporting, without recording any events.
   AddExitFunnelEvent(100, L"One", 1000 * 1000);
   AddExitFunnelEvent(101, L"Two", 1010 * 1000);
   AddExitFunnelEvent(102, L"Three", 990 * 1000);
 
   base::win::RegistryKeyIterator it(HKEY_CURRENT_USER, kRegistryPath);
   EXPECT_EQ(3u, it.SubkeyCount());
 
-  WatcherMetricsProviderWin provider(kRegistryPath, base::FilePath(),
-                                     base::FilePath(), test_task_runner_.get());
+  WatcherMetricsProviderWin provider(
+      kRegistryPath, base::FilePath(), base::FilePath(),
+      base::WrapUnique(new PostmortemReportCollectorForTest()),
+      test_task_runner_.get());
 
   provider.ProvideStabilityMetrics(NULL);
   // Make sure the exit funnel events are no longer recorded in histograms.
   EXPECT_TRUE(
       histogram_tester_.GetAllSamples("Stability.ExitFunnel.One").empty());
   EXPECT_TRUE(
       histogram_tester_.GetAllSamples("Stability.ExitFunnel.Two").empty());
   EXPECT_TRUE(
       histogram_tester_.GetAllSamples("Stability.ExitFunnel.Three").empty());
 
@@ skipping 13 matching lines @@
   AddProcessExitCode(false, 100);
 
   // Record an exit funnel.
   ASSERT_TRUE(funnel.InitImpl(kRegistryPath, 4, base::Time::Now()));
 
   AddExitFunnelEvent(100, L"One", 1000 * 1000);
   AddExitFunnelEvent(101, L"Two", 1010 * 1000);
   AddExitFunnelEvent(102, L"Three", 990 * 1000);
 
   // Make like the user is opted out of reporting.
-  WatcherMetricsProviderWin provider(kRegistryPath, base::FilePath(),
-                                     base::FilePath(), test_task_runner_.get());
+  WatcherMetricsProviderWin provider(
+      kRegistryPath, base::FilePath(), base::FilePath(),
+      base::WrapUnique(new PostmortemReportCollectorForTest()),
+      test_task_runner_.get());
   provider.OnRecordingDisabled();
 
   base::win::RegKey key;
   {
     // The deletion should be scheduled to the test_task_runner, and not happen
     // immediately.
     ASSERT_EQ(ERROR_SUCCESS,
               key.Open(HKEY_CURRENT_USER, kRegistryPath, KEY_READ));
   }
 
@@ skipping 10 matching lines @@
   for (size_t i = 0; i < 200; ++i) {
     AddExitFunnelEvent(i, L"One", 10);
     AddExitFunnelEvent(i, L"Two", 10);
   }
 
   base::win::RegistryKeyIterator it(HKEY_CURRENT_USER, kRegistryPath);
   EXPECT_EQ(200u, it.SubkeyCount());
 
   {
     // Make like the user is opted out of reporting.
-    WatcherMetricsProviderWin provider(kRegistryPath, base::FilePath(),
-                                       base::FilePath(),
-                                       test_task_runner_.get());
+    WatcherMetricsProviderWin provider(
+        kRegistryPath, base::FilePath(), base::FilePath(),
+        base::WrapUnique(new PostmortemReportCollectorForTest()),
+        test_task_runner_.get());
     provider.OnRecordingDisabled();
     // Flush the task(s).
     test_task_runner_->RunPendingTasks();
   }
 
   // We expect only 100 of the funnels have been scrubbed.
   EXPECT_EQ(100u, it.SubkeyCount());
 }
 
 }  // namespace browser_watcher