Added support for storing arbitrary user data.

base/debug/activity_tracker_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 "base/debug/activity_tracker.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/files/file.h"
@@ skipping 26 matching lines @@
 
  private:
   std::unique_ptr<char[]> mem_segment_;
 };
 
 }  // namespace
 
 
 class ActivityTrackerTest : public testing::Test {
  public:
-  const int kMemorySize = 1 << 10;  // 1MiB
+  const int kMemorySize = 1 << 20;  // 1MiB
   const int kStackSize  = 1 << 10;  // 1KiB
 
+  using ActivityId = ThreadActivityTracker::ActivityId;
+
   ActivityTrackerTest() {}
 
   ~ActivityTrackerTest() override {
     GlobalActivityTracker* global_tracker = GlobalActivityTracker::Get();
     if (global_tracker) {
       global_tracker->ReleaseTrackerForCurrentThreadForTesting();
       delete global_tracker;
     }
   }
 
@@ skipping 11 matching lines @@
   }
 
   size_t GetGlobalInactiveTrackerCount() {
     GlobalActivityTracker* global_tracker = GlobalActivityTracker::Get();
     if (!global_tracker)
       return 0;
     base::AutoLock autolock(global_tracker->thread_tracker_allocator_lock_);
     return global_tracker->thread_tracker_allocator_.cache_used();
   }
 
+  size_t GetGlobalUserDataMemoryCacheUsed() {
+    return GlobalActivityTracker::Get()->user_data_allocator_.cache_used();
+  }
+
   static void DoNothing() {}
 };
 
+TEST_F(ActivityTrackerTest, UserDataTest) {
+  char buffer[256];
+  memset(buffer, 0, sizeof(buffer));
+  ActivityUserData data(buffer, sizeof(buffer));
+  ASSERT_EQ(sizeof(buffer), data.available_);
+
+  data.SetInt("foo", 1);
+  ASSERT_EQ(sizeof(buffer) - 24, data.available_);
+
+  data.SetUint("b", 1U);  // Small names fit beside header in a word.
+  ASSERT_EQ(sizeof(buffer) - 24 - 16, data.available_);
+
+  data.Set("c", buffer, 10);
+  ASSERT_EQ(sizeof(buffer) - 24 - 16 - 24, data.available_);
+
+  data.SetString("dear john", "it's been fun");
+  ASSERT_EQ(sizeof(buffer) - 24 - 16 - 24 - 32, data.available_);
+
+  data.Set("c", buffer, 20);
+  ASSERT_EQ(sizeof(buffer) - 24 - 16 - 24 - 32, data.available_);
+
+  data.SetString("dear john", "but we're done together");
+  ASSERT_EQ(sizeof(buffer) - 24 - 16 - 24 - 32, data.available_);
+
+  data.SetString("dear john", "bye");
+  ASSERT_EQ(sizeof(buffer) - 24 - 16 - 24 - 32, data.available_);
+
+  data.SetChar("d", 'x');
+  ASSERT_EQ(sizeof(buffer) - 24 - 16 - 24 - 32 - 16, data.available_);
+}
+
 TEST_F(ActivityTrackerTest, PushPopTest) {
   std::unique_ptr<ThreadActivityTracker> tracker = CreateActivityTracker();
   ActivitySnapshot snapshot;
 
   ASSERT_TRUE(tracker->Snapshot(&snapshot));
   ASSERT_EQ(0U, snapshot.activity_stack_depth);
   ASSERT_EQ(0U, snapshot.activity_stack.size());
 
   char origin1;
-  tracker->PushActivity(&origin1, Activity::ACT_TASK,
-                        ActivityData::ForTask(11));
+  ActivityId id1 = tracker->PushActivity(&origin1, Activity::ACT_TASK,
+                                         ActivityData::ForTask(11));
   ASSERT_TRUE(tracker->Snapshot(&snapshot));
   ASSERT_EQ(1U, snapshot.activity_stack_depth);
   ASSERT_EQ(1U, snapshot.activity_stack.size());
   EXPECT_NE(0, snapshot.activity_stack[0].time_internal);
   EXPECT_EQ(Activity::ACT_TASK, snapshot.activity_stack[0].activity_type);
   EXPECT_EQ(reinterpret_cast<uintptr_t>(&origin1),
             snapshot.activity_stack[0].origin_address);
   EXPECT_EQ(11U, snapshot.activity_stack[0].data.task.sequence_id);
 
   char origin2;
   char lock2;
-  tracker->PushActivity(&origin2, Activity::ACT_LOCK,
-                        ActivityData::ForLock(&lock2));
+  ActivityId id2 = tracker->PushActivity(&origin2, Activity::ACT_LOCK,
+                                         ActivityData::ForLock(&lock2));
   ASSERT_TRUE(tracker->Snapshot(&snapshot));
   ASSERT_EQ(2U, snapshot.activity_stack_depth);
   ASSERT_EQ(2U, snapshot.activity_stack.size());
   EXPECT_LE(snapshot.activity_stack[0].time_internal,
             snapshot.activity_stack[1].time_internal);
   EXPECT_EQ(Activity::ACT_LOCK, snapshot.activity_stack[1].activity_type);
   EXPECT_EQ(reinterpret_cast<uintptr_t>(&origin2),
             snapshot.activity_stack[1].origin_address);
   EXPECT_EQ(reinterpret_cast<uintptr_t>(&lock2),
             snapshot.activity_stack[1].data.lock.lock_address);
 
-  tracker->PopActivity();
+  tracker->PopActivity(id2);
   ASSERT_TRUE(tracker->Snapshot(&snapshot));
   ASSERT_EQ(1U, snapshot.activity_stack_depth);
   ASSERT_EQ(1U, snapshot.activity_stack.size());
   EXPECT_EQ(Activity::ACT_TASK, snapshot.activity_stack[0].activity_type);
   EXPECT_EQ(reinterpret_cast<uintptr_t>(&origin1),
             snapshot.activity_stack[0].origin_address);
   EXPECT_EQ(11U, snapshot.activity_stack[0].data.task.sequence_id);
 
-  tracker->PopActivity();
+  tracker->PopActivity(id1);
   ASSERT_TRUE(tracker->Snapshot(&snapshot));
   ASSERT_EQ(0U, snapshot.activity_stack_depth);
   ASSERT_EQ(0U, snapshot.activity_stack.size());
 }
 
 TEST_F(ActivityTrackerTest, ScopedTaskTest) {
   GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3);
 
   ThreadActivityTracker* tracker =
       GlobalActivityTracker::Get()->GetOrCreateTrackerForCurrentThread();
   ActivitySnapshot snapshot;
