Grab system and process memory stats into crash keys in fallback handler.

components/crash/content/app/fallback_crash_handler_win.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 "components/crash/content/app/fallback_crash_handler_win.h"
 
 #include <dbghelp.h>
+#include <psapi.h>
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/win_util.h"
 #include "third_party/crashpad/crashpad/client/crash_report_database.h"
 #include "third_party/crashpad/crashpad/client/settings.h"
 #include "third_party/crashpad/crashpad/minidump/minidump_extensions.h"
 
 namespace crash_reporter {
 
 namespace {
 
 using FilePosition = uint32_t;
 const FilePosition kInvalidFilePos = static_cast<FilePosition>(-1);
 
 using StringStringMap = std::map<std::string, std::string>;
 
+void AcquireMemoryMetrics(const base::Process& process,
+                          StringStringMap* crash_keys) {
+  // Grab the process private memory.
+  // This is best effort, though really shouldn't ever fail.
+  PROCESS_MEMORY_COUNTERS_EX process_memory = {sizeof(process_memory)};
+  if (GetProcessMemoryInfo(
+          process.Handle(),
+          reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&process_memory),
+          sizeof(process_memory))) {
+    // This is in units of bytes, re-scale to pages for consistency with
+    // system metrics.
+    const uint64_t kPageSize = 4096;
+    crash_keys->insert(std::make_pair(
+        "ProcessPrivateUsage",
+        base::Uint64ToString(process_memory.PrivateUsage / kPageSize)));
+
+    crash_keys->insert(std::make_pair(
+        "ProcessPeakWorkingSetSize",
+        base::Uint64ToString(process_memory.PeakWorkingSetSize / kPageSize)));
+  }
+
+  // Grab system commit memory. Also best effort.
+  PERFORMANCE_INFORMATION perf_info = {sizeof(perf_info)};
+  if (GetPerformanceInfo(&perf_info, sizeof(perf_info))) {
+    // Record the remaining committable memory and the limit. This is in units
+    // of system pages.
+    crash_keys->insert(std::make_pair(
+        "SystemCommitRemaining",
+        base::UintToString(perf_info.CommitLimit - perf_info.CommitTotal)));
+    crash_keys->insert(std::make_pair(
+        "SystemCommitLimit", base::UintToString(perf_info.CommitLimit)));
+  }
+}
+
 // This class is a helper to edit minidump files written by MiniDumpWriteDump.
 // It assumes the minidump file it operates on has a directory entry pointing to
 // a CrashpadInfo entry, which it updates to point to the SimpleDictionary data
 // it appends to the file contents.
 class MinidumpUpdater {
  public:
   MinidumpUpdater();
 
   // Reads the existing directory from |file|.
   bool Initialize(base::File* file);
@@ skipping 360 matching lines @@
   const char* platform = "Win64";
 #else
   const char* platform = "Win32";
 #endif
   std::map<std::string, std::string> crash_keys = {{"prod", product},
                                                    {"ver", version},
                                                    {"channel", channel},
                                                    {"plat", platform},
                                                    {"ptype", process_type}};
 
+  // Add memory metrics relating to system-wide and target process memory usage.
+  AcquireMemoryMetrics(process_, &crash_keys);
+
   crashpad::UUID client_id;
   crashpad::Settings* settings = database->GetSettings();
   if (settings) {
     // If GetSettings() or GetClientID() fails client_id will be left at its
     // default value, all zeroes, which is appropriate.
     settings->GetClientID(&client_id);
   }
 
   base::FilePath dump_file_path;
   if (!base::CreateTemporaryFile(&dump_file_path))
     return false;
 
   // Open the file with delete on close, to try and ensure it's cleaned up on
   // any kind of failure.
   base::File dump_file(dump_file_path, base::File::FLAG_OPEN |
                                            base::File::FLAG_READ |
                                            base::File::FLAG_WRITE |
                                            base::File::FLAG_DELETE_ON_CLOSE);
   if (!dump_file.IsValid())
     return false;
 
   uint32_t minidump_type = MiniDumpWithUnloadedModules |
-                                 MiniDumpWithProcessThreadData |
-                                 MiniDumpWithThreadInfo;
+                           MiniDumpWithProcessThreadData |
+                           MiniDumpWithThreadInfo;
 
   // Capture more detail for canary and dev channels. The prefix search caters
   // for the soon to be outdated "-m" suffixed multi-install channels.
   if (channel.find("canary") == 0 || channel.find("dev") == 0)
     minidump_type |= MiniDumpWithIndirectlyReferencedMemory;
 
   // Write the minidump to the temp file, and then copy the data to the
   // Crashpad-provided handle, as the latter is only open for write.
   if (!MiniDumpWriteDumpWithCrashpadInfo(process_, minidump_type, &exc_info,
                                          crash_keys, client_id, report->uuid,
                                          &dump_file) ||
       !AppendFileContents(&dump_file, report->handle)) {
     return false;
   }
 
   on_error.Disarm();
 
   crashpad::UUID report_id = {};
   status = database->FinishedWritingCrashReport(report, &report_id);
   if (status != crashpad::CrashReportDatabase::kNoError)
     return false;
 
   return true;
 }
 
 }  // namespace crash_reporter