Stability file: collect generic activities

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 324 matching lines @@
   PostmortemReportCollector collector(kProductName, kVersionNumber,
                                       kChannelName, nullptr);
   StabilityReport report;
   ASSERT_EQ(DEBUG_FILE_NO_DATA, collector.CollectOneReport(file_path, &report));
 }
 
 namespace {
 
 // Parameters for the activity tracking.
 const size_t kFileSize = 2 * 1024;
-const int kStackDepth = 5;
+const int kStackDepth = 6;
 const uint64_t kAllocatorId = 0;
 const char kAllocatorName[] = "PostmortemReportCollectorCollectionTest";
 const uint64_t kTaskSequenceNum = 42;
 const uintptr_t kTaskOrigin = 1000U;
 const uintptr_t kLockAddress = 1001U;
 const uintptr_t kEventAddress = 1002U;
 const int kThreadId = 43;
 const int kProcessId = 44;
 const int kAnotherThreadId = 45;
+const uint32_t kGenericId = 46U;
+const int32_t kGenericData = 47;
 
 }  // namespace
 
 // Sets up a file backed thread tracker for direct access. A
 // GlobalActivityTracker is not created, meaning there is no risk of
 // the instrumentation interfering with the file's content.
 class PostmortemReportCollectorCollectionTest : public testing::Test {
  public:
   // Create a proper debug file.
   void SetUp() override {
@@ skipping 73 matching lines @@
   tracker_->PushActivity(
       nullptr, base::debug::Activity::ACT_LOCK_ACQUIRE,
       ActivityData::ForLock(reinterpret_cast<void*>(kLockAddress)));
   ThreadActivityTracker::ActivityId activity_id = tracker_->PushActivity(
       nullptr, base::debug::Activity::ACT_EVENT_WAIT,
       ActivityData::ForEvent(reinterpret_cast<void*>(kEventAddress)));
   tracker_->PushActivity(nullptr, base::debug::Activity::ACT_THREAD_JOIN,
                          ActivityData::ForThread(kThreadId));
   tracker_->PushActivity(nullptr, base::debug::Activity::ACT_PROCESS_WAIT,
                          ActivityData::ForProcess(kProcessId));
+  tracker_->PushActivity(nullptr, base::debug::Activity::ACT_GENERIC,
+                         ActivityData::ForGeneric(kGenericId, kGenericData));
   // Note: this exceeds the activity stack's capacity.
   tracker_->PushActivity(nullptr, base::debug::Activity::ACT_THREAD_JOIN,
                          ActivityData::ForThread(kAnotherThreadId));
 
   // 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);
@@ skipping 13 matching lines @@
 
   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());
 #endif
 
-  EXPECT_EQ(6, thread_state.activity_count());
-  ASSERT_EQ(5, thread_state.activities_size());
+  EXPECT_EQ(7, thread_state.activity_count());
+  ASSERT_EQ(6, thread_state.activities_size());
   {
     const Activity& activity = thread_state.activities(0);
     EXPECT_EQ(Activity::ACT_TASK_RUN, activity.type());
     EXPECT_EQ(kTaskOrigin, activity.origin_address());
     EXPECT_EQ(kTaskSequenceNum, activity.task_sequence_id());
     EXPECT_EQ(0U, activity.user_data().size());
   }
   {
     const Activity& activity = thread_state.activities(1);
     EXPECT_EQ(Activity::ACT_LOCK_ACQUIRE, activity.type());
@@ skipping 15 matching lines @@
     EXPECT_EQ(Activity::ACT_THREAD_JOIN, activity.type());
     EXPECT_EQ(kThreadId, activity.thread_id());
     EXPECT_EQ(0U, activity.user_data().size());
   }
   {
     const Activity& activity = thread_state.activities(4);
     EXPECT_EQ(Activity::ACT_PROCESS_WAIT, activity.type());
     EXPECT_EQ(kProcessId, activity.process_id());
     EXPECT_EQ(0U, activity.user_data().size());
   }
+  {
+    const Activity& activity = thread_state.activities(5);
+    EXPECT_EQ(Activity::ACT_GENERIC, activity.type());
+    EXPECT_EQ(kGenericId, activity.generic_id());
+    EXPECT_EQ(kGenericData, activity.generic_data());
+    EXPECT_EQ(0U, activity.user_data().size());
+  }
 }
 
 class PostmortemReportCollectorCollectionFromGlobalTrackerTest
     : public testing::Test {
  public:
   const int kMemorySize = 1 << 20;  // 1MiB
 
   PostmortemReportCollectorCollectionFromGlobalTrackerTest() {}
   ~PostmortemReportCollectorCollectionFromGlobalTrackerTest() override {
     GlobalActivityTracker* global_tracker = GlobalActivityTracker::Get();
@@ skipping 208 matching lines @@
   PostmortemReportCollector collector(kProductName, kVersionNumber,
                                       kChannelName, &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