+  ASSERT_EQ(0U, GetGlobalUserDataMemoryCacheUsed());
 
   ASSERT_TRUE(tracker->Snapshot(&snapshot));
   ASSERT_EQ(0U, snapshot.activity_stack_depth);
   ASSERT_EQ(0U, snapshot.activity_stack.size());
 
   {
     PendingTask task1(FROM_HERE, base::Bind(&DoNothing));
     ScopedTaskRunActivity activity1(task1);
+    ActivityUserData& user_data1 = activity1.user_data();
+    (void)user_data1;  // Tell compiler it's been used.
 
     ASSERT_TRUE(tracker->Snapshot(&snapshot));
     ASSERT_EQ(1U, snapshot.activity_stack_depth);
     ASSERT_EQ(1U, snapshot.activity_stack.size());
     EXPECT_EQ(Activity::ACT_TASK, snapshot.activity_stack[0].activity_type);
 
     {
       PendingTask task2(FROM_HERE, base::Bind(&DoNothing));
       ScopedTaskRunActivity activity2(task2);
+      ActivityUserData& user_data2 = activity2.user_data();
+      (void)user_data2;  // Tell compiler it's been used.
 
       ASSERT_TRUE(tracker->Snapshot(&snapshot));
       ASSERT_EQ(2U, snapshot.activity_stack_depth);
       ASSERT_EQ(2U, snapshot.activity_stack.size());
       EXPECT_EQ(Activity::ACT_TASK, snapshot.activity_stack[1].activity_type);
     }
 
     ASSERT_TRUE(tracker->Snapshot(&snapshot));
     ASSERT_EQ(1U, snapshot.activity_stack_depth);
     ASSERT_EQ(1U, snapshot.activity_stack.size());
     EXPECT_EQ(Activity::ACT_TASK, snapshot.activity_stack[0].activity_type);
   }
 
   ASSERT_TRUE(tracker->Snapshot(&snapshot));
   ASSERT_EQ(0U, snapshot.activity_stack_depth);
   ASSERT_EQ(0U, snapshot.activity_stack.size());
+  ASSERT_EQ(2U, GetGlobalUserDataMemoryCacheUsed());
 }
 
 TEST_F(ActivityTrackerTest, CreateWithFileTest) {
   const char temp_name[] = "CreateWithFileTest";
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   FilePath temp_file = temp_dir.GetPath().AppendASCII(temp_name);
   const size_t temp_size = 64 << 10;  // 64 KiB
 
   // Create a global tracker on a new file.
@@ skipping 25 matching lines @@
                        const ActivityData& data)
       : SimpleThread(name, Options()),
         origin_(origin),
         activity_(activity),
         data_(data),
         exit_condition_(&lock_) {}
 
   ~SimpleActivityThread() override {}
 
   void Run() override {
-    GlobalActivityTracker::Get()
-        ->GetOrCreateTrackerForCurrentThread()
-        ->PushActivity(origin_, activity_, data_);
+    ThreadActivityTracker::ActivityId id =
+        GlobalActivityTracker::Get()
+            ->GetOrCreateTrackerForCurrentThread()
+            ->PushActivity(origin_, activity_, data_);
 
     {
       AutoLock auto_lock(lock_);
       ready_ = true;
       while (!exit_)
         exit_condition_.Wait();
     }
 
-    GlobalActivityTracker::Get()
-        ->GetOrCreateTrackerForCurrentThread()
-        ->PopActivity();
+    GlobalActivityTracker::Get()->GetTrackerForCurrentThread()->PopActivity(id);
   }
 
   void Exit() {
     AutoLock auto_lock(lock_);
     exit_ = true;
     exit_condition_.Signal();
   }
 
   void WaitReady() {
     SPIN_FOR_1_SECOND_OR_UNTIL_TRUE(ready_);
@@ skipping 40 matching lines @@
   EXPECT_EQ(starting_inactive, GetGlobalInactiveTrackerCount());
 
   t2.Exit();
   t2.Join();
   EXPECT_EQ(starting_active, GetGlobalActiveTrackerCount());
   EXPECT_EQ(starting_inactive + 1, GetGlobalInactiveTrackerCount());
 }
 
 }  // namespace debug
 }  // namespace base