Add a field platform_private_footprint_ to ProcessMemoryTotals.

base/trace_event/process_memory_totals.h

 // 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_TRACE_EVENT_PROCESS_MEMORY_TOTALS_H_
 #define BASE_TRACE_EVENT_PROCESS_MEMORY_TOTALS_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 14 matching lines @@
 
   // Called at trace generation time to populate the TracedValue.
   void AsValueInto(TracedValue* value) const;
 
   // Clears up all the data collected.
   void Clear();
 
   uint64_t resident_set_bytes() const { return resident_set_bytes_; }
   void set_resident_set_bytes(uint64_t value) { resident_set_bytes_ = value; }
 
+  uint64_t private_footprint_precursor() const {

[Primiano Tucci (use gerrit), 2017/04/25 12:43:35]

I'd:
just call this private_footprint_bytes() and Add a todo instead (down below with
the larger comment is fine) to explain the "precursor" thing.
Renaming refactorings are always a cost, let's avoid an extra CL to our future
selves :)

+    return private_footprint_precursor_;
+  }
+  void set_private_footprint_precursor(uint64_t value) {
+    private_footprint_precursor_ = value;
+  }
+
   uint64_t peak_resident_set_bytes() const { return peak_resident_set_bytes_; }
   void set_peak_resident_set_bytes(uint64_t value) {
     peak_resident_set_bytes_ = value;
   }
 
   // On some platforms (recent linux kernels, see goo.gl/sMvAVz) the peak rss
   // can be reset. When is_peak_rss_resettable == true, the peak refers to
   // peak from the previous measurement. When false, it is the absolute peak
   // since the start of the process.
   bool is_peak_rss_resetable() const { return is_peak_rss_resetable_; }
   void set_is_peak_rss_resetable(bool value) { is_peak_rss_resetable_ = value; }
 
   void SetExtraFieldInBytes(const char* name, uint64_t value);
 
  private:
   uint64_t resident_set_bytes_;
   uint64_t peak_resident_set_bytes_;
   bool is_peak_rss_resetable_;
 
+  // Number of bytes in a platform-specific precursor that will be used to
+  // compute the private memory footprint. Not emitted in the trace as its value
+  // is platform-dependent. The meaning of the precursor depends on the OS.
+  // On macOS 10.12+,
+  //   task_info(...TASK_VM_INFO...).phys_footprint
+  // On macOS 10.11 and older,
+  //   task_info(...TASK_VM_INFO...).internal +
+  //   task_info(...TASK_VM_INFO...).compressed
+  // On Linux, Android and ChromeOS,
+  //   RssAnon + VmSwap from /proc/pid/status
+  //   TODO(hjd): https://crbug.com/707019
+  // On Windows,
+  //   TBD: https://crbug.com/707022
+  // On iOS,
+  //   TBD: https://crbug.com/714961
+  uint64_t private_footprint_precursor_;

[Wez, 2017/04/25 17:47:19]

As discussed on Slack: "precursor" isn't quite the right term for this, IMO - it
is some platform-specific value representing the private footprint, from which
we will calculate our metric, so I'd suggest a name like:

platform_private_footprint_
platform_private_footprint_metric_

or even just:

platform_private_bytes_

However, it seems strange to have this described as some sort of "raw" metric
specific to the OS, given that it is in fact *not* a raw metric, but something
calculated on an OS-specific basis from the actual raw platform-specific
metrics.

Does the logic that depends on this end up also having to be platform-specific,
since this itself is platform-specific?  If so then why not just store the raw
platform-specific metrics directly, so that there is just one set of logic?

+
   // Extra metrics for OS-specific statistics.
   std::map<const char*, uint64_t> extra_fields_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessMemoryTotals);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_PROCESS_MEMORY_TOTALS_H_