Decouple stability instrumentation recording and collection

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 22 matching lines @@
 #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::FilePath;
 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::DoAll;
 using testing::Return;
 using testing::SetArgPointee;
 
 namespace {
 
+TEST(PostmortemDeleterTest, BasicTest) {
+  base::HistogramTester histogram_tester;
+  base::ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+
+  // Create three files.
+  FilePath path_one = temp_dir.GetPath().AppendASCII("a.pma");
+  FilePath path_two = temp_dir.GetPath().AppendASCII("b.pma");
+  FilePath path_three = temp_dir.GetPath().AppendASCII("c.pma");
+
+  std::vector<FilePath> stability_files = {path_one, path_two, path_three};
+
+  for (const FilePath& path : stability_files) {
+    {
+      base::ScopedFILE file(base::OpenFile(path, "w"));
+      ASSERT_NE(file.get(), nullptr);
+    }
+    ASSERT_TRUE(base::PathExists(path));
+  }
+
+  // Open one stability file to prevent its deletion.
+  base::ScopedFILE file(base::OpenFile(path_two, "w"));
+  ASSERT_NE(file.get(), nullptr);
+
+  // Validate deletion and metrics.
+  PostmortemDeleter deleter;
+  deleter.Process(stability_files);
+
+  ASSERT_FALSE(base::PathExists(path_one));
+  ASSERT_FALSE(base::PathExists(path_three));
+  histogram_tester.ExpectBucketCount("ActivityTracker.Collect.Status",
+                                     UNCLEAN_SHUTDOWN, 2);
+
+  ASSERT_TRUE(base::PathExists(path_two));
+  histogram_tester.ExpectBucketCount("ActivityTracker.Collect.Status",
+                                     DEBUG_FILE_DELETION_FAILED, 1);

[Sigurður Ásgeirsson, 2017/06/05 15:39:39]

nice. Stupid question, though - wouldn't the Postmortem reporter class satisfy
this test as-written just fine? Maybe add a negative test to make sure it's not
updating the counts it shouldn't?

[manzagop (departed), 2017/06/05 18:02:16]

Done.

+}
+
 const char kProductName[] = "TestProduct";
 const char kVersionNumber[] = "TestVersionNumber";
 const char kChannelName[] = "TestChannel";
 
 // The tracker creates some data entries internally.
 const size_t kInternalProcessDatums = 1;
 
 void ContainsKeyValue(
     const google::protobuf::Map<std::string, TypedValue>& data,
     const std::string& key,
@@ skipping 39 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));
 };
 
-// Used for testing CollectAndSubmitAllPendingReports.
 class MockPostmortemReportCollector : public PostmortemReportCollector {
  public:
-  MockPostmortemReportCollector()
+  explicit MockPostmortemReportCollector(CrashReportDatabase* crash_database)
       : PostmortemReportCollector(kProductName,
                                   kVersionNumber,
                                   kChannelName,
+                                  crash_database,
                                   nullptr) {}
 
-  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_METHOD2(CollectOneReport,
-               CollectionStatus(const base::FilePath&,
-                                StabilityReport* report));
+               CollectionStatus(const FilePath&, StabilityReport* report));
   MOCK_METHOD4(WriteReportToMinidump,
                bool(StabilityReport* report,
                     const crashpad::UUID& client_id,
                     const crashpad::UUID& report_id,
                     base::PlatformFile minidump_file));
 };
 
 class MockSystemSessionAnalyzer : public SystemSessionAnalyzer {
  public:
   MockSystemSessionAnalyzer() : SystemSessionAnalyzer(10U) {}
@@ skipping 14 matching lines @@
 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;
 }
 
 }  // namespace
 
