[UMA] Use proper C++ objects to serialize tracked_objects across process boundaries.

base/tracked_objects_unittest.cc

 // Copyright (c) 2012 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.
 
 // Test of classes in the tracked_objects.h classes.
 
 #include "base/tracked_objects.h"
 
-#include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/process_util.h"
 #include "base/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+const int kLineNumber = 1776;
+const char kFile[] = "FixedUnitTestFileName";
+const char kFunction[] = "CatchEmAll";
+const char kWorkerThreadName[] = "WorkerThread-1";
+const char kMainThreadName[] = "SomeMainThreadName";
+const char kStillAlive[] = "Still_Alive";

[jar (doing other things), 2012/04/10 15:09:36]

The standardizing on the names, and line numbers tends to weaken these tests  a
bit.  This code all tends to deal with centralized data, and the fear is that
some data will be pushed into the database, and not be reset in a later test. 
When you have the same file name, function name, etc., you can't catch that
class of error.  Note for instance that we use atoms to record birth locations,
and this change would tend to cause us to reuse a single atom (or not realize we
had failed to update a pointer to a new atom).

Although it is slightly painful to list new values in each test, I think it adds
to the coverage.

[Ilya Sherman, 2012/04/10 20:34:41]

Does the DifferentLives test not give us the desired coverage?  As I understand,
unit tests should be written to be independent -- there's no guarantee that
they'll be run in any particular sequence or that all of them will be run
together.  So, if we're missing coverage, we should probably add new tests
providing this coverage.  But... I think we are already explicitly testing this.
 Am I misunderstanding your comment?

+
 namespace tracked_objects {
 
 class TrackedObjectsTest : public testing::Test {
  protected:
   TrackedObjectsTest() {
     // On entry, leak any database structures in case they are still in use by
     // prior threads.
     ThreadData::ShutdownSingleThreadedCleanup(true);
   }
 
   virtual ~TrackedObjectsTest() {
     // We should not need to leak any structures we create, since we are
     // single threaded, and carefully accounting for items.
     ThreadData::ShutdownSingleThreadedCleanup(false);
   }
 
-  // Provide access, since this class is a friend of ThreadData.
-  void ShutdownSingleThreadedCleanup(bool leak) {
-    ThreadData::ShutdownSingleThreadedCleanup(leak);
+  // Reset the profiler state.
+  void Reset() {
+    ThreadData::ShutdownSingleThreadedCleanup(false);
+  }
+
+  // Simulate a birth on the thread named |thread_name|, at the given
+  // |location|.
+  void TallyABirth(const Location& location, const std::string& thread_name) {

[jar (doing other things), 2012/04/10 15:09:36]

This was a nice refactor to create these two helper functions.

+    // If the |thread_name| is empty, we don't initialize system with a thread
+    // name, so we're viewed as a worker thread.
+    if (!thread_name.empty())
+      ThreadData::InitializeThreadContext(kMainThreadName);
+
+    // Do not delete |birth|.  We don't own it.
+    Births* birth = ThreadData::TallyABirthIfActive(location);
+
+    if (ThreadData::status() == ThreadData::DEACTIVATED)
+      EXPECT_EQ(reinterpret_cast<Births*>(NULL), birth);
+    else
+      EXPECT_NE(reinterpret_cast<Births*>(NULL), birth);
+  }
+
+  // Helper function to verify the most common test expectations.
+  void ExpectSimpleProcessData(const ProcessDataSnapshot& process_data,
+                               const std::string& birth_thread,
+                               const std::string& death_thread,
+                               int count,
+                               int run_ms,
+                               int queue_ms) {
+    ASSERT_EQ(1u, process_data.tasks.size());
+
+    EXPECT_EQ(kFile, process_data.tasks[0].birth.location.file_name);
+    EXPECT_EQ(kFunction, process_data.tasks[0].birth.location.function_name);
+    EXPECT_EQ(kLineNumber, process_data.tasks[0].birth.location.line_number);
+
+    EXPECT_EQ(birth_thread, process_data.tasks[0].birth.thread_name);
+
+    EXPECT_EQ(count, process_data.tasks[0].death_data.count);
+    EXPECT_EQ(count * run_ms,
+              process_data.tasks[0].death_data.run_duration_sum);
+    EXPECT_EQ(run_ms, process_data.tasks[0].death_data.run_duration_max);
+    EXPECT_EQ(run_ms, process_data.tasks[0].death_data.run_duration_sample);
+    EXPECT_EQ(count * queue_ms,
+              process_data.tasks[0].death_data.queue_duration_sum);
+    EXPECT_EQ(queue_ms, process_data.tasks[0].death_data.queue_duration_max);
+    EXPECT_EQ(queue_ms, process_data.tasks[0].death_data.queue_duration_sample);
+
+    EXPECT_EQ(death_thread, process_data.tasks[0].death_thread_name);
+
+    EXPECT_EQ(0u, process_data.descendants.size());
+
+    EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
   }
 };
 
 TEST_F(TrackedObjectsTest, MinimalStartupShutdown) {
   // Minimal test doesn't even create any tasks.
   if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+          ThreadData::PROFILING_CHILDREN_ACTIVE))
     return;
 
   EXPECT_FALSE(ThreadData::first());  // No activity even on this thread.
   ThreadData* data = ThreadData::Get();
   EXPECT_TRUE(ThreadData::first());  // Now class was constructed.
-  EXPECT_TRUE(data);
-  EXPECT_TRUE(!data->next());
+  ASSERT_TRUE(data);
+  EXPECT_FALSE(data->next());
   EXPECT_EQ(data, ThreadData::Get());
   ThreadData::BirthMap birth_map;
   ThreadData::DeathMap death_map;
   ThreadData::ParentChildSet parent_child_set;
   data->SnapshotMaps(false, &birth_map, &death_map, &parent_child_set);
   EXPECT_EQ(0u, birth_map.size());
   EXPECT_EQ(0u, death_map.size());
   EXPECT_EQ(0u, parent_child_set.size());
-  // Cleanup with no leaking.
-  ShutdownSingleThreadedCleanup(false);
+
+  // Clean up with no leaking.
+  Reset();
 
   // Do it again, just to be sure we reset state completely.
-  ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE);
+  EXPECT_TRUE(ThreadData::InitializeAndSetTrackingStatus(
+      ThreadData::PROFILING_CHILDREN_ACTIVE));
   EXPECT_FALSE(ThreadData::first());  // No activity even on this thread.
   data = ThreadData::Get();
   EXPECT_TRUE(ThreadData::first());  // Now class was constructed.
