[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/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace {
+
+std::string GetProcessIdString() {
+  return base::IntToString(base::GetCurrentProcId());

[jar (doing other things), 2012/04/04 17:55:35]

nit: I'm not sure which is better.... but you could put this in as a slot in the
TrackedObjectTest class, that is initialized during the constructor.

I can't make up my mind... so leaving it as is should be fine... but I thought
I'd mention the alternative.

+}
+
+}  // anonymous namespace
+
 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);
   }
 
   ~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);
   }

[jar (doing other things), 2012/04/04 17:55:35]

These lines (surely written by me) are useless, since we call directly into the
ThreadData method on lines 28 and 34.

[Ilya Sherman, 2012/04/05 02:51:04]

This seems to be used by the TrackedObjectsTest.MinimalStartupShutdown test (and
is needed to change the visibility of
ThreadData::ShutdownSingleThreadedCleanup() for that test).

 };
 
 TEST_F(TrackedObjectsTest, MinimalStartupShutdown) {
   // Minimal test doesn't even create any tasks.
   if (!ThreadData::InitializeAndSetTrackingStatus(
       ThreadData::PROFILING_CHILDREN_ACTIVE))
     return;
 
   EXPECT_FALSE(ThreadData::first());  // No activity even on this thread.
   ThreadData* data = ThreadData::Get();
@@ skipping 119 matching lines @@
 
   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));
+  SerializedProcessData process_data;
+  ThreadData::ToSerializedProcessData(false, &process_data);
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);

[jar (doing other things), 2012/04/04 17:55:35]

I think the scoped pointer was only useful because we used to get a return of a
pointer.  Now that you're creating the value locally, you can just use a local
instance (instead of a scoped pointer).

[Ilya Sherman, 2012/04/05 02:51:04]

This test code is actually completely out of sync with the rest of the CL,
because I didn't want to spend time updating it if we decided to go in a
different direction.  There is no longer any way to generate the DictionaryValue
serialization within base/ -- I'll need to fix up the tests, which I'll do in a
follow-up patch set.  (Note: patch set, not CL :)

+  process_data.ToValue(value.get());
+
   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"
           "},"
@@ skipping 54 matching lines @@
   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());
+  scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue);

[jar (doing other things), 2012/04/04 17:55:35]

Suggest using just an instance (not scoped pointer).  Here and below.

+  SerializedDeathData(*data).ToValue(dictionary.get());
   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());
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+  SerializedDeathData(*data).ToValue(value.get());
   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);
 }
 
 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));
+  SerializedProcessData process_data;
+  ThreadData::ToSerializedProcessData(false, &process_data);
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+  process_data.ToValue(value.get());
+
   std::string json;
   base::JSONWriter::Write(value.get(), &json);
   std::string birth_only_result = "{"
       "\"descendants\":["
       "],"
       "\"list\":["
-      "]"
+      "],"
+      "\"process_id\":" + GetProcessIdString() +
     "}";
-  EXPECT_EQ(json, birth_only_result);
+  EXPECT_EQ(birth_only_result, json);
 }
 
 TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToValueMainThread) {
   // 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));
 
-  scoped_ptr<base::Value> value(ThreadData::ToValue(false));
+  SerializedProcessData process_data;
+  ThreadData::ToSerializedProcessData(false, &process_data);
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+  process_data.ToValue(value.get());
+
   std::string json;
   base::JSONWriter::Write(value.get(), &json);
   std::string birth_only_result = "{"
       "\"descendants\":["
       "],"
       "\"list\":["
-      "]"
+      "],"
+      "\"process_id\":" + GetProcessIdString() +
     "}";
-  EXPECT_EQ(json, birth_only_result);
+  EXPECT_EQ(birth_only_result, json);
 }
 
 TEST_F(TrackedObjectsTest, BirthOnlyToValueWorkerThread) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
       ThreadData::PROFILING_CHILDREN_ACTIVE))
     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));
+  SerializedProcessData process_data;
+  ThreadData::ToSerializedProcessData(false, &process_data);
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+  process_data.ToValue(value.get());
+
   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"
           "}"
         "}"
-      "]"
+      "],"
+      "\"process_id\":" + GetProcessIdString() +
     "}";
-  EXPECT_EQ(json, birth_only_result);
+  EXPECT_EQ(birth_only_result, json);
 }
 
 TEST_F(TrackedObjectsTest, BirthOnlyToValueMainThread) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
       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));
 
-  scoped_ptr<base::Value> value(ThreadData::ToValue(false));
+  SerializedProcessData process_data;
+  ThreadData::ToSerializedProcessData(false, &process_data);
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+  process_data.ToValue(value.get());
+
   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"
           "}"
         "}"
-      "]"
+      "],"
+      "\"process_id\":" + GetProcessIdString() +
     "}";
-  EXPECT_EQ(json, birth_only_result);
+  EXPECT_EQ(birth_only_result, json);
 }
 
 TEST_F(TrackedObjectsTest, LifeCycleToValueMainThread) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
       ThreadData::PROFILING_CHILDREN_ACTIVE))
     return;
 
   // Use a well named thread.
   ThreadData::InitializeThreadContext("SomeMainThreadName");
   const int kFakeLineNumber = 236;
