Make task manager memory data more efficient and meaningful.

base/process/private_working_set_snapshot.h

Index: base/process/private_working_set_snapshot.h
diff --git a/base/process/private_working_set_snapshot.h b/base/process/private_working_set_snapshot.h
new file mode 100644
index 0000000000000000000000000000000000000000..71c160e82221ac30ddf5b151d76a112fba87347c
--- /dev/null
+++ b/base/process/private_working_set_snapshot.h
@@ -0,0 +1,107 @@
+// Copyright 2015 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.
+
+#ifndef BASE_PROCESS_PRIVATE_WORKING_SET_SNAPSHOT_
+#define BASE_PROCESS_PRIVATE_WORKING_SET_SNAPSHOT_
+
+#include <vector>
+
+#include "base/base_export.h"
+#include "base/process/process_handle.h"
+
+#if defined(OS_WIN)
+#include <pdh.h>
+#include "base/win/scoped_handle.h"
+
+namespace base {
+
+namespace win {
+
+// The traits class for PDH handles that can be closed via PdhCloseQuery() API.
+struct PDHHandleTraits {
+  typedef PDH_HQUERY Handle;
+  static PDH_HQUERY NullHandle() { return nullptr; }
+  static bool IsHandleValid(PDH_HQUERY handle) { return handle != nullptr; }
+  static bool BASE_EXPORT CloseHandle(PDH_HQUERY handle) {
+    return (PdhCloseQuery(handle) == ERROR_SUCCESS);
+  }
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(PDHHandleTraits);
+};
+
+// DummyVerifierTraits can be used because PDH_HQUERY is just a typedef for
+// HANDLE. However HandleTraits cannot be used because PdhCloseQuery must be
+// called rather than CloseHandle to dispose of the resources.
+typedef GenericScopedHandle<PDHHandleTraits, DummyVerifierTraits> ScopedPDH;
+}  // namespace win

[ncarter (slow), 2015/06/29 20:03:19]

Add a blank line before the namespace close

[brucedawson, 2015/06/29 22:09:52]

Done.

+
+// This class can be used to do bulk collection of private working sets. This
+// exists because on Windows it is much faster to collect a group of private
+// working sets all at once using PdhOpenQuery than to calculate the private
+// working sets for each process individually.
+class BASE_EXPORT PrivateWorkingSetSnapshot {
+ public:
+  PrivateWorkingSetSnapshot();

[ncarter (slow), 2015/06/29 20:03:19]

You should still declare a destructor in the .h with an empty body in the .cc.
An implicitly-declared destructor is an inline public member of its class, and
there's a fatwa issued against nontrivial inlines:

https://www.chromium.org/developers/coding-style/cpp-dos-and-donts#TOC-Stop-i...

[brucedawson, 2015/06/29 22:09:52]

Ah - right. Avoiding nontrivial hidden inlined functions. Done.

+
+  // Add a process name that this object should monitor, such as "chrome". All
+  // processes whose name starts with this string will be monitored.
+  void AddToMonitorList(const std::string& process_name);
+
+  // Query the system for working-set information for all monitored processes
+  // and update the results cache. This function may take a few ms to run.
+  // The time it takes seems to be independent of the number of processes it
+  // retrieves data for. This makes it faster than using QueryWorkingSet as soon
+  // as the process count exceeds two or three.
+  void Sample();
+
+  // Ask for the working set for a specific process, from the most recent call
+  // to Sample. If no data is available then zero will be returned. The result
+  // is in bytes.
+  size_t GetPrivateWorkingSet(base::ProcessId process_id) const;
+
+ private:
+  // This holds a pair of Pdh counters to queries for the process ID and private
+  // working set for a particular process name being monitored. The results from
+  // the two queries can be matched up so that we can associate a private
+  // working set with a process ID.
+  struct PdhCounterPair {
+    // These are bound to query_handle_ and will be freed when it is closed.
+    // The handle to the 'counter' that retrieves process IDs.
+    PDH_HCOUNTER process_id_handle = nullptr;
+    // The handle to the 'counter' that retrieves private working sets.
+    PDH_HCOUNTER private_ws_handle = nullptr;

[ncarter (slow), 2015/06/29 20:03:19]

I'm okay with leaving these as ws, but there's a good chance the base/ OWNER for
this CL may insist on expansion.

[brucedawson, 2015/06/29 22:09:52]

Let's see what happens...

+  };
+
+  // Struct for storing a process ID and associated private working set.
+  struct PidAndPrivateWorkingSet {
+    base::ProcessId process_id;
+    size_t private_ws;
+    // Comparison function for sorting.
+    bool operator<(const PidAndPrivateWorkingSet& other) const {
+      return process_id < other.process_id;
+    }
+    // Comparison function for searching.
+    bool operator<(const base::ProcessId other_process_id) const {
+      return process_id < other_process_id;
+    }
+  };
+
+  // The handle to the query object.
+  win::ScopedPDH query_handle_;
+
+  // A PdhCounterPair for each successful AddToMonitorList call.
+  std::vector<PdhCounterPair> counter_pairs_;
+
+  // After each call to Sample this will hold the results, sorted by process id.
+  std::vector<PidAndPrivateWorkingSet> records_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrivateWorkingSetSnapshot);
+};
+
+}  // namespace base
+
+#endif  // defined(OS_WIN)
+
+#endif  // BASE_PROCESS_PRIVATE_WORKING_SET_SNAPSHOT_