-  EXPECT_TRUE(data);
-  EXPECT_TRUE(!data->next());
+  ASSERT_TRUE(data);
+  EXPECT_FALSE(data->next());
   EXPECT_EQ(data, ThreadData::Get());
   birth_map.clear();
   death_map.clear();
+  parent_child_set.clear();
   data->SnapshotMaps(false, &birth_map, &death_map, &parent_child_set);
   EXPECT_EQ(0u, birth_map.size());
   EXPECT_EQ(0u, death_map.size());
   EXPECT_EQ(0u, parent_child_set.size());
 }
 
 TEST_F(TrackedObjectsTest, TinyStartupShutdown) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+          ThreadData::PROFILING_CHILDREN_ACTIVE))
     return;
 
   // Instigate tracking on a single tracked object, on our thread.
-  const Location& location = FROM_HERE;
+  Location location(kFunction, kFile, kLineNumber, NULL);
   Births* first_birth = ThreadData::TallyABirthIfActive(location);
 
   ThreadData* data = ThreadData::first();
   ASSERT_TRUE(data);
-  EXPECT_TRUE(!data->next());
+  EXPECT_FALSE(data->next());
   EXPECT_EQ(data, ThreadData::Get());
   ThreadData::BirthMap birth_map;
   ThreadData::DeathMap death_map;
   ThreadData::ParentChildSet parent_child_set;
   data->SnapshotMaps(false, &birth_map, &death_map, &parent_child_set);
   EXPECT_EQ(1u, birth_map.size());                         // 1 birth location.
   EXPECT_EQ(1, birth_map.begin()->second->birth_count());  // 1 birth.
   EXPECT_EQ(0u, death_map.size());                         // No deaths.
   EXPECT_EQ(0u, parent_child_set.size());                  // No children.
 
 
   // Now instigate another birth, while we are timing the run of the first
   // execution.
-  TrackedTime start_time =
-      ThreadData::NowForStartOfRun(first_birth);
+  TrackedTime start_time = ThreadData::NowForStartOfRun(first_birth);
   // Create a child (using the same birth location).
   // TrackingInfo will call TallyABirth() during construction.
   base::TimeTicks kBogusBirthTime;
   base::TrackingInfo pending_task(location, kBogusBirthTime);
   // Finally conclude the outer run.
   TrackedTime end_time = ThreadData::NowForEndOfRun();
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, start_time,
                                               end_time);
 
   birth_map.clear();
   death_map.clear();
   parent_child_set.clear();
   data->SnapshotMaps(false, &birth_map, &death_map, &parent_child_set);
   EXPECT_EQ(1u, birth_map.size());                         // 1 birth location.
   EXPECT_EQ(2, birth_map.begin()->second->birth_count());  // 2 births.
   EXPECT_EQ(1u, death_map.size());                         // 1 location.
   EXPECT_EQ(1, death_map.begin()->second.count());         // 1 death.
   if (ThreadData::TrackingParentChildStatus()) {
     EXPECT_EQ(1u, parent_child_set.size());                  // 1 child.
     EXPECT_EQ(parent_child_set.begin()->first,
               parent_child_set.begin()->second);
   } else {
     EXPECT_EQ(0u, parent_child_set.size());                  // no stats.
   }
 
   // The births were at the same location as the one known death.
   EXPECT_EQ(birth_map.begin()->second, death_map.begin()->first);
-}
 
-TEST_F(TrackedObjectsTest, ParentChildTest) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
-    return;
-  if (!ThreadData::TrackingParentChildStatus())
-    return;   // Feature not compiled in.
+  ProcessDataSnapshot process_data;
+  ThreadData::Snapshot(false, &process_data);
 
-  // Instigate tracking on a single tracked object, on our thread.
-  const int kFakeLineNumber = 1776;
-  const char* kFile = "FixedUnitTestFileName";
-  const char* kFunction = "ParentChildTest";
-  Location location(kFunction, kFile, kFakeLineNumber, NULL);
+  const int32 time_elapsed = (end_time - start_time).InMilliseconds();
+  ASSERT_EQ(1u, process_data.tasks.size());
+  EXPECT_EQ(kFile, process_data.tasks[0].birth.location.file_name);
+  EXPECT_EQ(kFunction, process_data.tasks[0].birth.location.function_name);
+  EXPECT_EQ(kLineNumber, process_data.tasks[0].birth.location.line_number);
+  EXPECT_EQ(kWorkerThreadName, process_data.tasks[0].birth.thread_name);
+  EXPECT_EQ(1, process_data.tasks[0].death_data.count);
+  EXPECT_EQ(time_elapsed, process_data.tasks[0].death_data.run_duration_sum);
+  EXPECT_EQ(time_elapsed, process_data.tasks[0].death_data.run_duration_max);
+  EXPECT_EQ(time_elapsed, process_data.tasks[0].death_data.run_duration_sample);
+  EXPECT_EQ(0, process_data.tasks[0].death_data.queue_duration_sum);
+  EXPECT_EQ(0, process_data.tasks[0].death_data.queue_duration_max);
+  EXPECT_EQ(0, process_data.tasks[0].death_data.queue_duration_sample);
+  EXPECT_EQ(kWorkerThreadName, process_data.tasks[0].death_thread_name);
 
