feat: add memory to app.getAppMetrics() (#18831)

shell/browser/api/atom_api_app.cc

@@ -1218,6 +1218,25 @@ std::vector<mate::Dictionary> App::GetAppMetrics(v8::Isolate* isolate) {
     pid_dict.Set("creationTime",
                  process_metric.second->process.CreationTime().ToJsTime());
 
+#if !defined(OS_LINUX)
+    auto memory_info = process_metric.second->GetMemoryInfo();
+
+    mate::Dictionary memory_dict = mate::Dictionary::CreateEmpty(isolate);
+    memory_dict.SetHidden("simple", true);
+    memory_dict.Set("workingSetSize",
+                    static_cast<double>(memory_info.working_set_size >> 10));
+    memory_dict.Set(
+        "peakWorkingSetSize",
+        static_cast<double>(memory_info.peak_working_set_size >> 10));
+
+#if defined(OS_WIN)
+    memory_dict.Set("privateBytes",
+                    static_cast<double>(memory_info.private_bytes >> 10));
+#endif
+
+    pid_dict.Set("memory", memory_dict);
+#endif
+
 #if defined(OS_MACOSX)
     pid_dict.Set("sandboxed", process_metric.second->IsSandboxed());
 #elif defined(OS_WIN)

shell/browser/api/process_metric.cc

@@ -7,13 +7,46 @@
 #include <memory>
 #include <utility>
 
+#include "base/optional.h"
+
 #if defined(OS_WIN)
 #include <windows.h>
+
+#include <psapi.h>
+#include "base/win/win_util.h"
 #endif
 
 #if defined(OS_MACOSX)
+#include <mach/mach.h>
+#include "base/process/port_provider_mac.h"
+#include "content/public/browser/browser_child_process_host.h"
+
 extern "C" int sandbox_check(pid_t pid, const char* operation, int type, ...);
-#endif
+
+namespace {
+
+mach_port_t TaskForPid(pid_t pid) {
+  mach_port_t task = MACH_PORT_NULL;
+  if (auto* port_provider = content::BrowserChildProcessHost::GetPortProvider())
+    task = port_provider->TaskForPid(pid);
+  if (task == MACH_PORT_NULL && pid == getpid())
+    task = mach_task_self();
+  return task;
+}
+
+base::Optional<mach_task_basic_info_data_t> GetTaskInfo(mach_port_t task) {
+  if (task == MACH_PORT_NULL)
+    return base::nullopt;
+  mach_task_basic_info_data_t info = {};
+  mach_msg_type_number_t count = MACH_TASK_BASIC_INFO_COUNT;
+  kern_return_t kr = task_info(task, MACH_TASK_BASIC_INFO,
+                               reinterpret_cast<task_info_t>(&info), &count);
+  return (kr == KERN_SUCCESS) ? base::make_optional(info) : base::nullopt;
+}
+
+}  // namespace
+
+#endif  // defined(OS_MACOSX)
 
 namespace electron {
 
@@ -37,6 +70,21 @@ ProcessMetric::~ProcessMetric() = default;
 
 #if defined(OS_WIN)
 
+ProcessMemoryInfo ProcessMetric::GetMemoryInfo() const {
+  ProcessMemoryInfo result;
+
+  PROCESS_MEMORY_COUNTERS_EX info = {};
+  if (::GetProcessMemoryInfo(process.Handle(),
+                             reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&info),
+                             sizeof(info))) {
+    result.working_set_size = info.WorkingSetSize;
+    result.peak_working_set_size = info.PeakWorkingSetSize;
+    result.private_bytes = info.PrivateUsage;
+  }
+
+  return result;
+}
+
 ProcessIntegrityLevel ProcessMetric::GetIntegrityLevel() const {
   HANDLE token = nullptr;
   if (!::OpenProcessToken(process.Handle(), TOKEN_QUERY, &token)) {
@@ -96,6 +144,17 @@ bool ProcessMetric::IsSandboxed(ProcessIntegrityLevel integrity_level) {
 
 #elif defined(OS_MACOSX)
 
+ProcessMemoryInfo ProcessMetric::GetMemoryInfo() const {
+  ProcessMemoryInfo result;
+
+  if (auto info = GetTaskInfo(TaskForPid(process.Pid()))) {
+    result.working_set_size = info->resident_size;
+    result.peak_working_set_size = info->resident_size_max;
+  }
+
+  return result;
+}
+
 bool ProcessMetric::IsSandboxed() const {
 #if defined(MAS_BUILD)
   return true;

shell/browser/api/process_metric.h

@@ -13,6 +13,16 @@
 
 namespace electron {
 
+#if !defined(OS_LINUX)
+struct ProcessMemoryInfo {
+  size_t working_set_size = 0;
+  size_t peak_working_set_size = 0;
+#if defined(OS_WIN)
+  size_t private_bytes = 0;
+#endif
+};
+#endif
+
 #if defined(OS_WIN)
 enum class ProcessIntegrityLevel {
   Unknown,
@@ -33,6 +43,10 @@ struct ProcessMetric {
                 std::unique_ptr<base::ProcessMetrics> metrics);
   ~ProcessMetric();
 
+#if !defined(OS_LINUX)
+  ProcessMemoryInfo GetMemoryInfo() const;
+#endif
+
 #if defined(OS_WIN)
   ProcessIntegrityLevel GetIntegrityLevel() const;
   static bool IsSandboxed(ProcessIntegrityLevel integrity_level);