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 93 matching lines @@
   MOCK_METHOD1(DeleteReport,
                CrashReportDatabase::OperationStatus(const UUID& uuid));
   MOCK_METHOD1(RequestUpload,
                CrashReportDatabase::OperationStatus(const UUID& uuid));
 };
 
 // Used for testing CollectAndSubmitForUpload.
 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 {
     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(nullptr) {}
+  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.
@@ skipping 130 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));
 }
 
 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));
 }
 
 namespace {
 
 // Parameters for the activity tracking.
 const size_t kFileSize = 2 * 1024;
 const int kStackDepth = 5;
@@ skipping 106 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));
   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());
@@ skipping 78 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));
   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));
 }
@@ skipping 11 matching lines @@
   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));
   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"));
@@ skipping 50 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));
   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());
@@ skipping 22 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));
   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.
+  std::unique_ptr<MockSystemSessionAnalyzer> analyzer(
+      new MockSystemSessionAnalyzer());
+  EXPECT_CALL(*analyzer,
+              IsSessionUnclean(base::Time::FromInternalValue(12345LL)))
+      .Times(1)
+      .WillOnce(Return(SystemSessionAnalyzer::CLEAN));
+  PostmortemReportCollector collector(kProductName, kVersionNumber,
+                                      kChannelName, std::move(analyzer));
+  std::unique_ptr<StabilityReport> report;
+  ASSERT_EQ(PostmortemReportCollector::SUCCESS,
+            collector.Collect(debug_file_path(), &report));
+  ASSERT_NE(nullptr, report);
+
+  // Validate the report.
+  ASSERT_EQ(SystemState::CLEAN, report->system_state().session_state());
+}
+
 }  // namespace browser_watcher