-  // Now instigate another birth, while we are timing the run of the first
-  // execution.
-
-  // Create a child (using the same birth location).
-  // TrackingInfo will call TallyABirth() during construction.
-  base::TimeTicks kBogusBirthTime;
-  base::TrackingInfo pending_task(location, kBogusBirthTime);
-
-  // Don't conclude the run, so that we don't use the actual timer that we
-  // started for the outer profile.  This way the JSON will not include some
-  // random time.
-  ThreadData* data = ThreadData::first();
-  ASSERT_TRUE(data);
-  EXPECT_TRUE(!data->next());
-  EXPECT_EQ(data, ThreadData::Get());
-
-  ThreadData::BirthMap birth_map;
-  ThreadData::DeathMap death_map;
-  ThreadData::ParentChildSet parent_child_set;
-
-  data->SnapshotMaps(false, &birth_map, &death_map, &parent_child_set);
-  EXPECT_EQ(1u, birth_map.size());                         // 1 birth location.
-  EXPECT_EQ(2, birth_map.begin()->second->birth_count());  // 2 births.
-  EXPECT_EQ(0u, death_map.size());                         // No status yet.
-  // Just like TinyStartupShutdown test.
-  EXPECT_EQ(1u, parent_child_set.size());                  // 1 child.
-  EXPECT_EQ(parent_child_set.begin()->first,
-            parent_child_set.begin()->second);
-
-  scoped_ptr<base::Value> value(ThreadData::ToValue(false));
-  std::string json;
-  base::JSONWriter::Write(value.get(), &json);
-  std::string birth_only_result = "{"
-      "\"descendants\":["
-        "{"
-          "\"child_location\":{"
-            "\"file_name\":\"FixedUnitTestFileName\","
-            "\"function_name\":\"ParentChildTest\","
-            "\"line_number\":1776"
-          "},"
-          "\"child_thread\":\"WorkerThread-1\","
-          "\"parent_location\":{"
-            "\"file_name\":\"FixedUnitTestFileName\","
-            "\"function_name\":\"ParentChildTest\","
-            "\"line_number\":1776"
-          "},"
-          "\"parent_thread\":\"WorkerThread-1\""
-        "}"
-      "],"
-      "\"list\":["
-        "{"
-          "\"birth_thread\":\"WorkerThread-1\","
-          "\"death_data\":{"
-            "\"count\":2,"
-            "\"queue_ms\":0,"
-            "\"queue_ms_max\":0,"
-            "\"queue_ms_sample\":0,"
-            "\"run_ms\":0,"
-            "\"run_ms_max\":0,"
-            "\"run_ms_sample\":0"
-          "},"
-          "\"death_thread\":\"Still_Alive\","
-          "\"location\":{"
-            "\"file_name\":\"FixedUnitTestFileName\","
-            "\"function_name\":\"ParentChildTest\","
-            "\"line_number\":1776"
-          "}"
-        "}"
-      "]"
-    "}";
-  EXPECT_EQ(json, birth_only_result);
+  if (ThreadData::TrackingParentChildStatus()) {
+    ASSERT_EQ(1u, process_data.descendants.size());
+    EXPECT_EQ(kFile, process_data.descendants[0].parent.location.file_name);
+    EXPECT_EQ(kFunction,
+              process_data.descendants[0].parent.location.function_name);
+    EXPECT_EQ(kLineNumber,
+              process_data.descendants[0].parent.location.line_number);
+    EXPECT_EQ(kWorkerThreadName,
+              process_data.descendants[0].parent.thread_name);
+    EXPECT_EQ(kFile, process_data.descendants[0].child.location.file_name);
+    EXPECT_EQ(kFunction,
+              process_data.descendants[0].child.location.function_name);
+    EXPECT_EQ(kLineNumber,
+              process_data.descendants[0].child.location.line_number);
+    EXPECT_EQ(kWorkerThreadName, process_data.descendants[0].child.thread_name);
+  } else {
+    EXPECT_EQ(0u, process_data.descendants.size());
+  }
 }
 
 TEST_F(TrackedObjectsTest, DeathDataTest) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+          ThreadData::PROFILING_CHILDREN_ACTIVE))
     return;
 
   scoped_ptr<DeathData> data(new DeathData());
   ASSERT_NE(data, reinterpret_cast<DeathData*>(NULL));
   EXPECT_EQ(data->run_duration_sum(), 0);
   EXPECT_EQ(data->run_duration_sample(), 0);
   EXPECT_EQ(data->queue_duration_sum(), 0);
   EXPECT_EQ(data->queue_duration_sample(), 0);
   EXPECT_EQ(data->count(), 0);
 
   int32 run_ms = 42;
   int32 queue_ms = 8;
 
   const int kUnrandomInt = 0;  // Fake random int that ensure we sample data.
   data->RecordDeath(queue_ms, run_ms, kUnrandomInt);
   EXPECT_EQ(data->run_duration_sum(), run_ms);
   EXPECT_EQ(data->run_duration_sample(), run_ms);
   EXPECT_EQ(data->queue_duration_sum(), queue_ms);
   EXPECT_EQ(data->queue_duration_sample(), queue_ms);
   EXPECT_EQ(data->count(), 1);
 
   data->RecordDeath(queue_ms, run_ms, kUnrandomInt);
   EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms);
   EXPECT_EQ(data->run_duration_sample(), run_ms);
   EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms);
   EXPECT_EQ(data->queue_duration_sample(), queue_ms);
   EXPECT_EQ(data->count(), 2);
 
-  scoped_ptr<base::DictionaryValue> dictionary(data->ToValue());
-  int integer;
-  EXPECT_TRUE(dictionary->GetInteger("run_ms", &integer));
-  EXPECT_EQ(integer, 2 * run_ms);
-  EXPECT_TRUE(dictionary->GetInteger("run_ms_sample", &integer));
-  EXPECT_EQ(integer, run_ms);
-  EXPECT_TRUE(dictionary->GetInteger("queue_ms", &integer));
-  EXPECT_EQ(integer, 2 * queue_ms);
-  EXPECT_TRUE(dictionary->GetInteger("queue_ms_sample", &integer));
-  EXPECT_EQ(integer, queue_ms);
-  EXPECT_TRUE(dictionary->GetInteger("count", &integer));
-  EXPECT_EQ(integer, 2);
-
-  scoped_ptr<base::Value> value(data->ToValue());
-  std::string json;
-  base::JSONWriter::Write(value.get(), &json);
-  std::string birth_only_result = "{"
-      "\"count\":2,"
-      "\"queue_ms\":16,"
-      "\"queue_ms_max\":8,"
-      "\"queue_ms_sample\":8,"
-      "\"run_ms\":84,"
-      "\"run_ms_max\":42,"
-      "\"run_ms_sample\":42"
-      "}";
-  EXPECT_EQ(birth_only_result, json);
+  DeathDataSnapshot snapshot(*data);
+  EXPECT_EQ(2, snapshot.count);
+  EXPECT_EQ(2 * run_ms, snapshot.run_duration_sum);
+  EXPECT_EQ(run_ms, snapshot.run_duration_max);
+  EXPECT_EQ(run_ms, snapshot.run_duration_sample);
+  EXPECT_EQ(2 * queue_ms, snapshot.queue_duration_sum);
+  EXPECT_EQ(queue_ms, snapshot.queue_duration_max);
+  EXPECT_EQ(queue_ms, snapshot.queue_duration_sample);
 }
 
-TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToValueWorkerThread) {
-  // Transition to Deactivated state before doing anything.
-  if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED))
-    return;
-  // We don't initialize system with a thread name, so we're viewed as a worker
-  // thread.
-  const int kFakeLineNumber = 173;
-  const char* kFile = "FixedFileName";
-  const char* kFunction = "BirthOnlyToValueWorkerThread";
-  Location location(kFunction, kFile, kFakeLineNumber, NULL);
-  Births* birth = ThreadData::TallyABirthIfActive(location);
-  // We should now see a NULL birth record.
-  EXPECT_EQ(birth, reinterpret_cast<Births*>(NULL));
-
-  scoped_ptr<base::Value> value(ThreadData::ToValue(false));
-  std::string json;
-  base::JSONWriter::Write(value.get(), &json);
-  std::string birth_only_result = "{"
-      "\"descendants\":["
-      "],"
-      "\"list\":["
-      "]"
-    "}";
-  EXPECT_EQ(json, birth_only_result);
-}
-
-TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToValueMainThread) {
+TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToSnapshotWorkerThread) {
   // Start in the deactivated state.
   if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED))
     return;
 
-  // Use a well named thread.
-  ThreadData::InitializeThreadContext("SomeMainThreadName");
-  const int kFakeLineNumber = 173;
-  const char* kFile = "FixedFileName";
-  const char* kFunction = "BirthOnlyToValueMainThread";
-  Location location(kFunction, kFile, kFakeLineNumber, NULL);
-  // Do not delete birth.  We don't own it.
-  Births* birth = ThreadData::TallyABirthIfActive(location);
-  // We expect to not get a birth record.
-  EXPECT_EQ(birth, reinterpret_cast<Births*>(NULL));
+  Location location(kFunction, kFile, kLineNumber, NULL);
+  TallyABirth(location, std::string());
 
-  scoped_ptr<base::Value> value(ThreadData::ToValue(false));
-  std::string json;
-  base::JSONWriter::Write(value.get(), &json);
-  std::string birth_only_result = "{"
-      "\"descendants\":["
-      "],"
-      "\"list\":["
-      "]"
-    "}";
-  EXPECT_EQ(json, birth_only_result);
+  ProcessDataSnapshot process_data;
+  ThreadData::Snapshot(false, &process_data);
+  EXPECT_EQ(0u, process_data.tasks.size());
+  EXPECT_EQ(0u, process_data.descendants.size());
+  EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
-TEST_F(TrackedObjectsTest, BirthOnlyToValueWorkerThread) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToSnapshotMainThread) {
+  // Start in the deactivated state.
+  if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED))
     return;
-  // We don't initialize system with a thread name, so we're viewed as a worker
-  // thread.
-  const int kFakeLineNumber = 173;
-  const char* kFile = "FixedFileName";
-  const char* kFunction = "BirthOnlyToValueWorkerThread";
-  Location location(kFunction, kFile, kFakeLineNumber, NULL);
-  Births* birth = ThreadData::TallyABirthIfActive(location);
-  EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));
 
-  scoped_ptr<base::Value> value(ThreadData::ToValue(false));
-  std::string json;
-  base::JSONWriter::Write(value.get(), &json);
-  std::string birth_only_result = "{"
-      "\"descendants\":["
-      "],"
-      "\"list\":["
-        "{"
-          "\"birth_thread\":\"WorkerThread-1\","
-          "\"death_data\":{"
-            "\"count\":1,"
-            "\"queue_ms\":0,"
-            "\"queue_ms_max\":0,"
-            "\"queue_ms_sample\":0,"
-            "\"run_ms\":0,"
-            "\"run_ms_max\":0,"
-            "\"run_ms_sample\":0"
-          "},"
-          "\"death_thread\":\"Still_Alive\","
-          "\"location\":{"
-            "\"file_name\":\"FixedFileName\","
-            "\"function_name\":\"BirthOnlyToValueWorkerThread\","
-            "\"line_number\":173"
-          "}"
-        "}"
-      "]"
-    "}";
-  EXPECT_EQ(json, birth_only_result);
+  Location location(kFunction, kFile, kLineNumber, NULL);
+  TallyABirth(location, kMainThreadName);
+
+  ProcessDataSnapshot process_data;
+  ThreadData::Snapshot(false, &process_data);
+  EXPECT_EQ(0u, process_data.tasks.size());
+  EXPECT_EQ(0u, process_data.descendants.size());
+  EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
-TEST_F(TrackedObjectsTest, BirthOnlyToValueMainThread) {
+TEST_F(TrackedObjectsTest, BirthOnlyToSnapshotWorkerThread) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+          ThreadData::PROFILING_CHILDREN_ACTIVE))
     return;
 
-  // Use a well named thread.
-  ThreadData::InitializeThreadContext("SomeMainThreadName");
-  const int kFakeLineNumber = 173;
-  const char* kFile = "FixedFileName";
-  const char* kFunction = "BirthOnlyToValueMainThread";
-  Location location(kFunction, kFile, kFakeLineNumber, NULL);
-  // Do not delete birth.  We don't own it.
-  Births* birth = ThreadData::TallyABirthIfActive(location);
-  EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));
+  Location location(kFunction, kFile, kLineNumber, NULL);
+  TallyABirth(location, std::string());
 
