Collect an initial set of stability 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>
 #include <string>
 #include <utility>
 #include <vector>
 
 #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/threading/platform_thread.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::Activity;
 using base::debug::ActivityData;
 using base::debug::GlobalActivityTracker;
 using base::debug::ThreadActivityTracker;
 using base::File;
 using base::FilePersistentMemoryAllocator;
 using base::MemoryMappedFile;
 using base::PersistentMemoryAllocator;
 using base::WrapUnique;
 using crashpad::CrashReportDatabase;
 using crashpad::Settings;
@@ skipping 277 matching lines @@
                                       kChannelName);
   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 = 4;
+const int kStackDepth = 5;
 const uint64_t kAllocatorId = 0;
 const char kAllocatorName[] = "PostmortemReportCollectorCollectionTest";
+const int 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;
 
 }  // namespace
 
 class PostmortemReportCollectorCollectionTest : public testing::Test {
  public:
   // Create a proper debug file.
   void SetUp() override {
     testing::Test::SetUp();
 
     // Create a file backed allocator.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     debug_file_path_ = temp_dir_.GetPath().AppendASCII("debug_file.pma");
     std::unique_ptr<PersistentMemoryAllocator> allocator = CreateAllocator();
     ASSERT_NE(nullptr, allocator);
 
     size_t tracker_mem_size =
         ThreadActivityTracker::SizeForStackDepth(kStackDepth);
     ASSERT_GT(kFileSize, tracker_mem_size);
 
     // Create some debug data using trackers.
     std::unique_ptr<ThreadActivityTracker> tracker =
         CreateTracker(allocator.get(), tracker_mem_size);
     ASSERT_NE(nullptr, tracker);
     ASSERT_TRUE(tracker->IsValid());
 
-    const void* dummy_task_origin = reinterpret_cast<void*>(0xCAFE);
-    const int dummy_task_sequence_num = 42;
-    tracker->PushActivity(dummy_task_origin, Activity::ACT_TASK_RUN,
-                          ActivityData::ForTask(dummy_task_sequence_num));
-
-    // TODO(manzagop): flesh out the data (more trackers and content).
+    tracker->PushActivity(reinterpret_cast<void*>(kTaskOrigin),

[bcwhite, 2016/11/02 16:52:37]

This is far away from where it's tested.  How about moving it down into that
method?

Also, you'd be better off using the ScopedFoo objects if you can since they
should be constant interfaces while FooActivity methods are subject to change as
the implementation evolves.

[manzagop (departed), 2016/11/02 20:15:23]

Done.
I'm leaning towards keeping as is if you're ok with it. Using the scoped
versions would require creating a GlobalActivityTracker and then setting up
actual tasks / locks.

[bcwhite, 2016/11/03 17:56:25]

Acknowledged.

+                          base::debug::Activity::ACT_TASK_RUN,
+                          ActivityData::ForTask(kTaskSequenceNum));
+    tracker->PushActivity(
+        nullptr, base::debug::Activity::ACT_LOCK_ACQUIRE,
+        ActivityData::ForLock(reinterpret_cast<void*>(kLockAddress)));
+    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));
+    // Note: this exceeds the stack's capacity.
+    tracker->PushActivity(nullptr, base::debug::Activity::ACT_THREAD_JOIN,
+                          ActivityData::ForThread(kAnotherThreadId));
   }
 
   std::unique_ptr<PersistentMemoryAllocator> CreateAllocator() {
     // Create the memory mapped file.
     std::unique_ptr<MemoryMappedFile> mmfile(new MemoryMappedFile());
     bool success = mmfile->Initialize(
         File(debug_file_path_, File::FLAG_CREATE | File::FLAG_READ |
                                    File::FLAG_WRITE | File::FLAG_SHARE_DELETE),
         {0, static_cast<int64_t>(kFileSize)},
         MemoryMappedFile::READ_WRITE_EXTEND);
@@ skipping 37 matching lines @@
 
 TEST_F(PostmortemReportCollectorCollectionTest, CollectSuccess) {
   // 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);
 
-  // Build the expected report.
-  StabilityReport expected_report;
-  ProcessState* process_state = expected_report.add_process_states();
-  ThreadState* thread_state = process_state->add_threads();
-  thread_state->set_thread_name(base::PlatformThread::GetName());
+  // 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());
 
-  ASSERT_EQ(expected_report.SerializeAsString(), report->SerializeAsString());
+  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_cnt());
+  ASSERT_EQ(5, 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());
+  }
+  {
+    const Activity& activity = thread_state.activities(1);
+    EXPECT_EQ(Activity::ACT_LOCK_ACQUIRE, activity.type());
+    EXPECT_EQ(kLockAddress, activity.lock_address());
+  }
+  {
+    const Activity& activity = thread_state.activities(2);
+    EXPECT_EQ(Activity::ACT_EVENT_WAIT, activity.type());
+    EXPECT_EQ(kEventAddress, activity.event_address());
+  }
+  {
+    const Activity& activity = thread_state.activities(3);
+    EXPECT_EQ(Activity::ACT_THREAD_JOIN, activity.type());
+    EXPECT_EQ(kThreadId, activity.thread_id());
+  }
+  {
+    const Activity& activity = thread_state.activities(4);
+    EXPECT_EQ(Activity::ACT_PROCESS_WAIT, activity.type());
+    EXPECT_EQ(kProcessId, activity.process_id());
+  }
 }
 
 }  // namespace browser_watcher