-class PostmortemReportCollectorCollectAndSubmitAllPendingReportsTest
-    : public testing::Test {
+class PostmortemReportCollectorProcessTest : public testing::Test {
  public:
-  void SetUpTest(bool system_session_clean) {
+  void SetUpTest(bool system_session_clean, bool expect_write_dump) {
+    collector_.reset(new MockPostmortemReportCollector(&database_));
+
     // Create a dummy debug file.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     debug_file_ = temp_dir_.GetPath().AppendASCII("foo-1.pma");
     {
       base::ScopedFILE file(base::OpenFile(debug_file_, "w"));
       ASSERT_NE(file.get(), nullptr);
     }
     ASSERT_TRUE(base::PathExists(debug_file_));
 
-    // Expect collection of the debug file paths.
-    debug_file_pattern_ = FILE_PATH_LITERAL("foo-*.pma");
-    std::vector<base::FilePath> debug_files{debug_file_};
-    EXPECT_CALL(collector_,
-                GetDebugStateFilePaths(debug_file_.DirName(),
-                                       debug_file_pattern_, no_excluded_files_))
-        .Times(1)
-        .WillOnce(Return(debug_files));
-
     EXPECT_CALL(database_, GetSettings()).Times(1).WillOnce(Return(nullptr));
 
     // Expect a single collection call.
     StabilityReport report;
     report.mutable_system_state()->set_session_state(
         system_session_clean ? SystemState::CLEAN : SystemState::UNCLEAN);
-    EXPECT_CALL(collector_, CollectOneReport(debug_file_, _))
+    EXPECT_CALL(*collector_, CollectOneReport(debug_file_, _))
         .Times(1)
         .WillOnce(DoAll(SetArgPointee<1>(report), Return(SUCCESS)));
 
+    if (!expect_write_dump)
+      return;
+
     // Expect the call to write the proto to a minidump. This involves
     // requesting a report from the crashpad database, writing the report, then
     // finalizing it with the database.
-    base::FilePath minidump_path = temp_dir_.GetPath().AppendASCII("foo-1.dmp");
+    FilePath minidump_path = temp_dir_.GetPath().AppendASCII("foo-1.dmp");
     base::File minidump_file(
         minidump_path, base::File::FLAG_CREATE | base::File::File::FLAG_WRITE);
     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_,
+    EXPECT_CALL(*collector_,
                 WriteReportToMinidump(_, _, _, minidump_file.GetPlatformFile()))
         .Times(1)
         .WillOnce(Return(true));
   }
   void ValidateHistograms(int unclean_cnt, int unclean_system_cnt) {
-    histogram_tester_.ExpectTotalCount(
-        "ActivityTracker.Collect.StabilityFileCount", 1);
-    histogram_tester_.ExpectBucketCount(
-        "ActivityTracker.Collect.StabilityFileCount", 1, 1);
-    histogram_tester_.ExpectTotalCount(
-        "ActivityTracker.Collect.UncleanShutdownCount", 1);
-    histogram_tester_.ExpectBucketCount(
-        "ActivityTracker.Collect.UncleanShutdownCount", unclean_cnt, 1);
-    histogram_tester_.ExpectTotalCount(
-        "ActivityTracker.Collect.UncleanSystemCount", 1);
-    histogram_tester_.ExpectBucketCount(
-        "ActivityTracker.Collect.UncleanSystemCount", unclean_system_cnt, 1);
+    histogram_tester_.ExpectBucketCount("ActivityTracker.Collect.Status",
+                                        UNCLEAN_SHUTDOWN, unclean_cnt);
+    histogram_tester_.ExpectBucketCount("ActivityTracker.Collect.Status",
+                                        UNCLEAN_SESSION, unclean_system_cnt);
   }
   void CollectReports(bool is_session_clean) {
-    SetUpTest(is_session_clean);
+    SetUpTest(is_session_clean, true);
 
     EXPECT_CALL(database_, FinishedWritingCrashReport(&crashpad_report_, _))
         .Times(1)
         .WillOnce(Return(CrashReportDatabase::kNoError));
 
     // Run the test.
-    int success_cnt = collector_.CollectAndSubmitAllPendingReports(
-        debug_file_.DirName(), debug_file_pattern_, no_excluded_files_,
-        &database_);
-    ASSERT_EQ(1, success_cnt);
+    std::vector<FilePath> debug_files{debug_file_};
+    collector_->Process(debug_files);
     ASSERT_FALSE(base::PathExists(debug_file_));
   }
 
  protected:
   base::HistogramTester histogram_tester_;
   base::ScopedTempDir temp_dir_;
-  base::FilePath debug_file_;
+  FilePath debug_file_;
   MockCrashReportDatabase database_;
-  MockPostmortemReportCollector collector_;
-  base::FilePath::StringType debug_file_pattern_;
-  std::set<base::FilePath> no_excluded_files_;
+  std::unique_ptr<MockPostmortemReportCollector> collector_;
   CrashReportDatabase::NewReport crashpad_report_;
 };
 
-TEST_F(PostmortemReportCollectorCollectAndSubmitAllPendingReportsTest,
-       CollectAndSubmitAllPendingReportsCleanSession) {
+TEST_F(PostmortemReportCollectorProcessTest, ProcessCleanSession) {
   CollectReports(true);
   int expected_unclean = 1;
   int expected_system_unclean = 0;
   ValidateHistograms(expected_unclean, expected_system_unclean);
 }
 
-TEST_F(PostmortemReportCollectorCollectAndSubmitAllPendingReportsTest,
-       CollectAndSubmitAllPendingReportsUncleanSession) {
+TEST_F(PostmortemReportCollectorProcessTest, ProcessUncleanSession) {
   CollectReports(false);
   int expected_unclean = 1;
   int expected_system_unclean = 1;
   ValidateHistograms(expected_unclean, expected_system_unclean);
 }
 
-TEST_F(PostmortemReportCollectorCollectAndSubmitAllPendingReportsTest,
-       CollectAndSubmitAllPendingReportsStuckFile) {
-  SetUpTest(true);
+TEST_F(PostmortemReportCollectorProcessTest, ProcessStuckFile) {
+  bool system_session_clean = true;
+  bool expect_write_dump = false;
+  SetUpTest(system_session_clean, expect_write_dump);
 
   // Open the stability debug file to prevent its deletion.
   base::ScopedFILE file(base::OpenFile(debug_file_, "w"));
   ASSERT_NE(file.get(), nullptr);
 
-  // Expect Crashpad is notified of an error writing the crash report.
-  EXPECT_CALL(database_, ErrorWritingCrashReport(&crashpad_report_))
-      .Times(1)
-      .WillOnce(Return(CrashReportDatabase::kNoError));
-
   // Run the test.
-  int success_cnt = collector_.CollectAndSubmitAllPendingReports(
-      debug_file_.DirName(), debug_file_pattern_, no_excluded_files_,
-      &database_);
-  ASSERT_EQ(0, success_cnt);
+  std::vector<FilePath> debug_files{debug_file_};
+  collector_->Process(debug_files);
   ASSERT_TRUE(base::PathExists(debug_file_));
 
+  histogram_tester_.ExpectBucketCount("ActivityTracker.Collect.Status",
+                                      DEBUG_FILE_DELETION_FAILED, 1);
   int expected_unclean = 0;
   int expected_system_unclean = 0;
   ValidateHistograms(expected_unclean, expected_system_unclean);
 }
 
-TEST(PostmortemReportCollectorTest, GetDebugStateFilePaths) {
-  base::ScopedTempDir temp_dir;
-  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
-  // Create files.
-  std::vector<base::FilePath> expected_paths;
-  std::set<base::FilePath> excluded_paths;
-  {
-    // Matches the pattern.
-    base::FilePath path = temp_dir.GetPath().AppendASCII("foo1.pma");
-    base::ScopedFILE file(base::OpenFile(path, "w"));
-    ASSERT_NE(file.get(), nullptr);
-    expected_paths.push_back(path);
-
-    // Matches the pattern, but is excluded.
-    path = temp_dir.GetPath().AppendASCII("foo2.pma");
-    file.reset(base::OpenFile(path, "w"));
-    ASSERT_NE(file.get(), nullptr);
-    ASSERT_TRUE(excluded_paths.insert(path).second);
-
-    // Matches the pattern.
-    path = temp_dir.GetPath().AppendASCII("foo3.pma");
-    file.reset(base::OpenFile(path, "w"));
-    ASSERT_NE(file.get(), nullptr);
-    expected_paths.push_back(path);
-
-    // Does not match the pattern.
-    path = temp_dir.GetPath().AppendASCII("bar.baz");
-    file.reset(base::OpenFile(path, "w"));
-    ASSERT_NE(file.get(), nullptr);
-  }
-
-  PostmortemReportCollector collector(kProductName, kVersionNumber,
-                                      kChannelName, nullptr);
-  EXPECT_THAT(
-      collector.GetDebugStateFilePaths(
-          temp_dir.GetPath(), 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.GetPath().AppendASCII("empty.pma");
+  FilePath file_path = temp_dir.GetPath().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.
+  MockCrashReportDatabase crash_db;
   PostmortemReportCollector collector(kProductName, kVersionNumber,
-                                      kChannelName, nullptr);
+                                      kChannelName, &crash_db, nullptr);
   StabilityReport report;
   ASSERT_EQ(ANALYZER_CREATION_FAILED,
             collector.CollectOneReport(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.GetPath().AppendASCII("invalid_content.pma");
+  FilePath file_path = temp_dir.GetPath().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.
+  MockCrashReportDatabase crash_db;
   PostmortemReportCollector collector(kProductName, kVersionNumber,
-                                      kChannelName, nullptr);
+                                      kChannelName, &crash_db, nullptr);
   StabilityReport report;
   ASSERT_NE(SUCCESS, collector.CollectOneReport(file_path, &report));
 }
 
 namespace {
 
 // Parameters for the activity tracking.
 const size_t kFileSize = 64 << 10;  // 64 KiB
 const int kStackDepth = 6;
 const uint64_t kAllocatorId = 0;
@@ skipping 68 matching lines @@
         PersistentMemoryAllocator::kSizeAny);
     if (mem_base == nullptr)
       return nullptr;
 
     // Make the allocation iterable so it can be found by other processes.
     allocator->MakeIterable(mem_reference);
 
     return WrapUnique(new ThreadActivityTracker(mem_base, tracker_mem_size));
   }
 
-  const base::FilePath& debug_file_path() const { return debug_file_path_; }
+  const FilePath& debug_file_path() const { return debug_file_path_; }
 
  protected:
   base::ScopedTempDir temp_dir_;
-  base::FilePath debug_file_path_;
+  FilePath debug_file_path_;
 
   std::unique_ptr<PersistentMemoryAllocator> allocator_;
   std::unique_ptr<ThreadActivityTracker> tracker_;
 };
 
 TEST_F(PostmortemReportCollectorCollectionTest, CollectSuccess) {
   // Create some activity data.
   tracker_->PushActivity(reinterpret_cast<void*>(kTaskOrigin),
                          base::debug::Activity::ACT_TASK_RUN,
                          ActivityData::ForTask(kTaskSequenceNum));
@@ skipping 15 matching lines @@
 
   // Add some user data.
   ActivityTrackerMemoryAllocator user_data_allocator(
       allocator_.get(), GlobalActivityTracker::kTypeIdUserDataRecord,
       GlobalActivityTracker::kTypeIdUserDataRecordFree, 1024U, 10U, false);
   std::unique_ptr<ActivityUserData> user_data =
       tracker_->GetUserData(activity_id, &user_data_allocator);
   user_data->SetInt("some_int", 42);
 
   // Validate collection returns the expected report.
+  MockCrashReportDatabase crash_db;
   PostmortemReportCollector collector(kProductName, kVersionNumber,
-                                      kChannelName, nullptr);
+                                      kChannelName, &crash_db, nullptr);
   StabilityReport report;
   ASSERT_EQ(SUCCESS, collector.CollectOneReport(debug_file_path(), &report));
 
   // Validate the report.
   ASSERT_EQ(1, report.process_states_size());
   const ProcessState& process_state = report.process_states(0);
   EXPECT_EQ(base::GetCurrentProcId(), process_state.process_id());
   ASSERT_EQ(1, process_state.threads_size());
 
   const ThreadState& thread_state = process_state.threads(0);
@@ skipping 66 matching lines @@
   }
 
   void SetUp() override {
     testing::Test::SetUp();
 
     // Set up a debug file path.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     debug_file_path_ = temp_dir_.GetPath().AppendASCII("debug.pma");
   }
 
-  const base::FilePath& debug_file_path() { return debug_file_path_; }
+  const FilePath& debug_file_path() { return debug_file_path_; }
 
  protected:
   base::ScopedTempDir temp_dir_;
-  base::FilePath debug_file_path_;
+  FilePath debug_file_path_;
 };
 
 TEST_F(PostmortemReportCollectorCollectionFromGlobalTrackerTest,
        LogCollection) {
   // Record some log messages.
   GlobalActivityTracker::CreateWithFile(debug_file_path(), kMemorySize, 0ULL,
                                         "", 3);
   GlobalActivityTracker::Get()->RecordLogMessage("hello world");
   GlobalActivityTracker::Get()->RecordLogMessage("foo bar");
 
   // Collect the stability report.
+  MockCrashReportDatabase crash_db;
   PostmortemReportCollector collector(kProductName, kVersionNumber,
-                                      kChannelName, nullptr);
+                                      kChannelName, &crash_db, nullptr);
   StabilityReport report;
   ASSERT_EQ(SUCCESS, collector.CollectOneReport(debug_file_path(), &report));
 
   // Validate the report's log content.
   ASSERT_EQ(2, report.log_messages_size());
   ASSERT_EQ("hello world", report.log_messages(0));
   ASSERT_EQ("foo bar", report.log_messages(1));
 }
 
 TEST_F(PostmortemReportCollectorCollectionFromGlobalTrackerTest,
@@ skipping 11 matching lines @@
   process_data.Set("raw", "foo", 3);
   process_data.SetString("string", "bar");
   process_data.SetChar("char", '9');
   process_data.SetInt("int", -9999);
   process_data.SetUint("uint", 9999);
   process_data.SetBool("bool", true);
   process_data.SetReference("ref", string1, strlen(string1));
   process_data.SetStringReference("sref", string2);
 
   // Collect the stability report.
+  MockCrashReportDatabase crash_db;
   PostmortemReportCollector collector(kProductName, kVersionNumber,
-                                      kChannelName, nullptr);
+                                      kChannelName, &crash_db, nullptr);
   StabilityReport report;
   ASSERT_EQ(SUCCESS, collector.CollectOneReport(debug_file_path(), &report));
 
   // Validate the report's user data.
   const auto& collected_data = report.global_data();
   ASSERT_EQ(kInternalProcessDatums + 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());
@@ skipping 47 matching lines @@
        FieldTrialCollection) {
   // Record some data.
   GlobalActivityTracker::CreateWithFile(debug_file_path(), kMemorySize, 0ULL,
                                         "", 3);
   ActivityUserData& process_data = GlobalActivityTracker::Get()->process_data();
   process_data.SetString("string", "bar");
   process_data.SetString("FieldTrial.string", "bar");
   process_data.SetString("FieldTrial.foo", "bar");
 
   // Collect the stability report.
+  MockCrashReportDatabase crash_db;
   PostmortemReportCollector collector(kProductName, kVersionNumber,
-                                      kChannelName, nullptr);
+                                      kChannelName, &crash_db, nullptr);
   StabilityReport report;
   ASSERT_EQ(SUCCESS, collector.CollectOneReport(debug_file_path(), &report));
 
   // Validate the report's experiment and global data.
   ASSERT_EQ(2, report.field_trials_size());
   EXPECT_NE(0U, report.field_trials(0).name_id());
   EXPECT_NE(0U, report.field_trials(0).group_id());
   EXPECT_NE(0U, report.field_trials(1).name_id());
   EXPECT_EQ(report.field_trials(0).group_id(),
             report.field_trials(1).group_id());
@@ skipping 19 matching lines @@
   module_info.age = 1;
   crashpad::UUID debug_uuid;
   debug_uuid.InitializeFromString("11223344-5566-7788-abcd-0123456789ab");
   memcpy(module_info.identifier, &debug_uuid, sizeof(module_info.identifier));
   module_info.file = "foo";
   module_info.debug_file = "bar";
 
   GlobalActivityTracker::Get()->RecordModuleInfo(module_info);
 
   // Collect the stability report.
+  MockCrashReportDatabase crash_db;
   PostmortemReportCollector collector(kProductName, kVersionNumber,
-                                      kChannelName, nullptr);
+                                      kChannelName, &crash_db, nullptr);
   StabilityReport report;
   ASSERT_EQ(SUCCESS, collector.CollectOneReport(debug_file_path(), &report));
 
   // Validate the report's modules content.
   ASSERT_EQ(1, report.process_states_size());
   const ProcessState& process_state = report.process_states(0);
   ASSERT_EQ(1, process_state.modules_size());
 
   const CodeModule collected_module = process_state.modules(0);
   EXPECT_EQ(module_info.address,
@@ skipping 16 matching lines @@
                                         "", 3);
   ActivityUserData& process_data = GlobalActivityTracker::Get()->process_data();
   process_data.SetInt(kStabilityStartTimestamp, 12345LL);
 
   // Collect.
   MockSystemSessionAnalyzer analyzer;
   EXPECT_CALL(analyzer,
               IsSessionUnclean(base::Time::FromInternalValue(12345LL)))
       .Times(1)
       .WillOnce(Return(SystemSessionAnalyzer::CLEAN));
+  MockCrashReportDatabase crash_db;
   PostmortemReportCollector collector(kProductName, kVersionNumber,
-                                      kChannelName, &analyzer);
+                                      kChannelName, &crash_db, &analyzer);
   StabilityReport report;
   ASSERT_EQ(SUCCESS, collector.CollectOneReport(debug_file_path(), &report));
 
   // Validate the report.
   ASSERT_EQ(SystemState::CLEAN, report.system_state().session_state());
 }
 
 }  // namespace browser_watcher