Add memory UKMs for existing UMA metrics.

Bug: 730783, 728707
Change-Id: I744c73d36ca76d97eff1e202fa20ba5d4a9adb7b
Reviewed-on: https://chromium-review.googlesource.com/531804
Commit-Queue: Jao-ke Chin-Lee <jchinlee@chromium.org>
Reviewed-by: Robert Kaplow <rkaplow@chromium.org>
Reviewed-by: Erik Chen <erikchen@chromium.org>
Cr-Commit-Position: refs/heads/master@{#485159}

chrome/browser/metrics/process_memory_metrics_emitter.cc

@@ -8,6 +8,8 @@
 #include "base/trace_event/memory_dump_request_args.h"
 #include "content/public/common/service_manager_connection.h"
 #include "content/public/common/service_names.mojom.h"
+#include "services/metrics/public/cpp/ukm_entry_builder.h"
+#include "services/metrics/public/cpp/ukm_recorder.h"
 #include "services/service_manager/public/cpp/connector.h"
 
 using ProcessMemoryDumpPtr =
@@ -15,44 +17,87 @@ using ProcessMemoryDumpPtr =
 
 namespace {
 
-void EmitBrowserMemoryMetrics(const ProcessMemoryDumpPtr& pmd) {
+void EmitBrowserMemoryMetrics(const ProcessMemoryDumpPtr& pmd,
+                              ukm::UkmEntryBuilder* builder) {
+  builder->AddMetric("ProcessType",
+                     static_cast<int64_t>(
+                         memory_instrumentation::mojom::ProcessType::BROWSER));
+
   UMA_HISTOGRAM_MEMORY_LARGE_MB("Memory.Experimental.Browser2.Resident",
                                 pmd->os_dump->resident_set_kb / 1024);
+  builder->AddMetric("Resident", pmd->os_dump->resident_set_kb / 1024);
+
   UMA_HISTOGRAM_MEMORY_LARGE_MB("Memory.Experimental.Browser2.Malloc",
                                 pmd->chrome_dump.malloc_total_kb / 1024);
+  builder->AddMetric("Malloc", pmd->chrome_dump.malloc_total_kb / 1024);
+
   UMA_HISTOGRAM_MEMORY_LARGE_MB(
       "Memory.Experimental.Browser2.PrivateMemoryFootprint",
       pmd->os_dump->private_footprint_kb / 1024);
+  builder->AddMetric("PrivateMemoryFootprint",
+                     pmd->os_dump->private_footprint_kb / 1024);
 }
 
-void EmitRendererMemoryMetrics(const ProcessMemoryDumpPtr& pmd) {
+void EmitRendererMemoryMetrics(const ProcessMemoryDumpPtr& pmd,
+                               ukm::UkmEntryBuilder* builder) {
+  builder->AddMetric("ProcessType",
+                     static_cast<int64_t>(
+                         memory_instrumentation::mojom::ProcessType::RENDERER));
+
   UMA_HISTOGRAM_MEMORY_LARGE_MB("Memory.Experimental.Renderer2.Resident",
                                 pmd->os_dump->resident_set_kb / 1024);
+  builder->AddMetric("Resident", pmd->os_dump->resident_set_kb / 1024);
+
+  UMA_HISTOGRAM_MEMORY_LARGE_MB("Memory.Experimental.Renderer2.Malloc",
+                                pmd->chrome_dump.malloc_total_kb / 1024);
+  builder->AddMetric("Malloc", pmd->chrome_dump.malloc_total_kb / 1024);
+
   UMA_HISTOGRAM_MEMORY_LARGE_MB(
       "Memory.Experimental.Renderer2.PrivateMemoryFootprint",
       pmd->os_dump->private_footprint_kb / 1024);
-  UMA_HISTOGRAM_MEMORY_LARGE_MB("Memory.Experimental.Renderer2.Malloc",
-                                pmd->chrome_dump.malloc_total_kb / 1024);
+  builder->AddMetric("PrivateMemoryFootprint",
+                     pmd->os_dump->private_footprint_kb / 1024);
+
   UMA_HISTOGRAM_MEMORY_LARGE_MB(
       "Memory.Experimental.Renderer2.PartitionAlloc",
       pmd->chrome_dump.partition_alloc_total_kb / 1024);
+  builder->AddMetric("PartitionAlloc",
+                     pmd->chrome_dump.partition_alloc_total_kb / 1024);
+
   UMA_HISTOGRAM_MEMORY_LARGE_MB("Memory.Experimental.Renderer2.BlinkGC",
                                 pmd->chrome_dump.blink_gc_total_kb / 1024);
+  builder->AddMetric("BlinkGC", pmd->chrome_dump.blink_gc_total_kb / 1024);
+
   UMA_HISTOGRAM_MEMORY_LARGE_MB("Memory.Experimental.Renderer2.V8",
                                 pmd->chrome_dump.v8_total_kb / 1024);
+  builder->AddMetric("V8", pmd->chrome_dump.v8_total_kb / 1024);
 }
 
-void EmitGpuMemoryMetrics(const ProcessMemoryDumpPtr& pmd) {
+void EmitGpuMemoryMetrics(const ProcessMemoryDumpPtr& pmd,
+                          ukm::UkmEntryBuilder* builder) {
+  builder->AddMetric(
+      "ProcessType",
+      static_cast<int64_t>(memory_instrumentation::mojom::ProcessType::GPU));
+
   UMA_HISTOGRAM_MEMORY_LARGE_MB("Memory.Experimental.Gpu2.Resident",
                                 pmd->os_dump->resident_set_kb / 1024);
+  builder->AddMetric("Resident", pmd->os_dump->resident_set_kb / 1024);
+
   UMA_HISTOGRAM_MEMORY_LARGE_MB("Memory.Experimental.Gpu2.Malloc",
                                 pmd->chrome_dump.malloc_total_kb / 1024);
+  builder->AddMetric("Malloc", pmd->chrome_dump.malloc_total_kb / 1024);
+
   UMA_HISTOGRAM_MEMORY_LARGE_MB(
       "Memory.Experimental.Gpu2.CommandBuffer",
       pmd->chrome_dump.command_buffer_total_kb / 1024);
+  builder->AddMetric("CommandBuffer",
+                     pmd->chrome_dump.command_buffer_total_kb / 1024);
+
   UMA_HISTOGRAM_MEMORY_LARGE_MB(
       "Memory.Experimental.Gpu2.PrivateMemoryFootprint",
       pmd->os_dump->private_footprint_kb / 1024);
+  builder->AddMetric("PrivateMemoryFootprint",
+                     pmd->os_dump->private_footprint_kb / 1024);
 }
 
 }  // namespace
@@ -77,6 +122,16 @@ void ProcessMemoryMetricsEmitter::FetchAndEmitProcessMemoryMetrics() {
 
 ProcessMemoryMetricsEmitter::~ProcessMemoryMetricsEmitter() {}
 
+std::unique_ptr<ukm::UkmEntryBuilder>
+ProcessMemoryMetricsEmitter::CreateUkmBuilder(const char* event_name) {
+  ukm::UkmRecorder* ukm_recorder = ukm::UkmRecorder::Get();
+  if (!ukm_recorder)
+    return nullptr;
+
+  const int32_t source_id = ukm_recorder->GetNewSourceID();
+  return ukm_recorder->GetEntryBuilder(source_id, event_name);
+}
+
 void ProcessMemoryMetricsEmitter::ReceivedMemoryDump(
     bool success,
     uint64_t dump_guid,
@@ -89,15 +144,23 @@ void ProcessMemoryMetricsEmitter::ReceivedMemoryDump(
   uint32_t private_footprint_total_kb = 0;
   for (const ProcessMemoryDumpPtr& pmd : ptr->process_dumps) {
     private_footprint_total_kb += pmd->os_dump->private_footprint_kb;
+
+    // Populate a new entry for each ProcessMemoryDumpPtr in the global dump,
+    // annotating each entry with the dump GUID so that entries in the same
+    // global dump can be correlated with each other.
+    // TODO(jchinlee): Add URLs.
+    std::unique_ptr<ukm::UkmEntryBuilder> builder =
+        CreateUkmBuilder("Memory.Experimental");
+
     switch (pmd->process_type) {
       case memory_instrumentation::mojom::ProcessType::BROWSER:
-        EmitBrowserMemoryMetrics(pmd);
+        EmitBrowserMemoryMetrics(pmd, builder.get());
         break;
       case memory_instrumentation::mojom::ProcessType::RENDERER:
-        EmitRendererMemoryMetrics(pmd);
+        EmitRendererMemoryMetrics(pmd, builder.get());
         break;
       case memory_instrumentation::mojom::ProcessType::GPU:
-        EmitGpuMemoryMetrics(pmd);
+        EmitGpuMemoryMetrics(pmd, builder.get());
         break;
       case memory_instrumentation::mojom::ProcessType::UTILITY:
       case memory_instrumentation::mojom::ProcessType::PLUGIN:
@@ -108,4 +171,9 @@ void ProcessMemoryMetricsEmitter::ReceivedMemoryDump(
   UMA_HISTOGRAM_MEMORY_LARGE_MB(
       "Memory.Experimental.Total2.PrivateMemoryFootprint",
       private_footprint_total_kb / 1024);
+
+  std::unique_ptr<ukm::UkmEntryBuilder> builder =
+      CreateUkmBuilder("Memory.Experimental");
+  builder->AddMetric("Total2.PrivateMemoryFootprint",
+                     private_footprint_total_kb / 1024);
 }

chrome/browser/metrics/process_memory_metrics_emitter.h

@@ -8,6 +8,10 @@
 #include "base/memory/ref_counted.h"
 #include "services/resource_coordinator/public/interfaces/memory_instrumentation/memory_instrumentation.mojom.h"
 
+namespace ukm {
+class UkmEntryBuilder;
+}
+
 // This class asynchronously fetches memory metrics for each process, and then
 // emits UMA metrics from those metrics.
 // Each instance is self-owned, and will delete itself once it has finished
@@ -35,6 +39,9 @@ class ProcessMemoryMetricsEmitter
  private:
   friend class base::RefCountedThreadSafe<ProcessMemoryMetricsEmitter>;
 
+  std::unique_ptr<ukm::UkmEntryBuilder> CreateUkmBuilder(
+      const char* event_name);
+
   memory_instrumentation::mojom::CoordinatorPtr coordinator_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessMemoryMetricsEmitter);

chrome/browser/metrics/process_memory_metrics_emitter_unittest.cc

+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/metrics/process_memory_metrics_emitter.h"
+
+#include "base/containers/flat_map.h"
+#include "base/memory/ref_counted.h"
+#include "components/ukm/test_ukm_recorder.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using GlobalMemoryDumpPtr = memory_instrumentation::mojom::GlobalMemoryDumpPtr;
+using ProcessMemoryDumpPtr =
+    memory_instrumentation::mojom::ProcessMemoryDumpPtr;
+using OSMemDumpPtr = memory_instrumentation::mojom::OSMemDumpPtr;
+using ProcessType = memory_instrumentation::mojom::ProcessType;
+
+namespace {
+
+// Provide fake to surface ReceivedMemoryDump to public visibility.
+class ProcessMemoryMetricsEmitterFake : public ProcessMemoryMetricsEmitter {
+ public:
+  ProcessMemoryMetricsEmitterFake() {}
+
+  void ReceivedMemoryDump(
+      bool success,
+      uint64_t dump_guid,
+      memory_instrumentation::mojom::GlobalMemoryDumpPtr ptr) override {
+    ProcessMemoryMetricsEmitter::ReceivedMemoryDump(success, dump_guid,
+                                                    std::move(ptr));
+  }
+
+ private:
+  ~ProcessMemoryMetricsEmitterFake() override {}
+
+  DISALLOW_COPY_AND_ASSIGN(ProcessMemoryMetricsEmitterFake);
+};
+
+void PopulateBrowserMetrics(GlobalMemoryDumpPtr& global_dump,
+                            base::flat_map<const char*, int64_t>& metrics_mb) {
+  ProcessMemoryDumpPtr pmd(
+      memory_instrumentation::mojom::ProcessMemoryDump::New());
+  pmd->process_type = ProcessType::BROWSER;
+  pmd->chrome_dump.malloc_total_kb = metrics_mb["Malloc"] * 1024;
+  OSMemDumpPtr os_dump(memory_instrumentation::mojom::OSMemDump::New(
+      metrics_mb["Resident"] * 1024,
+      metrics_mb["PrivateMemoryFootprint"] * 1024));
+  pmd->os_dump = std::move(os_dump);
+  global_dump->process_dumps.push_back(std::move(pmd));
+}
+
+base::flat_map<const char*, int64_t> GetExpectedBrowserMetrics() {
+  return base::flat_map<const char*, int64_t>(
+      {
+          {"ProcessType", static_cast<int64_t>(ProcessType::BROWSER)},
+          {"Resident", 10},
+          {"Malloc", 20},
+          {"PrivateMemoryFootprint", 30},
+      },
+      base::KEEP_FIRST_OF_DUPES);
+}
+
+void PopulateRendererMetrics(GlobalMemoryDumpPtr& global_dump,
+                             base::flat_map<const char*, int64_t>& metrics_mb) {
+  ProcessMemoryDumpPtr pmd(
+      memory_instrumentation::mojom::ProcessMemoryDump::New());
+  pmd->process_type = ProcessType::RENDERER;
+  pmd->chrome_dump.malloc_total_kb = metrics_mb["Malloc"] * 1024;
+  pmd->chrome_dump.partition_alloc_total_kb =
+      metrics_mb["PartitionAlloc"] * 1024;
+  pmd->chrome_dump.blink_gc_total_kb = metrics_mb["BlinkGC"] * 1024;
+  pmd->chrome_dump.v8_total_kb = metrics_mb["V8"] * 1024;
+  OSMemDumpPtr os_dump(memory_instrumentation::mojom::OSMemDump::New(
+      metrics_mb["Resident"] * 1024,
+      metrics_mb["PrivateMemoryFootprint"] * 1024));
+  pmd->os_dump = std::move(os_dump);
+  global_dump->process_dumps.push_back(std::move(pmd));
+}
+
+base::flat_map<const char*, int64_t> GetExpectedRendererMetrics() {
+  return base::flat_map<const char*, int64_t>(
+      {
+          {"ProcessType", static_cast<int64_t>(ProcessType::RENDERER)},
+          {"Resident", 110},
+          {"Malloc", 120},
+          {"PrivateMemoryFootprint", 130},
+          {"PartitionAlloc", 140},
+          {"BlinkGC", 150},
+          {"V8", 160},
+      },
+      base::KEEP_FIRST_OF_DUPES);
+}
+
+void PopulateGpuMetrics(GlobalMemoryDumpPtr& global_dump,
+                        base::flat_map<const char*, int64_t>& metrics_mb) {
+  ProcessMemoryDumpPtr pmd(
+      memory_instrumentation::mojom::ProcessMemoryDump::New());
+  pmd->process_type = ProcessType::GPU;
+  pmd->chrome_dump.malloc_total_kb = metrics_mb["Malloc"] * 1024;
+  pmd->chrome_dump.command_buffer_total_kb = metrics_mb["CommandBuffer"] * 1024;
+  OSMemDumpPtr os_dump(memory_instrumentation::mojom::OSMemDump::New(
+      metrics_mb["Resident"] * 1024,
+      metrics_mb["PrivateMemoryFootprint"] * 1024));
+  pmd->os_dump = std::move(os_dump);
+  global_dump->process_dumps.push_back(std::move(pmd));
+}
+
+base::flat_map<const char*, int64_t> GetExpectedGpuMetrics() {
+  return base::flat_map<const char*, int64_t>(
+      {
+          {"ProcessType", static_cast<int64_t>(ProcessType::GPU)},
+          {"Resident", 210},
+          {"Malloc", 220},
+          {"PrivateMemoryFootprint", 230},
+          {"CommandBuffer", 240},
+      },
+      base::KEEP_FIRST_OF_DUPES);
+}
+
+void PopulateMetrics(GlobalMemoryDumpPtr& global_dump,
+                     ProcessType ptype,
+                     base::flat_map<const char*, int64_t>& metrics_mb) {
+  switch (ptype) {
+    case ProcessType::BROWSER:
+      PopulateBrowserMetrics(global_dump, metrics_mb);
+      return;
+    case ProcessType::RENDERER:
+      PopulateRendererMetrics(global_dump, metrics_mb);
+      return;
+    case ProcessType::GPU:
+      PopulateGpuMetrics(global_dump, metrics_mb);
+      return;
+    case ProcessType::UTILITY:
+    case ProcessType::PLUGIN:
+    case ProcessType::OTHER:
+      break;
+  }
+
+  // We shouldn't reach here.
+  FAIL() << "Unknown process type case " << ptype << ".";
+}
+
+base::flat_map<const char*, int64_t> GetExpectedProcessMetrics(
+    ProcessType ptype) {
+  switch (ptype) {
+    case ProcessType::BROWSER:
+      return GetExpectedBrowserMetrics();
+    case ProcessType::RENDERER:
+      return GetExpectedRendererMetrics();
+    case ProcessType::GPU:
+      return GetExpectedGpuMetrics();
+    case ProcessType::UTILITY:
+    case ProcessType::PLUGIN:
+    case ProcessType::OTHER:
+      break;
+  }
+
+  // We shouldn't reach here.
+  CHECK(false);
+  return base::flat_map<const char*, int64_t>();
+}
+
+}  // namespace
+
+class ProcessMemoryMetricsEmitterTest
+    : public testing::TestWithParam<ProcessType> {
+ public:
+  ProcessMemoryMetricsEmitterTest() {}
+  ~ProcessMemoryMetricsEmitterTest() override {}
+
+ protected:
+  void CheckMemoryUkmEntryMetrics(
+      size_t entry_num,
+      base::flat_map<const char*, int64_t> expected) {
+    const ukm::mojom::UkmEntry* entry = test_ukm_recorder_.GetEntry(entry_num);
+    CHECK(entry != nullptr);
+    EXPECT_EQ(expected.size(), entry->metrics.size());
+    for (auto it = expected.begin(); it != expected.end(); ++it) {
+      const ukm::mojom::UkmMetric* actual =
+          test_ukm_recorder_.FindMetric(entry, it->first);
+      CHECK(actual != nullptr);
+      EXPECT_EQ(it->second, actual->value);
+    }
+  }
+
+  ukm::TestUkmRecorder test_ukm_recorder_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ProcessMemoryMetricsEmitterTest);
+};
+
+TEST_P(ProcessMemoryMetricsEmitterTest, CollectsSingleProcessUKMs) {
+  base::flat_map<const char*, int64_t> expected_metrics =
+      GetExpectedProcessMetrics(GetParam());
+  uint64_t dump_guid = 333;
+
+  GlobalMemoryDumpPtr global_dump(
+      memory_instrumentation::mojom::GlobalMemoryDump::New());
+  PopulateMetrics(global_dump, GetParam(), expected_metrics);
+
+  scoped_refptr<ProcessMemoryMetricsEmitterFake> emitter(
+      new ProcessMemoryMetricsEmitterFake());
+  emitter->ReceivedMemoryDump(true, dump_guid, std::move(global_dump));
+
+  EXPECT_EQ(2u, test_ukm_recorder_.entries_count());
+  CheckMemoryUkmEntryMetrics(0, expected_metrics);
+}
+
+INSTANTIATE_TEST_CASE_P(SinglePtype,
+                        ProcessMemoryMetricsEmitterTest,
+                        testing::Values(ProcessType::BROWSER,
+                                        ProcessType::RENDERER,
+                                        ProcessType::GPU));
+
+TEST_F(ProcessMemoryMetricsEmitterTest, CollectsManyProcessUKMsSingleDump) {
+  std::vector<ProcessType> entries_ptypes = {
+      ProcessType::BROWSER, ProcessType::RENDERER, ProcessType::GPU,
+      ProcessType::GPU,     ProcessType::RENDERER, ProcessType::BROWSER,
+  };
+  uint64_t dump_guid = 333;
+
+  GlobalMemoryDumpPtr global_dump(
+      memory_instrumentation::mojom::GlobalMemoryDump::New());
+  std::vector<base::flat_map<const char*, int64_t>> entries_metrics;
+  for (const auto& ptype : entries_ptypes) {
+    auto expected_metrics = GetExpectedProcessMetrics(ptype);
+    PopulateMetrics(global_dump, ptype, expected_metrics);
+    entries_metrics.push_back(expected_metrics);
+  }
+
+  scoped_refptr<ProcessMemoryMetricsEmitterFake> emitter(
+      new ProcessMemoryMetricsEmitterFake());
+  emitter->ReceivedMemoryDump(true, dump_guid, std::move(global_dump));
+
+  EXPECT_EQ(7u, test_ukm_recorder_.entries_count());
+  for (size_t i = 0; i < entries_ptypes.size(); ++i) {
+    CheckMemoryUkmEntryMetrics(i, entries_metrics[i]);
+  }
+}
+
+TEST_F(ProcessMemoryMetricsEmitterTest, CollectsManyProcessUKMsManyDumps) {
+  std::vector<std::vector<ProcessType>> entries_ptypes = {
+      {ProcessType::BROWSER, ProcessType::RENDERER, ProcessType::GPU},
+      {ProcessType::GPU, ProcessType::RENDERER, ProcessType::BROWSER},
+  };
+
+  std::vector<base::flat_map<const char*, int64_t>> entries_metrics;
+  scoped_refptr<ProcessMemoryMetricsEmitterFake> emitter(
+      new ProcessMemoryMetricsEmitterFake());
+  for (int i = 0; i < 2; ++i) {
+    GlobalMemoryDumpPtr global_dump(
+        memory_instrumentation::mojom::GlobalMemoryDump::New());
+    for (const auto& ptype : entries_ptypes[i]) {
+      auto expected_metrics = GetExpectedProcessMetrics(ptype);
+      PopulateMetrics(global_dump, ptype, expected_metrics);
+      entries_metrics.push_back(expected_metrics);
+    }
+    emitter->ReceivedMemoryDump(true, i, std::move(global_dump));
+  }
+
+  EXPECT_EQ(8u, test_ukm_recorder_.entries_count());
+  for (size_t i = 0; i < entries_ptypes.size(); ++i) {
+    CheckMemoryUkmEntryMetrics(i, entries_metrics[i]);
+  }
+}

chrome/test/BUILD.gn

@@ -3151,6 +3151,7 @@ test("unit_tests") {
     "../browser/metrics/chrome_browser_main_extra_parts_metrics_unittest.cc",
     "../browser/metrics/chrome_metrics_service_accessor_unittest.cc",
     "../browser/metrics/perf/perf_provider_chromeos_unittest.cc",
+    "../browser/metrics/process_memory_metrics_emitter_unittest.cc",
     "../browser/metrics/subprocess_metrics_provider_unittest.cc",
     "../browser/metrics/thread_watcher_android_unittest.cc",
     "../browser/metrics/thread_watcher_unittest.cc",

services/metrics/public/cpp/ukm_recorder.h

@@ -20,6 +20,7 @@
 
 class ContextualSearchRankerLoggerImpl;
 class PluginInfoMessageFilter;
+class ProcessMemoryMetricsEmitter;
 class UkmPageLoadMetricsObserver;
 class LocalNetworkRequestsPageLoadMetricsObserver;
 
@@ -89,6 +90,7 @@ class METRICS_EXPORT UkmRecorder {
   friend autofill::AutofillMetrics;
   friend payments::JourneyLogger;
   friend ContextualSearchRankerLoggerImpl;
+  friend ProcessMemoryMetricsEmitter;
   friend PluginInfoMessageFilter;
   friend UkmPageLoadMetricsObserver;
   friend LocalNetworkRequestsPageLoadMetricsObserver;

tools/metrics/ukm/ukm.xml

@@ -489,6 +489,55 @@ be describing additional metrics about the same event.
   <metric name="AudioVideo.SRC"/>
 </event>
 
+<event name="Memory.Experimental">
+  <owner>erikchen@chromium.org</owner>
+  <summary>
+    Metrics associated with memory consumption, in MB.
+  </summary>
+  <metric name="BlinkGC">
+    <summary>
+      Measure of memory consumed by Oilpan.
+    </summary>
+  </metric>
+  <metric name="CommandBuffer">
+    <summary>
+      Measure of memory consumed by GL command buffer.
+    </summary>
+  </metric>
+  <metric name="Malloc">
+    <summary>
+      Measure of memory allocated by malloc.
+    </summary>
+  </metric>
+  <metric name="PartitionAlloc">
+    <summary>
+      Measure of memory allocated by PartitionAlloc.
+    </summary>
+  </metric>
+  <metric name="PrivateMemoryFootprint">
+    <summary>
+      Measure of total memory consumed by process.
+    </summary>
+  </metric>
+  <metric name="ProcessType">
+    <summary>
+      Type of process (e.g. browser, renderer, GPU --- see
+      services/resource_coordinator/public/interfaces/memory_instrumentation/memory_instrumentation.mojom)
+      of associated metrics.
+    </summary>
+  </metric>
+  <metric name="Resident">
+    <summary>
+      Size of process' working set.
+    </summary>
+  </metric>
+  <metric name="V8">
+    <summary>
+      Measure of memory consumed by V8.
+    </summary>
+  </metric>
+</event>
+
 <event name="PageDomainInfo">
   <owner>uthakore@chromium.org</owner>
   <summary>