Separate collection logic from the extraction of the report

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/debug/activity_analyzer.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/process/process_handle.h"
 #include "base/stl_util.h"
 #include "base/threading/platform_thread.h"
+#include "components/browser_watcher/postmortem_report_extractor.h"
 #include "components/browser_watcher/stability_data_names.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #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;
@@ skipping 68 matching lines @@
   MOCK_METHOD1(RequestUpload,
                CrashReportDatabase::OperationStatus(const UUID& uuid));
 };
 
 // Used for testing CollectAndSubmitForUpload.
 class MockPostmortemReportCollector : public PostmortemReportCollector {
  public:
   MockPostmortemReportCollector()
       : PostmortemReportCollector(kProductName, kVersionNumber, kChannelName) {}
 
-  // 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_METHOD2(Collect,
+               CollectionStatus(const base::FilePath&,
+                                StabilityReport* report));
   MOCK_METHOD4(WriteReportToMinidump,
                bool(StabilityReport* report,
                     const crashpad::UUID& client_id,
                     const crashpad::UUID& report_id,
                     base::PlatformFile minidump_file));
 };
 
 // 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
@@ skipping 32 matching lines @@
     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 collection to a proto of a single debug file.
-    // Note: caller takes ownership.
-    StabilityReport* stability_report = new StabilityReport();
-    EXPECT_CALL(collector_, CollectRaw(debug_file_))
+    // Expect a single collection call.
+    EXPECT_CALL(collector_, Collect(debug_file_, _))
         .Times(1)
-        .WillOnce(Return(stability_report));
+        .WillOnce(Return(SUCCESS));
 
     // 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");
     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_,
-                WriteReportToMinidump(stability_report, _, _,
-                                      minidump_file.GetPlatformFile()))
+                WriteReportToMinidump(_, _, _, minidump_file.GetPlatformFile()))
         .Times(1)
         .WillOnce(Return(true));
   }
 
  protected:
   base::ScopedTempDir temp_dir_;
   base::FilePath debug_file_;
   MockCrashReportDatabase database_;
   MockPostmortemReportCollector collector_;
   base::FilePath::StringType debug_file_pattern_;
@@ skipping 81 matching lines @@
   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);
-  std::unique_ptr<StabilityReport> report;
-  ASSERT_EQ(PostmortemReportCollector::ANALYZER_CREATION_FAILED,
-            collector.Collect(file_path, &report));
+  StabilityReport report;
+  ASSERT_EQ(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);
-  std::unique_ptr<StabilityReport> report;
-  ASSERT_EQ(PostmortemReportCollector::DEBUG_FILE_NO_DATA,
-            collector.Collect(file_path, &report));
+  StabilityReport report;
+  ASSERT_EQ(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;
 const uint64_t kAllocatorId = 0;
 const char kAllocatorName[] = "PostmortemReportCollectorCollectionTest";
 const uint64_t kTaskSequenceNum = 42;
@@ skipping 104 matching lines @@
   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);
-  std::unique_ptr<StabilityReport> report;
-  ASSERT_EQ(PostmortemReportCollector::SUCCESS,
-            collector.Collect(debug_file_path(), &report));
-  ASSERT_NE(nullptr, report);
+  StabilityReport report;
+  ASSERT_EQ(SUCCESS, collector.Collect(debug_file_path(), &report));
 
   // Validate the report.
-  ASSERT_EQ(1, report->process_states_size());
-  const ProcessState& process_state = report->process_states(0);
+  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());
 #if defined(OS_WIN)
   EXPECT_EQ(base::PlatformThread::CurrentId(), thread_state.thread_id());
 #elif defined(OS_POSIX)
   EXPECT_EQ(base::PlatformThread::CurrentHandle().platform_handle(),
             thread_state.thread_id());
@@ skipping 71 matching lines @@
        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);
-  std::unique_ptr<StabilityReport> report;
-  ASSERT_EQ(PostmortemReportCollector::SUCCESS,
-            collector.Collect(debug_file_path(), &report));
-  ASSERT_NE(nullptr, report);
+  StabilityReport report;
+  ASSERT_EQ(SUCCESS, collector.Collect(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));
+  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);
-  std::unique_ptr<StabilityReport> report;
-  ASSERT_EQ(PostmortemReportCollector::SUCCESS,
-            collector.Collect(debug_file_path(), &report));
-  ASSERT_NE(nullptr, report);
+  StabilityReport report;
+  ASSERT_EQ(SUCCESS, collector.Collect(debug_file_path(), &report));
 
   // Validate the report's user data.
-  const auto& collected_data = report->global_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());
 
   ASSERT_TRUE(base::ContainsKey(collected_data, "string"));
   EXPECT_EQ(TypedValue::kStringValue, collected_data.at("string").value_case());
   EXPECT_EQ("bar", collected_data.at("string").string_value());
 
@@ skipping 44 matching lines @@
   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);
-  std::unique_ptr<StabilityReport> report;
-  ASSERT_EQ(PostmortemReportCollector::SUCCESS,
-            collector.Collect(debug_file_path(), &report));
-  ASSERT_NE(nullptr, report);
+  StabilityReport report;
+  ASSERT_EQ(SUCCESS, collector.Collect(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());
+  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());
 
   // Expect 5 key/value pairs (including product details).
-  const auto& collected_data = report->global_data();
+  const auto& collected_data = report.global_data();
   EXPECT_EQ(5U, collected_data.size());
   EXPECT_TRUE(base::ContainsKey(collected_data, "string"));
 }
 
 TEST_F(PostmortemReportCollectorCollectionFromGlobalTrackerTest,
        ModuleCollection) {
   // Record some module information.
   GlobalActivityTracker::CreateWithFile(debug_file_path(), kMemorySize, 0ULL,
                                         "", 3);
 
   base::debug::GlobalActivityTracker::ModuleInfo module_info = {};
   module_info.is_loaded = true;
   module_info.address = 0x123456;
   module_info.load_time = 1111LL;
   module_info.size = 0x2d000;
   module_info.timestamp = 0xCAFECAFE;
   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.
   PostmortemReportCollector collector(kProductName, kVersionNumber,
                                       kChannelName);
-  std::unique_ptr<StabilityReport> report;
-  ASSERT_EQ(PostmortemReportCollector::SUCCESS,
-            collector.Collect(debug_file_path(), &report));
-  ASSERT_NE(nullptr, report);
+  StabilityReport report;
+  ASSERT_EQ(SUCCESS, collector.Collect(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, 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());
 }
 
 }  // namespace browser_watcher