Bound the impact of system instability on chrome instability.

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 89 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 CollectAndSubmitForUpload.
+// Used for testing CollectAndSubmitAllPendingReports.
 class MockPostmortemReportCollector : public PostmortemReportCollector {
  public:
   MockPostmortemReportCollector()
-      : PostmortemReportCollector(kProductName, kVersionNumber, kChannelName) {}
+      : PostmortemReportCollector(kProductName,
+                                  kVersionNumber,
+                                  kChannelName,
+                                  nullptr) {}
 
   // 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 {
+  CollectionStatus CollectOneReport(
+      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_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(StabilityReport* report,
                     const crashpad::UUID& client_id,
                     const crashpad::UUID& report_id,
                     base::PlatformFile minidump_file));
 };
 
+class MockSystemSessionAnalyzer : public SystemSessionAnalyzer {
+ public:
+  MockSystemSessionAnalyzer() : SystemSessionAnalyzer(10U) {}
+  MOCK_METHOD1(IsSessionUnclean, Status(base::Time timestamp));
+};
+
 // Checks if two proto messages are the same based on their serializations. Note
 // this only works if serialization is deterministic, which is not guaranteed.
 // In practice, serialization is deterministic (even for protocol buffers with
 // maps) and such matchers are common in the Chromium code base. Also note that
 // in the context of this test, false positive matches are the problem and these
 // are not possible (otherwise serialization would be ambiguous). False
 // negatives would lead to test failure and developer action. Alternatives are:
 // 1) a generic matcher (likely not possible without reflections, missing from
 // lite runtime),  2) a specialized matcher or 3) implementing deterministic
 // 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;
 }
 
 }  // namespace
 
-class PostmortemReportCollectorCollectAndSubmitTest : public testing::Test {
+class PostmortemReportCollectorCollectAndSubmitAllPendingReportsTest
+    : public testing::Test {
  public:
   void SetUp() override {
     testing::Test::SetUp();
     // 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);
     }
@@ skipping 42 matching lines @@
  protected:
   base::ScopedTempDir temp_dir_;
   base::FilePath debug_file_;
   MockCrashReportDatabase database_;
   MockPostmortemReportCollector collector_;
   base::FilePath::StringType debug_file_pattern_;
   std::set<base::FilePath> no_excluded_files_;
   CrashReportDatabase::NewReport crashpad_report_;
 };
 
-TEST_F(PostmortemReportCollectorCollectAndSubmitTest,
-       CollectAndSubmitForUpload) {
+TEST_F(PostmortemReportCollectorCollectAndSubmitAllPendingReportsTest,
+       CollectAndSubmitAllPendingReports) {
   EXPECT_CALL(database_, FinishedWritingCrashReport(&crashpad_report_, _))
       .Times(1)
       .WillOnce(Return(CrashReportDatabase::kNoError));
 
   // Run the test.
-  int success_cnt = collector_.CollectAndSubmitForUpload(
+  int success_cnt = collector_.CollectAndSubmitAllPendingReports(
       debug_file_.DirName(), debug_file_pattern_, no_excluded_files_,
       &database_);
   ASSERT_EQ(1, success_cnt);
   ASSERT_FALSE(base::PathExists(debug_file_));
 }
 
-TEST_F(PostmortemReportCollectorCollectAndSubmitTest,
-       CollectAndSubmitForUploadStuckFile) {
+TEST_F(PostmortemReportCollectorCollectAndSubmitAllPendingReportsTest,
+       CollectAndSubmitAllPendingReportsStuckFile) {
   // 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_.CollectAndSubmitForUpload(
+  int success_cnt = collector_.CollectAndSubmitAllPendingReports(
       debug_file_.DirName(), debug_file_pattern_, no_excluded_files_,
       &database_);
   ASSERT_EQ(0, success_cnt);
   ASSERT_TRUE(base::PathExists(debug_file_));
 }
 
 TEST(PostmortemReportCollectorTest, GetDebugStateFilePaths) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
@@ skipping 19 matching lines @@
     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);
+                                      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");
   {
     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(kProductName, kVersionNumber,
-                                      kChannelName);
+                                      kChannelName, nullptr);
   std::unique_ptr<StabilityReport> report;
   ASSERT_EQ(PostmortemReportCollector::ANALYZER_CREATION_FAILED,
-            collector.Collect(file_path, &report));
+            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");
   {
     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(kProductName, kVersionNumber,
-                                      kChannelName);
+                                      kChannelName, nullptr);
   std::unique_ptr<StabilityReport> report;
   ASSERT_EQ(PostmortemReportCollector::DEBUG_FILE_NO_DATA,
-            collector.Collect(file_path, &report));
+            collector.CollectOneReport(file_path, &report));
 }
 
 namespace {
 
 // Parameters for the activity tracking.
 const size_t kFileSize = 2 * 1024;
 const int kStackDepth = 5;
 const uint64_t kAllocatorId = 0;
 const char kAllocatorName[] = "PostmortemReportCollectorCollectionTest";
 const uint64_t kTaskSequenceNum = 42;
@@ skipping 103 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.
   PostmortemReportCollector collector(kProductName, kVersionNumber,
-                                      kChannelName);
+                                      kChannelName, nullptr);
   std::unique_ptr<StabilityReport> report;
   ASSERT_EQ(PostmortemReportCollector::SUCCESS,
-            collector.Collect(debug_file_path(), &report));
+            collector.CollectOneReport(debug_file_path(), &report));
   ASSERT_NE(nullptr, 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);
   EXPECT_EQ(base::PlatformThread::GetName(), thread_state.thread_name());
