diff --git a/infra/perfetto.dev/src/assets/style.scss b/infra/perfetto.dev/src/assets/style.scss
index e141890..0d0bbbe 100644
--- a/infra/perfetto.dev/src/assets/style.scss
+++ b/infra/perfetto.dev/src/assets/style.scss
@@ -683,6 +683,9 @@
             tr {
                 height: 20px;
             }
+            tr:target {
+                background-color: #ecba2a;
+            }
             thead {
                 text-align: left;
                 background-color: #e8eaed;
diff --git a/infra/perfetto.dev/src/gen_stats_reference.js b/infra/perfetto.dev/src/gen_stats_reference.js
index 0f7228e..0658d01 100644
--- a/infra/perfetto.dev/src/gen_stats_reference.js
+++ b/infra/perfetto.dev/src/gen_stats_reference.js
@@ -66,13 +66,14 @@
 
 function tableToMarkdown(table) {
   let md = `# Trace Processor Stats\n\n`;
-  md += 'Name | Cardinality | Type | Scope | Description |\n';
-  md += '---- | ----------- | ---- | ----- | ----------- |\n';
+  md += `<table><thead><tr><td>Name</td><td>Cardinality</td><td>Type</td>
+  <td>Scope</td><td>Description</td></tr></thead>\n`;
   for (const col of table) {
-    md += `${col.name} | ${col.cardinality} | ${col.type} | ${col.scope} | ${
-        singleLineComment(col.comment)} |\n`
+    md += `<tr id="${col.name}"><td>${col.name}</td>
+    <td>${col.cardinality}</td><td>${col.type}</td><td>${col.scope}</td>
+    <td>${singleLineComment(col.comment)} </td></tr>\n`
   }
-  md += '\n\n';
+  md += '</table>\n\n';
   return md;
 }
 
diff --git a/src/profiling/memory/heapprofd_end_to_end_test.cc b/src/profiling/memory/heapprofd_end_to_end_test.cc
index 590cdd2..ec024a1 100644
--- a/src/profiling/memory/heapprofd_end_to_end_test.cc
+++ b/src/profiling/memory/heapprofd_end_to_end_test.cc
@@ -59,6 +59,29 @@
 
 constexpr const char* kHeapprofdModeProperty = "heapprofd.userdebug.mode";
 
+void ContinuousDump(HeapprofdConfig* cfg) {
+  auto* cont_config = cfg->mutable_continuous_dump_config();
+  cont_config->set_dump_phase_ms(0);
+  cont_config->set_dump_interval_ms(100);
+}
+
+template <typename F>
+TraceConfig MakeTraceConfig(F fn) {
+  TraceConfig trace_config;
+  trace_config.add_buffers()->set_size_kb(10 * 1024);
+  trace_config.set_duration_ms(2000);
+  trace_config.set_data_source_stop_timeout_ms(10000);
+
+  auto* ds_config = trace_config.add_data_sources()->mutable_config();
+  ds_config->set_name("android.heapprofd");
+  ds_config->set_target_buffer(0);
+
+  protos::gen::HeapprofdConfig heapprofd_config;
+  fn(&heapprofd_config);
+  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
+  return trace_config;
+}
+
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
 
 std::string ReadProperty(const std::string& name, std::string def) {
@@ -359,24 +382,12 @@
   base::Subprocess child = ForkContinuousMalloc(kAllocSize);
   const auto pid = child.pid();
 
-  TraceConfig trace_config;
-  trace_config.add_buffers()->set_size_kb(10 * 1024);
-  trace_config.set_duration_ms(2000);
-  trace_config.set_data_source_stop_timeout_ms(10000);
-
-  auto* ds_config = trace_config.add_data_sources()->mutable_config();
-  ds_config->set_name("android.heapprofd");
-  ds_config->set_target_buffer(0);
-
-  protos::gen::HeapprofdConfig heapprofd_config;
-  heapprofd_config.set_sampling_interval_bytes(1);
-  heapprofd_config.add_pid(static_cast<uint64_t>(pid));
-  heapprofd_config.set_all(false);
-  heapprofd_config.add_heaps("invalid");
-  auto* cont_config = heapprofd_config.mutable_continuous_dump_config();
-  cont_config->set_dump_phase_ms(0);
-  cont_config->set_dump_interval_ms(100);
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
+  TraceConfig trace_config = MakeTraceConfig([pid](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_pid(static_cast<uint64_t>(pid));
+    cfg->add_heaps("invalid");
+    ContinuousDump(cfg);
+  });
 
   auto helper = Trace(trace_config);
   PrintStats(helper.get());
@@ -390,23 +401,11 @@
   base::Subprocess child = ForkContinuousMalloc(kAllocSize);
   const auto pid = child.pid();
 
-  TraceConfig trace_config;
-  trace_config.add_buffers()->set_size_kb(10 * 1024);
-  trace_config.set_duration_ms(2000);
-  trace_config.set_data_source_stop_timeout_ms(10000);
-
-  auto* ds_config = trace_config.add_data_sources()->mutable_config();
-  ds_config->set_name("android.heapprofd");
-  ds_config->set_target_buffer(0);
-
-  protos::gen::HeapprofdConfig heapprofd_config;
-  heapprofd_config.set_sampling_interval_bytes(1);
-  heapprofd_config.add_pid(static_cast<uint64_t>(pid));
-  heapprofd_config.set_all(false);
-  auto* cont_config = heapprofd_config.mutable_continuous_dump_config();
-  cont_config->set_dump_phase_ms(0);
-  cont_config->set_dump_interval_ms(100);
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
+  TraceConfig trace_config = MakeTraceConfig([pid](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_pid(static_cast<uint64_t>(pid));
+    ContinuousDump(cfg);
+  });
 
   auto helper = Trace(trace_config);
   PrintStats(helper.get());
@@ -424,25 +423,13 @@
   base::Subprocess child = ForkContinuousMalloc(kAllocSize, kCustomAllocSize);
   const auto pid = child.pid();
 
-  TraceConfig trace_config;
-  trace_config.add_buffers()->set_size_kb(10 * 1024);
-  trace_config.set_duration_ms(2000);
-  trace_config.set_data_source_stop_timeout_ms(10000);
-
-  auto* ds_config = trace_config.add_data_sources()->mutable_config();
-  ds_config->set_name("android.heapprofd");
-  ds_config->set_target_buffer(0);
-
-  protos::gen::HeapprofdConfig heapprofd_config;
-  heapprofd_config.set_sampling_interval_bytes(1);
-  heapprofd_config.add_pid(static_cast<uint64_t>(pid));
-  heapprofd_config.set_all(false);
-  heapprofd_config.add_heaps("test");
-  heapprofd_config.add_heaps("malloc");
-  auto* cont_config = heapprofd_config.mutable_continuous_dump_config();
-  cont_config->set_dump_phase_ms(0);
-  cont_config->set_dump_interval_ms(100);
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
+  TraceConfig trace_config = MakeTraceConfig([pid](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_pid(static_cast<uint64_t>(pid));
+    cfg->add_heaps("test");
+    cfg->add_heaps("malloc");
+    ContinuousDump(cfg);
+  });
 
   auto helper = Trace(trace_config);
   PrintStats(helper.get());
@@ -487,21 +474,11 @@
   child.Start();
   const auto pid = child.pid();
 
-  TraceConfig trace_config;
-  trace_config.add_buffers()->set_size_kb(10 * 1024);
-  trace_config.set_duration_ms(2000);
-  trace_config.set_data_source_stop_timeout_ms(10000);
-
-  auto* ds_config = trace_config.add_data_sources()->mutable_config();
-  ds_config->set_name("android.heapprofd");
-  ds_config->set_target_buffer(0);
-
-  protos::gen::HeapprofdConfig heapprofd_config;
-  heapprofd_config.set_sampling_interval_bytes(1);
-  heapprofd_config.add_pid(static_cast<uint64_t>(pid));
-  heapprofd_config.set_all(false);
-  heapprofd_config.add_heaps("test");
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
+  TraceConfig trace_config = MakeTraceConfig([pid](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_pid(static_cast<uint64_t>(pid));
+    cfg->add_heaps("test");
+  });
 
   auto helper = Trace(trace_config);
   PrintStats(helper.get());
@@ -528,24 +505,12 @@
   base::Subprocess child = ForkContinuousMalloc(0, kAllocSize);
   const auto pid = child.pid();
 
-  TraceConfig trace_config;
-  trace_config.add_buffers()->set_size_kb(10 * 1024);
-  trace_config.set_duration_ms(2000);
-  trace_config.set_data_source_stop_timeout_ms(10000);
-
-  auto* ds_config = trace_config.add_data_sources()->mutable_config();
-  ds_config->set_name("android.heapprofd");
-  ds_config->set_target_buffer(0);
-
-  protos::gen::HeapprofdConfig heapprofd_config;
-  heapprofd_config.set_sampling_interval_bytes(1);
-  heapprofd_config.add_pid(static_cast<uint64_t>(pid));
-  heapprofd_config.set_all(false);
-  heapprofd_config.add_heaps("test");
-  auto* cont_config = heapprofd_config.mutable_continuous_dump_config();
-  cont_config->set_dump_phase_ms(0);
-  cont_config->set_dump_interval_ms(100);
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
+  TraceConfig trace_config = MakeTraceConfig([pid](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_pid(static_cast<uint64_t>(pid));
+    cfg->add_heaps("test");
+    ContinuousDump(cfg);
+  });
 
   auto helper = Trace(trace_config);
   PrintStats(helper.get());
@@ -561,24 +526,11 @@
 
   base::Subprocess child = ForkContinuousMalloc(0, kAllocSize);
   const auto pid = child.pid();
-
-  TraceConfig trace_config;
-  trace_config.add_buffers()->set_size_kb(10 * 1024);
-  trace_config.set_duration_ms(2000);
-  trace_config.set_data_source_stop_timeout_ms(10000);
-
-  auto* ds_config = trace_config.add_data_sources()->mutable_config();
-  ds_config->set_name("android.heapprofd");
-  ds_config->set_target_buffer(0);
-
-  protos::gen::HeapprofdConfig heapprofd_config;
-  heapprofd_config.set_sampling_interval_bytes(1);
-  heapprofd_config.add_pid(static_cast<uint64_t>(pid));
-  heapprofd_config.set_all(false);
-  auto* cont_config = heapprofd_config.mutable_continuous_dump_config();
-  cont_config->set_dump_phase_ms(0);
-  cont_config->set_dump_interval_ms(100);
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
+  TraceConfig trace_config = MakeTraceConfig([pid](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_pid(static_cast<uint64_t>(pid));
+    ContinuousDump(cfg);
+  });
 
   auto helper = Trace(trace_config);
   PrintStats(helper.get());
@@ -596,21 +548,11 @@
   const auto pid = child.pid();
   const auto pid2 = child2.pid();
 
-  TraceConfig trace_config;
-  trace_config.add_buffers()->set_size_kb(10 * 1024);
-  trace_config.set_duration_ms(2000);
-  trace_config.set_data_source_stop_timeout_ms(10000);
-
-  auto* ds_config = trace_config.add_data_sources()->mutable_config();
-  ds_config->set_name("android.heapprofd");
-  ds_config->set_target_buffer(0);
-
-  protos::gen::HeapprofdConfig heapprofd_config;
-  heapprofd_config.set_sampling_interval_bytes(1);
-  heapprofd_config.add_pid(static_cast<uint64_t>(pid));
-  heapprofd_config.add_pid(static_cast<uint64_t>(pid2));
-  heapprofd_config.set_all(false);
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
+  TraceConfig trace_config = MakeTraceConfig([pid, pid2](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_pid(static_cast<uint64_t>(pid));
+    cfg->add_pid(static_cast<uint64_t>(pid2));
+  });
 
   auto helper = Trace(trace_config);
   PrintStats(helper.get());
@@ -628,21 +570,10 @@
 
   base::Subprocess child = ForkContinuousMalloc(kAllocSize);
   const auto pid = child.pid();
-
-  TraceConfig trace_config;
-  trace_config.add_buffers()->set_size_kb(10 * 1024);
-  trace_config.set_duration_ms(2000);
-  trace_config.set_data_source_stop_timeout_ms(10000);
-
-  auto* ds_config = trace_config.add_data_sources()->mutable_config();
-  ds_config->set_name("android.heapprofd");
-  ds_config->set_target_buffer(0);
-
-  protos::gen::HeapprofdConfig heapprofd_config;
-  heapprofd_config.set_sampling_interval_bytes(1);
-  heapprofd_config.add_pid(static_cast<uint64_t>(pid));
-  heapprofd_config.set_all(false);
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
+  TraceConfig trace_config = MakeTraceConfig([pid](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_pid(static_cast<uint64_t>(pid));
+  });
 
   auto helper = Trace(trace_config);
   PrintStats(helper.get());
@@ -656,19 +587,12 @@
 TEST_P(HeapprofdEndToEnd, NativeStartup) {
   auto helper = GetHelper(&task_runner);
 
-  TraceConfig trace_config;
-  trace_config.add_buffers()->set_size_kb(10 * 1024);
+  TraceConfig trace_config = MakeTraceConfig([](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_process_cmdline("heapprofd_continuous_malloc");
+    cfg->set_all(false);
+  });
   trace_config.set_duration_ms(5000);
-  trace_config.set_data_source_stop_timeout_ms(10000);
-
-  auto* ds_config = trace_config.add_data_sources()->mutable_config();
-  ds_config->set_name("android.heapprofd");
-
-  protos::gen::HeapprofdConfig heapprofd_config;
-  heapprofd_config.set_sampling_interval_bytes(1);
-  heapprofd_config.add_process_cmdline("heapprofd_continuous_malloc");
-  heapprofd_config.set_all(false);
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
 
   helper->StartTracing(trace_config);
 
@@ -723,19 +647,12 @@
 TEST_P(HeapprofdEndToEnd, NativeStartupDenormalizedCmdline) {
   auto helper = GetHelper(&task_runner);
 
-  TraceConfig trace_config;
-  trace_config.add_buffers()->set_size_kb(10 * 1024);
+  TraceConfig trace_config = MakeTraceConfig([](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_process_cmdline("heapprofd_continuous_malloc@1.2.3");
+    cfg->set_all(false);
+  });
   trace_config.set_duration_ms(5000);
-  trace_config.set_data_source_stop_timeout_ms(10000);
-
-  auto* ds_config = trace_config.add_data_sources()->mutable_config();
-  ds_config->set_name("android.heapprofd");
-
-  protos::gen::HeapprofdConfig heapprofd_config;
-  heapprofd_config.set_sampling_interval_bytes(1);
-  heapprofd_config.add_process_cmdline("heapprofd_continuous_malloc@1.2.3");
-  heapprofd_config.set_all(false);
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
 
   helper->StartTracing(trace_config);
 
@@ -790,20 +707,6 @@
 TEST_P(HeapprofdEndToEnd, DiscoverByName) {
   auto helper = GetHelper(&task_runner);
 
-  TraceConfig trace_config;
-  trace_config.add_buffers()->set_size_kb(10 * 1024);
-  trace_config.set_duration_ms(5000);
-  trace_config.set_data_source_stop_timeout_ms(10000);
-
-  auto* ds_config = trace_config.add_data_sources()->mutable_config();
-  ds_config->set_name("android.heapprofd");
-
-  protos::gen::HeapprofdConfig heapprofd_config;
-  heapprofd_config.set_sampling_interval_bytes(1);
-  heapprofd_config.add_process_cmdline("heapprofd_continuous_malloc");
-  heapprofd_config.set_all(false);
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
-
   base::Subprocess child({"/proc/self/exe"});
   child.args.argv0_override = "heapprofd_continuous_malloc";
   child.args.stdout_mode = base::Subprocess::kDevNull;
@@ -815,6 +718,13 @@
   // match it by the startup logic.
   sleep(1);
 
+  TraceConfig trace_config = MakeTraceConfig([](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_process_cmdline("heapprofd_continuous_malloc");
+    cfg->set_all(false);
+  });
+  trace_config.set_duration_ms(5000);
+
   helper->StartTracing(trace_config);
   helper->WaitForTracingDisabled(kTracingDisabledTimeoutMs);
 
@@ -853,20 +763,6 @@
 TEST_P(HeapprofdEndToEnd, DiscoverByNameDenormalizedCmdline) {
   auto helper = GetHelper(&task_runner);
 
-  TraceConfig trace_config;
-  trace_config.add_buffers()->set_size_kb(10 * 1024);
-  trace_config.set_duration_ms(5000);
-  trace_config.set_data_source_stop_timeout_ms(10000);
-
-  auto* ds_config = trace_config.add_data_sources()->mutable_config();
-  ds_config->set_name("android.heapprofd");
-
-  protos::gen::HeapprofdConfig heapprofd_config;
-  heapprofd_config.set_sampling_interval_bytes(1);
-  heapprofd_config.add_process_cmdline("heapprofd_continuous_malloc@1.2.3");
-  heapprofd_config.set_all(false);
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
-
   // Make sure the forked process does not get reparented to init.
   base::Subprocess child({"/proc/self/exe"});
   child.args.argv0_override = "heapprofd_continuous_malloc";
@@ -879,6 +775,13 @@
   // match it by the startup logic.
   sleep(1);
 
+  TraceConfig trace_config = MakeTraceConfig([](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_process_cmdline("heapprofd_continuous_malloc@1.2.3");
+    cfg->set_all(false);
+  });
+  trace_config.set_duration_ms(5000);
+
   helper->StartTracing(trace_config);
   helper->WaitForTracingDisabled(kTracingDisabledTimeoutMs);
 
@@ -954,20 +857,10 @@
   signal_pipe.rd.reset();
   ack_pipe.wr.reset();
 
-  TraceConfig trace_config;
-  trace_config.add_buffers()->set_size_kb(10 * 1024);
-  trace_config.set_duration_ms(2000);
-  trace_config.set_data_source_stop_timeout_ms(10000);
-
-  auto* ds_config = trace_config.add_data_sources()->mutable_config();
-  ds_config->set_name("android.heapprofd");
-  ds_config->set_target_buffer(0);
-
-  protos::gen::HeapprofdConfig heapprofd_config;
-  heapprofd_config.set_sampling_interval_bytes(1);
-  heapprofd_config.add_pid(static_cast<uint64_t>(pid));
-  heapprofd_config.set_all(false);
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
+  TraceConfig trace_config = MakeTraceConfig([pid](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_pid(static_cast<uint64_t>(pid));
+  });
 
   auto helper = Trace(trace_config);
   PrintStats(helper.get());
@@ -1036,22 +929,11 @@
 
   signal_pipe.rd.reset();
   ack_pipe.wr.reset();
-
-  TraceConfig trace_config;
-  trace_config.add_buffers()->set_size_kb(10 * 1024);
-  trace_config.set_duration_ms(2000);
-  trace_config.set_data_source_stop_timeout_ms(10000);
-
-  auto* ds_config = trace_config.add_data_sources()->mutable_config();
-  ds_config->set_name("android.heapprofd");
-  ds_config->set_target_buffer(0);
-
-  protos::gen::HeapprofdConfig heapprofd_config;
-  heapprofd_config.set_sampling_interval_bytes(1);
-  heapprofd_config.add_pid(static_cast<uint64_t>(pid));
-  heapprofd_config.set_all(false);
-  heapprofd_config.add_heaps("invalid");
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
+  TraceConfig trace_config = MakeTraceConfig([pid](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_pid(static_cast<uint64_t>(pid));
+    cfg->add_heaps("invalid");
+  });
 
   auto helper = Trace(trace_config);
   PrintStats(helper.get());
@@ -1067,8 +949,10 @@
   // to be torn down (as it rejects concurrent sessions).
   usleep(500 * kMsToUs);
 
-  heapprofd_config.add_heaps("malloc");
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
+  trace_config = MakeTraceConfig([pid](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_pid(static_cast<uint64_t>(pid));
+  });
 
   PERFETTO_LOG("HeapprofdEndToEnd::ReinitAfterInvalid: Starting second");
   helper = Trace(trace_config);
@@ -1087,23 +971,12 @@
   base::Subprocess child = ForkContinuousMalloc(kAllocSize);
   const auto pid = child.pid();
 
-  TraceConfig trace_config;
-  trace_config.add_buffers()->set_size_kb(10 * 1024);
+  TraceConfig trace_config = MakeTraceConfig([pid](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_pid(static_cast<uint64_t>(pid));
+    ContinuousDump(cfg);
+  });
   trace_config.set_duration_ms(5000);
-  trace_config.set_data_source_stop_timeout_ms(10000);
-
-  auto* ds_config = trace_config.add_data_sources()->mutable_config();
-  ds_config->set_name("android.heapprofd");
-  ds_config->set_target_buffer(0);
-
-  protos::gen::HeapprofdConfig heapprofd_config;
-  heapprofd_config.set_sampling_interval_bytes(1);
-  heapprofd_config.add_pid(static_cast<uint64_t>(pid));
-  heapprofd_config.set_all(false);
-  auto* cont_config = heapprofd_config.mutable_continuous_dump_config();
-  cont_config->set_dump_phase_ms(0);
-  cont_config->set_dump_interval_ms(100);
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
 
   auto helper = GetHelper(&task_runner);
   helper->StartTracing(trace_config);
@@ -1159,24 +1032,18 @@
 
   // Construct tracing config (without starting profiling).
   auto helper = GetHelper(&task_runner);
-  TraceConfig trace_config;
-  trace_config.add_buffers()->set_size_kb(10 * 1024);
-  trace_config.set_duration_ms(5000);
-  trace_config.set_data_source_stop_timeout_ms(10000);
-
-  auto* ds_config = trace_config.add_data_sources()->mutable_config();
-  ds_config->set_name("android.heapprofd");
-
-  protos::gen::HeapprofdConfig heapprofd_config;
-  heapprofd_config.set_sampling_interval_bytes(1);
-  heapprofd_config.add_pid(static_cast<uint64_t>(pid));
-  ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
 
   // Wait for child to have been scheduled at least once.
   char buf[1] = {};
   ASSERT_EQ(PERFETTO_EINTR(read(*start_pipe.rd, buf, sizeof(buf))), 1);
   start_pipe.rd.reset();
 
+  TraceConfig trace_config = MakeTraceConfig([pid](HeapprofdConfig* cfg) {
+    cfg->set_sampling_interval_bytes(1);
+    cfg->add_pid(static_cast<uint64_t>(pid));
+  });
+  trace_config.set_duration_ms(5000);
+
   // Trace until child exits.
   helper->StartTracing(trace_config);
 