-  scoped_ptr<base::Value> value(ThreadData::ToValue(false));
-  std::string json;
-  base::JSONWriter::Write(value.get(), &json);
-  std::string birth_only_result = "{"
-      "\"descendants\":["
-      "],"
-      "\"list\":["
-        "{"
-          "\"birth_thread\":\"SomeMainThreadName\","
-          "\"death_data\":{"
-            "\"count\":1,"
-            "\"queue_ms\":0,"
-            "\"queue_ms_max\":0,"
-            "\"queue_ms_sample\":0,"
-            "\"run_ms\":0,"
-            "\"run_ms_max\":0,"
-            "\"run_ms_sample\":0"
-          "},"
-          "\"death_thread\":\"Still_Alive\","
-          "\"location\":{"
-            "\"file_name\":\"FixedFileName\","
-            "\"function_name\":\"BirthOnlyToValueMainThread\","
-            "\"line_number\":173"
-          "}"
-        "}"
-      "]"
-    "}";
-  EXPECT_EQ(json, birth_only_result);
+  ProcessDataSnapshot process_data;
+  ThreadData::Snapshot(false, &process_data);
+  ExpectSimpleProcessData(process_data, kWorkerThreadName, kStillAlive,
+                          1, 0, 0);
 }
 
-TEST_F(TrackedObjectsTest, LifeCycleToValueMainThread) {
+TEST_F(TrackedObjectsTest, BirthOnlyToSnapshotMainThread) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+          ThreadData::PROFILING_CHILDREN_ACTIVE))
     return;
 
-  // Use a well named thread.
-  ThreadData::InitializeThreadContext("SomeMainThreadName");
-  const int kFakeLineNumber = 236;
-  const char* kFile = "FixedFileName";
-  const char* kFunction = "LifeCycleToValueMainThread";
-  Location location(kFunction, kFile, kFakeLineNumber, NULL);
-  // Do not delete birth.  We don't own it.
-  Births* birth = ThreadData::TallyABirthIfActive(location);
-  EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));
+  Location location(kFunction, kFile, kLineNumber, NULL);
+  TallyABirth(location, kMainThreadName);
 
-  const base::TimeTicks kTimePosted = base::TimeTicks()
-      + base::TimeDelta::FromMilliseconds(1);
+  ProcessDataSnapshot process_data;
+  ThreadData::Snapshot(false, &process_data);
+  ExpectSimpleProcessData(process_data, kMainThreadName, kStillAlive,
+                          1, 0, 0);
+}
+
+TEST_F(TrackedObjectsTest, LifeCycleToSnapshotMainThread) {
+  if (!ThreadData::InitializeAndSetTrackingStatus(
+          ThreadData::PROFILING_CHILDREN_ACTIVE))
+    return;
+
+  Location location(kFunction, kFile, kLineNumber, NULL);
+  TallyABirth(location, kMainThreadName);
+
+  const base::TimeTicks kTimePosted = base::TimeTicks() +
+      base::TimeDelta::FromMilliseconds(1);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   const TrackedTime kStartOfRun = TrackedTime() +
       Duration::FromMilliseconds(5);
   const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7);
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task,
       kStartOfRun, kEndOfRun);
 
-  scoped_ptr<base::Value> value(ThreadData::ToValue(false));
-  std::string json;
-  base::JSONWriter::Write(value.get(), &json);
-  std::string one_line_result = "{"
-      "\"descendants\":["
-      "],"
-      "\"list\":["
-        "{"
-          "\"birth_thread\":\"SomeMainThreadName\","
-          "\"death_data\":{"
-            "\"count\":1,"
-            "\"queue_ms\":4,"
-            "\"queue_ms_max\":4,"
-            "\"queue_ms_sample\":4,"
-            "\"run_ms\":2,"
-            "\"run_ms_max\":2,"
-            "\"run_ms_sample\":2"
-          "},"
-          "\"death_thread\":\"SomeMainThreadName\","
-          "\"location\":{"
-            "\"file_name\":\"FixedFileName\","
-            "\"function_name\":\"LifeCycleToValueMainThread\","
-            "\"line_number\":236"
-          "}"
-        "}"
-      "]"
-    "}";
-  EXPECT_EQ(one_line_result, json);
+  ProcessDataSnapshot process_data;
+  ThreadData::Snapshot(false, &process_data);
+  ExpectSimpleProcessData(process_data, kMainThreadName, kMainThreadName,
+                          1, 2, 4);
 }
 
 // We will deactivate tracking after the birth, and before the death, and
 // demonstrate that the lifecycle is completely tallied. This ensures that
 // our tallied births are matched by tallied deaths (except for when the
 // task is still running, or is queued).
-TEST_F(TrackedObjectsTest, LifeCycleMidDeactivatedToValueMainThread) {
+TEST_F(TrackedObjectsTest, LifeCycleMidDeactivatedToSnapshotMainThread) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+          ThreadData::PROFILING_CHILDREN_ACTIVE))
     return;
 
-  // Use a well named thread.
-  ThreadData::InitializeThreadContext("SomeMainThreadName");
-  const int kFakeLineNumber = 236;
-  const char* kFile = "FixedFileName";
-  const char* kFunction = "LifeCycleToValueMainThread";
-  Location location(kFunction, kFile, kFakeLineNumber, NULL);
-  // Do not delete birth.  We don't own it.
-  Births* birth = ThreadData::TallyABirthIfActive(location);
-  EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));
+  Location location(kFunction, kFile, kLineNumber, NULL);
+  TallyABirth(location, kMainThreadName);
 
-  const base::TimeTicks kTimePosted = base::TimeTicks()
-      + base::TimeDelta::FromMilliseconds(1);
+  const base::TimeTicks kTimePosted = base::TimeTicks() +
+      base::TimeDelta::FromMilliseconds(1);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   // Turn off tracking now that we have births.
   EXPECT_TRUE(ThreadData::InitializeAndSetTrackingStatus(
       ThreadData::DEACTIVATED));
 
   const TrackedTime kStartOfRun = TrackedTime() +
       Duration::FromMilliseconds(5);
   const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7);
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task,
       kStartOfRun, kEndOfRun);
 
