Add analyzer support for multiple processes.

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 186 matching lines @@
             snapshot.activity_stack[0].origin_address);
   EXPECT_EQ(11U, snapshot.activity_stack[0].data.task.sequence_id);
 
   tracker->PopActivity(id1);
   ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
   ASSERT_EQ(0U, snapshot.activity_stack_depth);
   ASSERT_EQ(0U, snapshot.activity_stack.size());
 }
 
 TEST_F(ActivityTrackerTest, ScopedTaskTest) {
-  GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3);
+  GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
 
   ThreadActivityTracker* tracker =
       GlobalActivityTracker::Get()->GetOrCreateTrackerForCurrentThread();
   ThreadActivityTracker::Snapshot snapshot;
   ASSERT_EQ(0U, GetGlobalUserDataMemoryCacheUsed());
 
   ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
   ASSERT_EQ(0U, snapshot.activity_stack_depth);
   ASSERT_EQ(0U, snapshot.activity_stack.size());
 
@@ skipping 26 matching lines @@
     EXPECT_EQ(Activity::ACT_TASK, snapshot.activity_stack[0].activity_type);
   }
 
   ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
   ASSERT_EQ(0U, snapshot.activity_stack_depth);
   ASSERT_EQ(0U, snapshot.activity_stack.size());
   ASSERT_EQ(2U, GetGlobalUserDataMemoryCacheUsed());
 }
 
 TEST_F(ActivityTrackerTest, ExceptionTest) {
-  GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3);
+  GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
   GlobalActivityTracker* global = GlobalActivityTracker::Get();
 
   ThreadActivityTracker* tracker =
       GlobalActivityTracker::Get()->GetOrCreateTrackerForCurrentThread();
   ThreadActivityTracker::Snapshot snapshot;
   ASSERT_EQ(0U, GetGlobalUserDataMemoryCacheUsed());
 
   ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
   ASSERT_EQ(0U, snapshot.last_exception.activity_type);
 
@@ skipping 29 matching lines @@
   global = GlobalActivityTracker::Get();
   EXPECT_EQ(std::string("bar"), global->allocator()->Name());
   global->ReleaseTrackerForCurrentThreadForTesting();
   delete global;
 }
 
 
 // GlobalActivityTracker tests below.
 
 TEST_F(ActivityTrackerTest, BasicTest) {
-  GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3);
+  GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
   GlobalActivityTracker* global = GlobalActivityTracker::Get();
 
   // Ensure the data repositories have backing store, indicated by non-zero ID.
   EXPECT_NE(0U, global->process_data().id());
   EXPECT_NE(0U, global->global_data().id());
   EXPECT_NE(global->process_data().id(), global->global_data().id());
 }
 
 class SimpleActivityThread : public SimpleThread {
  public:
@@ skipping 42 matching lines @@
 
   bool ready_ = false;
   bool exit_ = false;
   Lock lock_;
   ConditionVariable exit_condition_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleActivityThread);
 };
 
 TEST_F(ActivityTrackerTest, ThreadDeathTest) {
-  GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3);
+  GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
   GlobalActivityTracker::Get()->GetOrCreateTrackerForCurrentThread();
   const size_t starting_active = GetGlobalActiveTrackerCount();
   const size_t starting_inactive = GetGlobalInactiveTrackerCount();
 
   SimpleActivityThread t1("t1", nullptr, Activity::ACT_TASK,
                           ActivityData::ForTask(11));
   t1.Start();
   t1.WaitReady();
   EXPECT_EQ(starting_active + 1, GetGlobalActiveTrackerCount());
   EXPECT_EQ(starting_inactive, GetGlobalInactiveTrackerCount());
@@ skipping 16 matching lines @@
   t2.Join();
   EXPECT_EQ(starting_active, GetGlobalActiveTrackerCount());
   EXPECT_EQ(starting_inactive + 1, GetGlobalInactiveTrackerCount());
 }
 
 TEST_F(ActivityTrackerTest, ProcessDeathTest) {
   // This doesn't actually create and destroy a process. Instead, it uses for-
   // testing interfaces to simulate data created by other processes.
   const ProcessId other_process_id = GetCurrentProcId() + 1;
 
-  GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3);
+  GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
   GlobalActivityTracker* global = GlobalActivityTracker::Get();
   ThreadActivityTracker* thread = global->GetOrCreateTrackerForCurrentThread();
 
   // Get callbacks for process exit.
   global->SetProcessExitCallback(
       Bind(&ActivityTrackerTest::HandleProcessExit, Unretained(this)));
 
   // Pretend than another process has started.
   global->RecordProcessLaunch(other_process_id, FILE_PATH_LITERAL("foo --bar"));
 
@@ skipping 19 matching lines @@
           user_data.GetBaseAddress(),
           GlobalActivityTracker::kTypeIdUserDataRecord);
   ASSERT_TRUE(user_data_ref);
 
   // Make a copy of the thread-tracker state so it can be restored later.
   const size_t tracker_size = global->allocator()->GetAllocSize(tracker_ref);
   std::unique_ptr<char[]> tracker_copy(new char[tracker_size]);
   memcpy(tracker_copy.get(), thread->GetBaseAddress(), tracker_size);
 
   // Change the objects to appear to be owned by another process.
-  ProcessId owning_id;
+  int64_t owning_id;
   int64_t stamp;
   ASSERT_TRUE(ActivityUserData::GetOwningProcessId(
       global->process_data().GetBaseAddress(), &owning_id, &stamp));
   EXPECT_NE(other_process_id, owning_id);
   ASSERT_TRUE(ThreadActivityTracker::GetOwningProcessId(
       thread->GetBaseAddress(), &owning_id, &stamp));
   EXPECT_NE(other_process_id, owning_id);
   ASSERT_TRUE(ActivityUserData::GetOwningProcessId(user_data.GetBaseAddress(),
                                                    &owning_id, &stamp));
   EXPECT_NE(other_process_id, owning_id);
@@ skipping 38 matching lines @@
   global->allocator()->ChangeType(
       tracker_ref, GlobalActivityTracker::kTypeIdActivityTracker,
       GlobalActivityTracker::kTypeIdActivityTrackerFree, false);
   global->allocator()->ChangeType(
       user_data_ref, GlobalActivityTracker::kTypeIdUserDataRecord,
       GlobalActivityTracker::kTypeIdUserDataRecordFree, false);
 }
 
 }  // namespace debug
 }  // namespace base