@@ skipping 10 matching lines @@
   // 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));
+  SerializedProcessData process_data;
+  ThreadData::ToSerializedProcessData(false, &process_data);
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+  process_data.ToValue(value.get());
+
   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"
           "}"
         "}"
-      "]"
+      "],"
+      "\"process_id\":" + GetProcessIdString() +
     "}";
   EXPECT_EQ(one_line_result, json);
 }
 
 // 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) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
@@ skipping 20 matching lines @@
   // 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));
+  SerializedProcessData process_data;
+  ThreadData::ToSerializedProcessData(false, &process_data);
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+  process_data.ToValue(value.get());
+
   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"
           "}"
         "}"
-      "]"
+      "],"
+      "\"process_id\":" + GetProcessIdString() +
     "}";
   EXPECT_EQ(one_line_result, json);
 }
 
 // We will deactivate tracking before starting a life cycle, and neither
 // the birth nor the death will be recorded.
 TEST_F(TrackedObjectsTest, LifeCyclePreDeactivatedToValueMainThread) {
   if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED))
     return;
 
@@ skipping 13 matching lines @@
   // 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));
+  SerializedProcessData process_data;
+  ThreadData::ToSerializedProcessData(false, &process_data);
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+  process_data.ToValue(value.get());
+
   std::string json;
   base::JSONWriter::Write(value.get(), &json);
   std::string one_line_result = "{"
       "\"descendants\":["
       "],"
       "\"list\":["
-      "]"
+      "],"
+      "\"process_id\":" + GetProcessIdString() +
     "}";
   EXPECT_EQ(one_line_result, json);
 }
 
 TEST_F(TrackedObjectsTest, LifeCycleToValueWorkerThread) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
       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.
   Births* birth = ThreadData::TallyABirthIfActive(location);
   EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));
 
   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));
+  SerializedProcessData process_data;
+  ThreadData::ToSerializedProcessData(false, &process_data);
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+  process_data.ToValue(value.get());
+
   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"
           "}"
         "}"
-      "]"
+      "],"
+      "\"process_id\":" + GetProcessIdString() +
     "}";
   EXPECT_EQ(one_line_result, json);
 
   // Call for the ToValue, 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);
+  SerializedProcessData process_data_pre_reset;
+  ThreadData::ToSerializedProcessData(true, &process_data_pre_reset);
+  value.reset(new base::DictionaryValue);
+  process_data_pre_reset.ToValue(value.get());
+
+  base::JSONWriter::Write(value.get(), false, &json);
   // Result should be unchanged.
   EXPECT_EQ(one_line_result, json);
 
   // 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);
+  SerializedProcessData process_data_post_reset;
+  ThreadData::ToSerializedProcessData(true, &process_data_post_reset);
+  value.reset(new base::DictionaryValue);
+  process_data_post_reset.ToValue(value.get());
+
+  base::JSONWriter::Write(value.get(), false, &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"
           "}"
         "}"
-      "]"
+      "],"
+      "\"process_id\":" + GetProcessIdString() +
     "}";
   EXPECT_EQ(one_line_result_with_zeros, json);
 }
 
 TEST_F(TrackedObjectsTest, TwoLives) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
       ThreadData::PROFILING_CHILDREN_ACTIVE))
     return;
 
   // Use a well named thread.
@@ skipping 20 matching lines @@
   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));
+  SerializedProcessData process_data;
+  ThreadData::ToSerializedProcessData(false, &process_data);
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+  process_data.ToValue(value.get());
+
   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"
           "}"
         "}"
-      "]"
+      "],"
+      "\"process_id\":" + GetProcessIdString() +
     "}";
   EXPECT_EQ(one_line_result, json);
 }
 
 TEST_F(TrackedObjectsTest, DifferentLives) {
   if (!ThreadData::InitializeAndSetTrackingStatus(
       ThreadData::PROFILING_CHILDREN_ACTIVE))
     return;
 
   // Use a well named thread.
@@ skipping 16 matching lines @@
   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));
+  SerializedProcessData process_data;
+  ThreadData::ToSerializedProcessData(false, &process_data);
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+  process_data.ToValue(value.get());
+
   std::string json;
   base::JSONWriter::Write(value.get(), &json);
   std::string one_line_result = "{"
       "\"descendants\":["
       "],"
       "\"list\":["
         "{"
           "\"birth_thread\":\"SomeFileThreadName\","
           "\"death_data\":{"
             "\"count\":1,"
@@ skipping 22 matching lines @@
             "\"run_ms_max\":0,"
             "\"run_ms_sample\":0"
           "},"
           "\"death_thread\":\"Still_Alive\","
           "\"location\":{"
             "\"file_name\":\"AnotherFileName\","
             "\"function_name\":\"DifferentLives\","
             "\"line_number\":999"
           "}"
         "}"
-      "]"
+      "],"
+      "\"process_id\":" + GetProcessIdString() +
     "}";
   EXPECT_EQ(one_line_result, json);
 }
 
 
 }  // namespace tracked_objects