-  scoped_ptr<base::Value> value(ThreadData::ToValue(false));
-  std::string json;
-  base::JSONWriter::Write(value.get(), &json);
-  std::string one_line_result = "{"
-      "\"descendants\":["
-      "],"
-      "\"list\":["
-        "{"
-          "\"birth_thread\":\"SomeMainThreadName\","
-          "\"death_data\":{"
-            "\"count\":1,"
-            "\"queue_ms\":4,"
-            "\"queue_ms_max\":4,"
-            "\"queue_ms_sample\":4,"
-            "\"run_ms\":2,"
-            "\"run_ms_max\":2,"
-            "\"run_ms_sample\":2"
-          "},"
-          "\"death_thread\":\"SomeMainThreadName\","
-          "\"location\":{"
-            "\"file_name\":\"FixedFileName\","
-            "\"function_name\":\"LifeCycleToValueMainThread\","
-            "\"line_number\":236"
-          "}"
-        "}"
-      "]"
-    "}";
-  EXPECT_EQ(one_line_result, json);
+  ProcessDataSnapshot process_data;
+  ThreadData::Snapshot(false, &process_data);
+  ExpectSimpleProcessData(process_data, kMainThreadName, kMainThreadName,
+                          1, 2, 4);
 }
 
 // We will deactivate tracking before starting a life cycle, and neither
 // the birth nor the death will be recorded.
-TEST_F(TrackedObjectsTest, LifeCyclePreDeactivatedToValueMainThread) {
+TEST_F(TrackedObjectsTest, LifeCyclePreDeactivatedToSnapshotMainThread) {
+  // Start in the deactivated state.
   if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED))
     return;
 
-  // Use a well named thread.
-  ThreadData::InitializeThreadContext("SomeMainThreadName");
-  const int kFakeLineNumber = 236;
-  const char* kFile = "FixedFileName";
-  const char* kFunction = "LifeCycleToValueMainThread";
-  Location location(kFunction, kFile, kFakeLineNumber, NULL);
-  // Do not delete birth.  We don't own it.
-  Births* birth = ThreadData::TallyABirthIfActive(location);
-  EXPECT_EQ(birth, reinterpret_cast<Births*>(NULL));
+  Location location(kFunction, kFile, kLineNumber, NULL);
+  TallyABirth(location, kMainThreadName);
 
-  const base::TimeTicks kTimePosted = base::TimeTicks()
-      + base::TimeDelta::FromMilliseconds(1);
+  const base::TimeTicks kTimePosted = base::TimeTicks() +
+      base::TimeDelta::FromMilliseconds(1);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   const TrackedTime kStartOfRun = TrackedTime() +
       Duration::FromMilliseconds(5);
   const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7);
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task,
       kStartOfRun, kEndOfRun);
 
-  scoped_ptr<base::Value> value(ThreadData::ToValue(false));
-  std::string json;
-  base::JSONWriter::Write(value.get(), &json);
-  std::string one_line_result = "{"
-      "\"descendants\":["
-      "],"
-      "\"list\":["
-      "]"
-    "}";
-  EXPECT_EQ(one_line_result, json);
+  ProcessDataSnapshot process_data;
+  ThreadData::Snapshot(false, &process_data);
+  EXPECT_EQ(0u, process_data.tasks.size());
+  EXPECT_EQ(0u, process_data.descendants.size());
+  EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
-TEST_F(TrackedObjectsTest, LifeCycleToValueWorkerThread) {
+TEST_F(TrackedObjectsTest, LifeCycleToSnapshotWorkerThread) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+          ThreadData::PROFILING_CHILDREN_ACTIVE))
     return;
 
-  // Don't initialize thread, so that we appear as a worker thread.
-  // ThreadData::InitializeThreadContext("SomeMainThreadName");
-
-  const int kFakeLineNumber = 236;
-  const char* kFile = "FixedFileName";
-  const char* kFunction = "LifeCycleToValueWorkerThread";
-  Location location(kFunction, kFile, kFakeLineNumber, NULL);
-  // Do not delete birth.  We don't own it.
+  Location location(kFunction, kFile, kLineNumber, NULL);
+  // Do not delete |birth|.  We don't own it.
   Births* birth = ThreadData::TallyABirthIfActive(location);
-  EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));
+  EXPECT_NE(reinterpret_cast<Births*>(NULL), birth);
 
   const TrackedTime kTimePosted = TrackedTime() + Duration::FromMilliseconds(1);
   const TrackedTime kStartOfRun = TrackedTime() +
       Duration::FromMilliseconds(5);
   const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7);
   ThreadData::TallyRunOnWorkerThreadIfTracking(birth, kTimePosted,
       kStartOfRun, kEndOfRun);
 
-  // Call for the ToValue, but tell it to not the maxes after scanning.
-  scoped_ptr<base::Value> value(ThreadData::ToValue(false));
-  std::string json;
-  base::JSONWriter::Write(value.get(), &json);
-  std::string one_line_result = "{"
-      "\"descendants\":["
-      "],"
-      "\"list\":["
-        "{"
-          "\"birth_thread\":\"WorkerThread-1\","
-          "\"death_data\":{"
-            "\"count\":1,"
-            "\"queue_ms\":4,"
-            "\"queue_ms_max\":4,"
-            "\"queue_ms_sample\":4,"
-            "\"run_ms\":2,"
-            "\"run_ms_max\":2,"
-            "\"run_ms_sample\":2"
-          "},"
-          "\"death_thread\":\"WorkerThread-1\","
-          "\"location\":{"
-            "\"file_name\":\"FixedFileName\","
-            "\"function_name\":\"LifeCycleToValueWorkerThread\","
-            "\"line_number\":236"
-          "}"
-        "}"
-      "]"
-    "}";
-  EXPECT_EQ(one_line_result, json);
+  // Call for the ToSnapshot, but tell it to not reset the maxes after scanning.
+  ProcessDataSnapshot process_data;
+  ThreadData::Snapshot(false, &process_data);
+  ExpectSimpleProcessData(process_data, kWorkerThreadName, kWorkerThreadName,
+                          1, 2, 4);
 
