Update MemoryDetails to use memory_instrumentation.

memory_instrumentation is the source of truth for memory metrics. It provides
private_memory_footprint, a cross-platform consistent memory metric.

The previous implementation exposed working_set and committed - Windows specific
measurements, and phys_footprint - a macOS specific measurement.

This CL replaces those metrics with private_memory_footprint. The only place
these numbers are used is to generate a log string, used by the feedback system
and the OOM reporting system.

Change-Id: If39c626605f70e18e6044c7f1d2f0f1a8ce5562a
Bug: 819289
Reviewed-on: https://chromium-review.googlesource.com/951754Reviewed-by: Nico Weber <thakis@chromium.org>
Commit-Queue: Erik Chen <erikchen@chromium.org>
Cr-Commit-Position: refs/heads/master@{#542196}

chrome/browser/memory_details.cc

@@ -32,6 +32,8 @@
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/content_constants.h"
 #include "extensions/buildflags/buildflags.h"
+#include "services/resource_coordinator/public/cpp/memory_instrumentation/global_memory_dump.h"
+#include "services/resource_coordinator/public/cpp/memory_instrumentation/memory_instrumentation.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
@@ -96,7 +98,7 @@ ProcessMemoryInformation::ProcessMemoryInformation()
       num_open_fds(-1),
       open_fds_soft_limit(-1),
       renderer_type(RENDERER_UNKNOWN),
-      phys_footprint(0) {}
+      private_memory_footprint_kb(0) {}
 
 ProcessMemoryInformation::ProcessMemoryInformation(
     const ProcessMemoryInformation& other) = default;
@@ -105,7 +107,7 @@ ProcessMemoryInformation::~ProcessMemoryInformation() {}
 
 bool ProcessMemoryInformation::operator<(
     const ProcessMemoryInformation& rhs) const {
-  return working_set.priv < rhs.working_set.priv;
+  return private_memory_footprint_kb < rhs.private_memory_footprint_kb;
 }
 
 ProcessData::ProcessData() {}
@@ -175,13 +177,8 @@ std::string MemoryDetails::ToLogString() {
       }
       log += "]";
     }
