Add analyzer support for multiple processes.

base/debug/activity_analyzer_unittest.cc

Index: base/debug/activity_analyzer_unittest.cc
diff --git a/base/debug/activity_analyzer_unittest.cc b/base/debug/activity_analyzer_unittest.cc
index ee614eaeb9a12d83864e25961cc37db108085629..10b70aa989656ec886665325d282a46ecedee006 100644
--- a/base/debug/activity_analyzer_unittest.cc
+++ b/base/debug/activity_analyzer_unittest.cc
@@ -139,18 +139,22 @@ class SimpleActivityThread : public SimpleThread {
 
 TEST_F(ActivityAnalyzerTest, GlobalAnalyzerConstruction) {
   GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3);
+  GlobalActivityTracker::Get()->process_data().SetString("foo", "bar");
 
   PersistentMemoryAllocator* allocator =
       GlobalActivityTracker::Get()->allocator();
   GlobalActivityAnalyzer analyzer(MakeUnique<PersistentMemoryAllocator>(
       const_cast<void*>(allocator->data()), allocator->size(), 0, 0, "", true));
 
-  // The only thread at thois point is the test thread.
-  ThreadActivityAnalyzer* ta1 = analyzer.GetFirstAnalyzer();
+  // The only thread at this point is the test thread of this process.
+  const int64_t pid = analyzer.GetFirstProcess();
+  ASSERT_NE(0, pid);
+  ThreadActivityAnalyzer* ta1 = analyzer.GetFirstAnalyzer(pid);
   ASSERT_TRUE(ta1);
-  EXPECT_FALSE(analyzer.GetNextAnalyzer());
+  EXPECT_FALSE(analyzer.GetNextAnalyzer(pid));
   ThreadActivityAnalyzer::ThreadKey tk1 = ta1->GetThreadKey();
   EXPECT_EQ(ta1, analyzer.GetAnalyzerForThread(tk1));
+  EXPECT_EQ(0, analyzer.GetNextProcess());
 
   // Create a second thread that will do something.
   SimpleActivityThread t2("t2", nullptr, Activity::ACT_TASK,
@@ -158,28 +162,38 @@ TEST_F(ActivityAnalyzerTest, GlobalAnalyzerConstruction) {
   t2.Start();
   t2.WaitReady();
 
-  // Now there should be two.
-  EXPECT_TRUE(analyzer.GetFirstAnalyzer());
-  EXPECT_TRUE(analyzer.GetNextAnalyzer());
-  EXPECT_FALSE(analyzer.GetNextAnalyzer());
+  // Now there should be two. Calling GetFirstProcess invalidates any
+  // previously returned analyzer pointers.
+  ASSERT_EQ(pid, analyzer.GetFirstProcess());
+  EXPECT_TRUE(analyzer.GetFirstAnalyzer(pid));
+  EXPECT_TRUE(analyzer.GetNextAnalyzer(pid));
+  EXPECT_FALSE(analyzer.GetNextAnalyzer(pid));
+  EXPECT_EQ(0, analyzer.GetNextProcess());
 
   // Let thread exit.
   t2.Exit();
   t2.Join();
 
-  // Now there should be only one again. Calling GetFirstAnalyzer invalidates
-  // any previously returned analyzer pointers.
-  ThreadActivityAnalyzer* ta2 = analyzer.GetFirstAnalyzer();
+  // Now there should be only one again.
+  ASSERT_EQ(pid, analyzer.GetFirstProcess());
+  ThreadActivityAnalyzer* ta2 = analyzer.GetFirstAnalyzer(pid);
   ASSERT_TRUE(ta2);
-  EXPECT_FALSE(analyzer.GetNextAnalyzer());
+  EXPECT_FALSE(analyzer.GetNextAnalyzer(pid));
   ThreadActivityAnalyzer::ThreadKey tk2 = ta2->GetThreadKey();
   EXPECT_EQ(ta2, analyzer.GetAnalyzerForThread(tk2));
   EXPECT_EQ(tk1, tk2);
+  EXPECT_EQ(0, analyzer.GetNextProcess());
+
+  // Verify that there is process data.
+  const ActivityUserData::Snapshot& data_snapshot =
+      analyzer.GetProcessDataSnapshot(pid);
+  ASSERT_LE(1U, data_snapshot.size());
+  EXPECT_EQ("bar", data_snapshot.at("foo").GetString());
 }
 
 TEST_F(ActivityAnalyzerTest, UserDataSnapshotTest) {
   GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3);
-  ThreadActivityAnalyzer::Snapshot snapshot;
+  ThreadActivityAnalyzer::Snapshot tracker_snapshot;
 
   const char string1a[] = "string1a";
   const char string1b[] = "string1b";
@@ -218,16 +232,16 @@ TEST_F(ActivityAnalyzerTest, UserDataSnapshotTest) {
       user_data2.SetReference("ref2", string2a, sizeof(string2a));
       user_data2.SetStringReference("sref2", string2b);
 
-      ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
-      ASSERT_EQ(2U, snapshot.activity_stack.size());
+      ASSERT_TRUE(tracker->CreateSnapshot(&tracker_snapshot));
+      ASSERT_EQ(2U, tracker_snapshot.activity_stack.size());
 
       ThreadActivityAnalyzer analyzer(*tracker);
       analyzer.AddGlobalInformation(&global_analyzer);
-      const ThreadActivityAnalyzer::Snapshot& snapshot =
+      const ThreadActivityAnalyzer::Snapshot& analyzer_snapshot =
           analyzer.activity_snapshot();
-      ASSERT_EQ(2U, snapshot.user_data_stack.size());
+      ASSERT_EQ(2U, analyzer_snapshot.user_data_stack.size());
       const ActivityUserData::Snapshot& user_data =
-          snapshot.user_data_stack.at(1);
+          analyzer_snapshot.user_data_stack.at(1);
       EXPECT_EQ(8U, user_data.size());
       ASSERT_TRUE(ContainsKey(user_data, "raw2"));
       EXPECT_EQ("foo2", user_data.at("raw2").Get().as_string());
@@ -250,16 +264,16 @@ TEST_F(ActivityAnalyzerTest, UserDataSnapshotTest) {
                 user_data.at("sref2").GetStringReference().size());
     }
 
-    ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
-    ASSERT_EQ(1U, snapshot.activity_stack.size());
+    ASSERT_TRUE(tracker->CreateSnapshot(&tracker_snapshot));
+    ASSERT_EQ(1U, tracker_snapshot.activity_stack.size());
 
     ThreadActivityAnalyzer analyzer(*tracker);
     analyzer.AddGlobalInformation(&global_analyzer);
-    const ThreadActivityAnalyzer::Snapshot& snapshot =
+    const ThreadActivityAnalyzer::Snapshot& analyzer_snapshot =
         analyzer.activity_snapshot();
-    ASSERT_EQ(1U, snapshot.user_data_stack.size());
+    ASSERT_EQ(1U, analyzer_snapshot.user_data_stack.size());
     const ActivityUserData::Snapshot& user_data =
-        snapshot.user_data_stack.at(0);
+        analyzer_snapshot.user_data_stack.at(0);
     EXPECT_EQ(8U, user_data.size());
     EXPECT_EQ("foo1", user_data.at("raw1").Get().as_string());
     EXPECT_EQ("bar1", user_data.at("string1").GetString().as_string());
@@ -274,8 +288,8 @@ TEST_F(ActivityAnalyzerTest, UserDataSnapshotTest) {
               user_data.at("sref1").GetStringReference().size());
   }
 
-  ASSERT_TRUE(tracker->CreateSnapshot(&snapshot));
-  ASSERT_EQ(0U, snapshot.activity_stack.size());
+  ASSERT_TRUE(tracker->CreateSnapshot(&tracker_snapshot));
+  ASSERT_EQ(0U, tracker_snapshot.activity_stack.size());
 }
 
 TEST_F(ActivityAnalyzerTest, GlobalUserDataTest) {
@@ -299,8 +313,8 @@ TEST_F(ActivityAnalyzerTest, GlobalUserDataTest) {
   global_data.SetReference("ref", string1, sizeof(string1));
   global_data.SetStringReference("sref", string2);
 
-  ActivityUserData::Snapshot snapshot =
-      global_analyzer.GetGlobalUserDataSnapshot();
+  const ActivityUserData::Snapshot& snapshot =
+      global_analyzer.GetGlobalDataSnapshot();
   ASSERT_TRUE(ContainsKey(snapshot, "raw"));
   EXPECT_EQ("foo", snapshot.at("raw").Get().as_string());
   ASSERT_TRUE(ContainsKey(snapshot, "string"));