-  // Call for the ToValue, but tell it to reset the maxes after scanning.
+  // Call for the ToSnapshot, but tell it to reset the maxes after scanning.
   // We'll still get the same values, but the data will be reset (which we'll
   // see in a moment).
-  value.reset(ThreadData::ToValue(true));
-  base::JSONWriter::Write(value.get(), &json);
-  // Result should be unchanged.
-  EXPECT_EQ(one_line_result, json);
+  ProcessDataSnapshot process_data_pre_reset;
+  ThreadData::Snapshot(true, &process_data_pre_reset);
+  ExpectSimpleProcessData(process_data, kWorkerThreadName, kWorkerThreadName,
+                          1, 2, 4);
 
-  // Call for the ToValue, and now we'll see the result of the last translation,
-  // as the max will have been pushed back to zero.
-  value.reset(ThreadData::ToValue(false));
-  base::JSONWriter::Write(value.get(), &json);
-  std::string one_line_result_with_zeros = "{"
-      "\"descendants\":["
-      "],"
-      "\"list\":["
-        "{"
-          "\"birth_thread\":\"WorkerThread-1\","
-          "\"death_data\":{"
-            "\"count\":1,"
-            "\"queue_ms\":4,"
-            "\"queue_ms_max\":0,"  // Note zero here.
-            "\"queue_ms_sample\":4,"
-            "\"run_ms\":2,"
-            "\"run_ms_max\":0,"   // Note zero here.
-            "\"run_ms_sample\":2"
-          "},"
-          "\"death_thread\":\"WorkerThread-1\","
-          "\"location\":{"
-            "\"file_name\":\"FixedFileName\","
-            "\"function_name\":\"LifeCycleToValueWorkerThread\","
-            "\"line_number\":236"
-          "}"
-        "}"
-      "]"
-    "}";
-  EXPECT_EQ(one_line_result_with_zeros, json);
+  // Call for the ToSnapshot, and now we'll see the result of the last
+  // translation, as the max will have been pushed back to zero.
+  ProcessDataSnapshot process_data_post_reset;
+  ThreadData::Snapshot(true, &process_data_post_reset);
+  ASSERT_EQ(1u, process_data_post_reset.tasks.size());
+  EXPECT_EQ(kFile, process_data_post_reset.tasks[0].birth.location.file_name);
+  EXPECT_EQ(kFunction,
+            process_data_post_reset.tasks[0].birth.location.function_name);
+  EXPECT_EQ(kLineNumber,
+            process_data_post_reset.tasks[0].birth.location.line_number);
+  EXPECT_EQ(kWorkerThreadName,
+            process_data_post_reset.tasks[0].birth.thread_name);
+  EXPECT_EQ(1, process_data_post_reset.tasks[0].death_data.count);
+  EXPECT_EQ(2, process_data_post_reset.tasks[0].death_data.run_duration_sum);
+  EXPECT_EQ(0, process_data_post_reset.tasks[0].death_data.run_duration_max);
+  EXPECT_EQ(2, process_data_post_reset.tasks[0].death_data.run_duration_sample);
+  EXPECT_EQ(4, process_data_post_reset.tasks[0].death_data.queue_duration_sum);
+  EXPECT_EQ(0, process_data_post_reset.tasks[0].death_data.queue_duration_max);
+  EXPECT_EQ(4,
+            process_data_post_reset.tasks[0].death_data.queue_duration_sample);
+  EXPECT_EQ(kWorkerThreadName,
+            process_data_post_reset.tasks[0].death_thread_name);
+  EXPECT_EQ(0u, process_data_post_reset.descendants.size());
+  EXPECT_EQ(base::GetCurrentProcId(), process_data_post_reset.process_id);
 }
 
 TEST_F(TrackedObjectsTest, TwoLives) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+          ThreadData::PROFILING_CHILDREN_ACTIVE))
     return;
 
-  // Use a well named thread.
-  ThreadData::InitializeThreadContext("SomeFileThreadName");
-  const int kFakeLineNumber = 222;
-  const char* kFile = "AnotherFileName";
-  const char* kFunction = "TwoLives";
-  Location location(kFunction, kFile, kFakeLineNumber, NULL);
-  // Do not delete birth.  We don't own it.
-  Births* birth = ThreadData::TallyABirthIfActive(location);
-  EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));
+  Location location(kFunction, kFile, kLineNumber, NULL);
+  TallyABirth(location, kMainThreadName);
 
-
-  const base::TimeTicks kTimePosted = base::TimeTicks()
-      + base::TimeDelta::FromMilliseconds(1);
+  const base::TimeTicks kTimePosted = base::TimeTicks() +
+      base::TimeDelta::FromMilliseconds(1);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   const TrackedTime kStartOfRun = TrackedTime() +
       Duration::FromMilliseconds(5);
   const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7);
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task,
       kStartOfRun, kEndOfRun);
 
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task2(location, kDelayedStartTime);
   pending_task2.time_posted = kTimePosted;  // Overwrite implied Now().
 
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task2,
       kStartOfRun, kEndOfRun);
 
-  scoped_ptr<base::Value> value(ThreadData::ToValue(false));
-  std::string json;
-  base::JSONWriter::Write(value.get(), &json);
-  std::string one_line_result = "{"
-      "\"descendants\":["
-      "],"
-      "\"list\":["
-        "{"
-          "\"birth_thread\":\"SomeFileThreadName\","
-          "\"death_data\":{"
-            "\"count\":2,"
-            "\"queue_ms\":8,"
-            "\"queue_ms_max\":4,"
-            "\"queue_ms_sample\":4,"
-            "\"run_ms\":4,"
-            "\"run_ms_max\":2,"
-            "\"run_ms_sample\":2"
-          "},"
-          "\"death_thread\":\"SomeFileThreadName\","
-          "\"location\":{"
-            "\"file_name\":\"AnotherFileName\","
-            "\"function_name\":\"TwoLives\","
-            "\"line_number\":222"
-          "}"
-        "}"
-      "]"
-    "}";
-  EXPECT_EQ(one_line_result, json);
+  ProcessDataSnapshot process_data;
+  ThreadData::Snapshot(false, &process_data);
+  ExpectSimpleProcessData(process_data, kMainThreadName, kMainThreadName,
+                          2, 2, 4);
 }
 
 TEST_F(TrackedObjectsTest, DifferentLives) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