-    log += StringPrintf(" %d MB private, %d MB shared",
-                        static_cast<int>(iter1->working_set.priv) / 1024,
-                        static_cast<int>(iter1->working_set.shared) / 1024);
-#if defined(OS_CHROMEOS)
-    log += StringPrintf(", %d MB swapped",
-                        static_cast<int>(iter1->working_set.swapped) / 1024);
-#endif
+    log += StringPrintf(
+        " %d MB", static_cast<int>(iter1->private_memory_footprint_kb) / 1024);
     if (iter1->num_open_fds != -1 || iter1->open_fds_soft_limit != -1) {
       log += StringPrintf(", %d FDs open of %d", iter1->num_open_fds,
                           iter1->open_fds_soft_limit);
@@ -359,5 +356,31 @@ void MemoryDetails::CollectChildInfoOnUIThread() {
   vector.erase(std::remove_if(vector.begin(), vector.end(), is_unknown),
                vector.end());
 
+  // Grab a memory dump for all processes.
+  // Using AdaptCallbackForRepeating allows for an easier transition to
+  // OnceCallbacks for https://crbug.com/714018.
+  memory_instrumentation::MemoryInstrumentation::GetInstance()
+      ->RequestGlobalDump(std::vector<std::string>(),
+                          base::AdaptCallbackForRepeating(base::BindOnce(
+                              &MemoryDetails::DidReceiveMemoryDump, this)));
+}
+
+void MemoryDetails::DidReceiveMemoryDump(
+    bool success,
+    std::unique_ptr<memory_instrumentation::GlobalMemoryDump> global_dump) {
+  ProcessData* const chrome_browser = ChromeBrowser();
+  if (success) {
+    for (const memory_instrumentation::GlobalMemoryDump::ProcessDump& dump :
+         global_dump->process_dumps()) {
+      base::ProcessId dump_pid = dump.pid();
+      for (ProcessMemoryInformation& pmi : chrome_browser->processes) {
+        if (pmi.pid == dump_pid) {
+          pmi.private_memory_footprint_kb = dump.os_dump().private_footprint_kb;
+          break;
+        }
+      }
+    }
+  }
+
   OnDetailsAvailable();
 }

chrome/browser/memory_details.h

@@ -19,6 +19,10 @@
 #include "chrome/browser/site_details.h"
 #include "content/public/common/process_type.h"
 
+namespace memory_instrumentation {
+class GlobalMemoryDump;
+}  // namespace memory_instrumentation
+
 // We collect data about each browser process.  A browser may
 // have multiple processes (of course!).  Even IE has multiple
 // processes these days.
@@ -49,10 +53,6 @@ struct ProcessMemoryInformation {
 
   // The process id.
   base::ProcessId pid;
-  // The working set information.
-  base::WorkingSetKBytes working_set;
-  // The committed bytes.
-  base::CommittedKBytes committed;
   // The process version
   base::string16 version;
   // The process product name.
@@ -69,9 +69,8 @@ struct ProcessMemoryInformation {
   RendererProcessType renderer_type;
   // A collection of titles used, i.e. for a tab it'll show all the page titles.
   std::vector<base::string16> titles;
-  // The physical footprint is a macOS concept that tracks anonymous,
-  // non-discardable memory.
-  size_t phys_footprint;
+  // Consistent memory metric for all platforms.
+  size_t private_memory_footprint_kb;
 };
 
 typedef std::vector<ProcessMemoryInformation> ProcessMemoryInformationList;
@@ -170,6 +169,10 @@ class MemoryDetails : public base::RefCountedThreadSafe<MemoryDetails> {
   // renderer processes is only available there.
   void CollectChildInfoOnUIThread();
 
+  void DidReceiveMemoryDump(
+      bool success,
+      std::unique_ptr<memory_instrumentation::GlobalMemoryDump> dump);
+
   std::vector<ProcessData> process_data_;
 
 #if defined(OS_CHROMEOS)

chrome/browser/memory_details_android.cc

@@ -63,7 +63,6 @@ void GetProcessDataMemoryInformation(
 
     std::unique_ptr<base::ProcessMetrics> metrics(
         base::ProcessMetrics::CreateProcessMetrics(*i));
-    metrics->GetWorkingSetKBytes(&pmi.working_set);
 
     // TODO(ssid): Reading "/proc/fd" only works for current process. For child
     // processes, the values need to be computed by the process itself.

chrome/browser/memory_details_linux.cc

@@ -70,7 +70,6 @@ ProcessData GetProcessDataMemoryInformation(
 
     std::unique_ptr<base::ProcessMetrics> metrics(
         base::ProcessMetrics::CreateProcessMetrics(pid));
-    metrics->GetWorkingSetKBytes(&pmi.working_set);
     pmi.num_open_fds = metrics->GetOpenFdCount();
     pmi.open_fds_soft_limit = metrics->GetOpenFdSoftLimit();
 

chrome/browser/memory_details_mac.cc

@@ -58,13 +58,6 @@ void CollectProcessDataForChromeProcess(
     }
   }
 
-  std::unique_ptr<base::ProcessMetrics> metrics =
-      base::ProcessMetrics::CreateProcessMetrics(
-          pid, content::BrowserChildProcessHost::GetPortProvider());
-  metrics->GetCommittedAndWorkingSetKBytes(&info.committed, &info.working_set);
-  base::ProcessMetrics::TaskVMInfo vm_info = metrics->GetTaskVMInfo();
-  info.phys_footprint = vm_info.phys_footprint;
-
   processes->push_back(info);
 }
 

chrome/browser/memory_details_win.cc

@@ -78,11 +78,6 @@ void MemoryDetails::CollectProcessData(
                             ? content::PROCESS_TYPE_BROWSER
                             : content::PROCESS_TYPE_UNKNOWN;
 
-    std::unique_ptr<base::ProcessMetrics> metrics =
-        base::ProcessMetrics::CreateProcessMetrics(process_handle.Get());
-    metrics->GetCommittedKBytes(&info.committed);
-    metrics->GetWorkingSetKBytes(&info.working_set);
-
     // Get Version Information.
     info.version = base::ASCIIToUTF16(version_info::GetVersionNumber());
     // Check if this is one of the child processes whose data we collected