@@ skipping 75 matching lines @@
 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.
   PostmortemReportCollector collector(kProductName, kVersionNumber,
-                                      kChannelName);
+                                      kChannelName, nullptr);
   std::unique_ptr<StabilityReport> report;
   ASSERT_EQ(PostmortemReportCollector::SUCCESS,
-            collector.Collect(debug_file_path(), &report));
+            collector.CollectOneReport(debug_file_path(), &report));
   ASSERT_NE(nullptr, 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,
        GlobalUserDataCollection) {
   const char string1[] = "foo";
   const char string2[] = "bar";
 
   // Record some global user data.
   GlobalActivityTracker::CreateWithFile(debug_file_path(), kMemorySize, 0ULL,
                                         "", 3);
   ActivityUserData& global_data = GlobalActivityTracker::Get()->global_data();
   global_data.Set("raw", "foo", 3);
   global_data.SetString("string", "bar");
   global_data.SetChar("char", '9');
   global_data.SetInt("int", -9999);
   global_data.SetUint("uint", 9999);
   global_data.SetBool("bool", true);
   global_data.SetReference("ref", string1, strlen(string1));
   global_data.SetStringReference("sref", string2);
 
   // Collect the stability report.
   PostmortemReportCollector collector(kProductName, kVersionNumber,
-                                      kChannelName);
+                                      kChannelName, nullptr);
   std::unique_ptr<StabilityReport> report;
   ASSERT_EQ(PostmortemReportCollector::SUCCESS,
-            collector.Collect(debug_file_path(), &report));
+            collector.CollectOneReport(debug_file_path(), &report));
   ASSERT_NE(nullptr, report);
 
   // Validate the report's user data.
   const auto& collected_data = report->global_data();
   ASSERT_EQ(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 @@
   // Record some data.
   GlobalActivityTracker::CreateWithFile(debug_file_path(), kMemorySize, 0ULL,
                                         "", 3);
   ActivityUserData& global_data = GlobalActivityTracker::Get()->global_data();
   global_data.SetString("string", "bar");
   global_data.SetString("FieldTrial.string", "bar");
   global_data.SetString("FieldTrial.foo", "bar");
 
   // Collect the stability report.
   PostmortemReportCollector collector(kProductName, kVersionNumber,
-                                      kChannelName);
+                                      kChannelName, nullptr);
   std::unique_ptr<StabilityReport> report;
   ASSERT_EQ(PostmortemReportCollector::SUCCESS,
-            collector.Collect(debug_file_path(), &report));
+            collector.CollectOneReport(debug_file_path(), &report));
   ASSERT_NE(nullptr, 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 @@
   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.
   PostmortemReportCollector collector(kProductName, kVersionNumber,
-                                      kChannelName);
+                                      kChannelName, nullptr);
   std::unique_ptr<StabilityReport> report;
   ASSERT_EQ(PostmortemReportCollector::SUCCESS,
-            collector.Collect(debug_file_path(), &report));
+            collector.CollectOneReport(debug_file_path(), &report));
   ASSERT_NE(nullptr, 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,
             static_cast<uintptr_t>(collected_module.base_address()));
   EXPECT_EQ(module_info.size, static_cast<size_t>(collected_module.size()));
   EXPECT_EQ(module_info.file, collected_module.code_file());
   EXPECT_EQ("CAFECAFE2d000", collected_module.code_identifier());
   EXPECT_EQ(module_info.debug_file, collected_module.debug_file());
   EXPECT_EQ("1122334455667788ABCD0123456789AB1",
             collected_module.debug_identifier());
   EXPECT_EQ("", collected_module.version());
   EXPECT_EQ(0LL, collected_module.shrink_down_delta());
   EXPECT_EQ(!module_info.is_loaded, collected_module.is_unloaded());
 }
 
+TEST_F(PostmortemReportCollectorCollectionFromGlobalTrackerTest,
+       SystemStateTest) {
+  // Setup.
+  GlobalActivityTracker::CreateWithFile(debug_file_path(), kMemorySize, 0ULL,
+                                        "", 3);
+  ActivityUserData& global_data = GlobalActivityTracker::Get()->global_data();
+  global_data.SetInt(kStabilityStartTimestamp, 12345LL);
+
+  // Collect.
+  MockSystemSessionAnalyzer analyzer;
+  EXPECT_CALL(analyzer,
+              IsSessionUnclean(base::Time::FromInternalValue(12345LL)))
+      .Times(1)
+      .WillOnce(Return(SystemSessionAnalyzer::CLEAN));
+  PostmortemReportCollector collector(kProductName, kVersionNumber,
+                                      kChannelName, &analyzer);
+  std::unique_ptr<StabilityReport> report;
+  ASSERT_EQ(PostmortemReportCollector::SUCCESS,
+            collector.CollectOneReport(debug_file_path(), &report));
+  ASSERT_NE(nullptr, report);
+
+  // Validate the report.
+  ASSERT_EQ(SystemState::CLEAN, report->system_state().session_state());
+}
+
 }  // namespace browser_watcher