-      ThreadData::PROFILING_CHILDREN_ACTIVE))
+          ThreadData::PROFILING_CHILDREN_ACTIVE))
     return;
 
   // Use a well named thread.
-  ThreadData::InitializeThreadContext("SomeFileThreadName");
-  const int kFakeLineNumber = 567;
-  const char* kFile = "AnotherFileName";
-  const char* kFunction = "DifferentLives";
-  Location location(kFunction, kFile, kFakeLineNumber, NULL);
+  ThreadData::InitializeThreadContext(kMainThreadName);
+  Location location(kFunction, kFile, kLineNumber, NULL);
 
-  const base::TimeTicks kTimePosted = base::TimeTicks()
-      + base::TimeDelta::FromMilliseconds(1);
+  const base::TimeTicks kTimePosted = base::TimeTicks() +
+      base::TimeDelta::FromMilliseconds(1);
   const base::TimeTicks kDelayedStartTime = base::TimeTicks();
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task(location, kDelayedStartTime);
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   const TrackedTime kStartOfRun = TrackedTime() +
       Duration::FromMilliseconds(5);
   const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7);
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task,
       kStartOfRun, kEndOfRun);
 
   const int kSecondFakeLineNumber = 999;
   Location second_location(kFunction, kFile, kSecondFakeLineNumber, NULL);
 
   // TrackingInfo will call TallyABirth() during construction.
   base::TrackingInfo pending_task2(second_location, kDelayedStartTime);
   pending_task2.time_posted = kTimePosted;  // Overwrite implied Now().
 
-  scoped_ptr<base::Value> value(ThreadData::ToValue(false));
-  std::string json;
-  base::JSONWriter::Write(value.get(), &json);
-  std::string one_line_result = "{"
-      "\"descendants\":["
-      "],"
-      "\"list\":["
-        "{"
-          "\"birth_thread\":\"SomeFileThreadName\","
-          "\"death_data\":{"
-            "\"count\":1,"
-            "\"queue_ms\":4,"
-            "\"queue_ms_max\":4,"
-            "\"queue_ms_sample\":4,"
-            "\"run_ms\":2,"
-            "\"run_ms_max\":2,"
-            "\"run_ms_sample\":2"
-          "},"
-          "\"death_thread\":\"SomeFileThreadName\","
-          "\"location\":{"
-            "\"file_name\":\"AnotherFileName\","
-            "\"function_name\":\"DifferentLives\","
-            "\"line_number\":567"
-          "}"
-        "},"
-        "{"
-          "\"birth_thread\":\"SomeFileThreadName\","
-          "\"death_data\":{"
-            "\"count\":1,"
-            "\"queue_ms\":0,"
-            "\"queue_ms_max\":0,"
-            "\"queue_ms_sample\":0,"
-            "\"run_ms\":0,"
-            "\"run_ms_max\":0,"
-            "\"run_ms_sample\":0"
-          "},"
-          "\"death_thread\":\"Still_Alive\","
-          "\"location\":{"
-            "\"file_name\":\"AnotherFileName\","
-            "\"function_name\":\"DifferentLives\","
-            "\"line_number\":999"
-          "}"
-        "}"
-      "]"
-    "}";
-  EXPECT_EQ(one_line_result, json);
+  ProcessDataSnapshot process_data;
+  ThreadData::Snapshot(false, &process_data);
+  ASSERT_EQ(2u, process_data.tasks.size());
+  EXPECT_EQ(kFile, process_data.tasks[0].birth.location.file_name);
+  EXPECT_EQ(kFunction, process_data.tasks[0].birth.location.function_name);
+  EXPECT_EQ(kLineNumber, process_data.tasks[0].birth.location.line_number);
+  EXPECT_EQ(kMainThreadName, process_data.tasks[0].birth.thread_name);
+  EXPECT_EQ(1, process_data.tasks[0].death_data.count);
+  EXPECT_EQ(2, process_data.tasks[0].death_data.run_duration_sum);
+  EXPECT_EQ(2, process_data.tasks[0].death_data.run_duration_max);
+  EXPECT_EQ(2, process_data.tasks[0].death_data.run_duration_sample);
+  EXPECT_EQ(4, process_data.tasks[0].death_data.queue_duration_sum);
+  EXPECT_EQ(4, process_data.tasks[0].death_data.queue_duration_max);
+  EXPECT_EQ(4, process_data.tasks[0].death_data.queue_duration_sample);
+  EXPECT_EQ(kMainThreadName, process_data.tasks[0].death_thread_name);
+  EXPECT_EQ(kFile, process_data.tasks[1].birth.location.file_name);
+  EXPECT_EQ(kFunction, process_data.tasks[1].birth.location.function_name);
+  EXPECT_EQ(kSecondFakeLineNumber,
+            process_data.tasks[1].birth.location.line_number);
+  EXPECT_EQ(kMainThreadName, process_data.tasks[1].birth.thread_name);
+  EXPECT_EQ(1, process_data.tasks[1].death_data.count);
+  EXPECT_EQ(0, process_data.tasks[1].death_data.run_duration_sum);
+  EXPECT_EQ(0, process_data.tasks[1].death_data.run_duration_max);
+  EXPECT_EQ(0, process_data.tasks[1].death_data.run_duration_sample);
+  EXPECT_EQ(0, process_data.tasks[1].death_data.queue_duration_sum);
+  EXPECT_EQ(0, process_data.tasks[1].death_data.queue_duration_max);
+  EXPECT_EQ(0, process_data.tasks[1].death_data.queue_duration_sample);
+  EXPECT_EQ(kStillAlive, process_data.tasks[1].death_thread_name);
+  EXPECT_EQ(0u, process_data.descendants.size());
+  EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
-
 }  // namespace tracked_objects