[tracing] Dump child processes' memory metrics in browser

base/process/process_metrics_linux.cc

 // Copyright (c) 2013 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 "base/process/process_metrics.h"
 
 #include <dirent.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 35 matching lines @@
   if (!ReadFileToString(file, &file_as_string))
     return 0;
   TrimWhitespaceASCII(file_as_string, TRIM_ALL, &file_as_string);
   uint64_t file_as_uint64 = 0;
   if (!StringToUint64(file_as_string, &file_as_uint64))
     return 0;
   return file_as_uint64;
 }
 #endif
 
-// Read /proc/<pid>/status and return the value for |field|, or 0 on failure.
-// Only works for fields in the form of "Field: value kB".
-size_t ReadProcStatusAndGetFieldAsSizeT(pid_t pid, const std::string& field) {
+// Read /proc/<pid>/status and writes the value for |field| into |result|.
+// Returns true on success. Only works for fields in the form of
+// "Field: value kB".
+bool ReadProcStatusAndGetFieldAsSizeT(pid_t pid,
+                                      const std::string& field,
+                                      size_t* result) {
+  *result = 0;
   std::string status;
   {
     // Synchronously reading files in /proc does not hit the disk.
     ThreadRestrictions::ScopedAllowIO allow_io;
     FilePath stat_file = internal::GetProcPidDir(pid).Append("status");
     if (!ReadFileToString(stat_file, &status))
-      return 0;
+      return false;
   }
 
   StringPairs pairs;
   SplitStringIntoKeyValuePairs(status, ':', '\n', &pairs);
   TrimKeyValuePairs(&pairs);
   for (size_t i = 0; i < pairs.size(); ++i) {
     const std::string& key = pairs[i].first;
     const std::string& value_str = pairs[i].second;
     if (key == field) {
       std::vector<StringPiece> split_value_str = SplitStringPiece(
           value_str, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       if (split_value_str.size() != 2 || split_value_str[1] != "kB") {
         NOTREACHED();
-        return 0;
+        return false;
       }
-      size_t value;
-      if (!StringToSizeT(split_value_str[0], &value)) {
+      if (!StringToSizeT(split_value_str[0], result)) {
         NOTREACHED();
-        return 0;
+        return false;
       }
-      return value;
+      return true;
     }
   }
-  NOTREACHED();
-  return 0;
+  return false;
 }
 
 #if defined(OS_LINUX)
 // Read /proc/<pid>/sched and look for |field|. On succes, return true and
 // write the value for |field| into |result|.
 // Only works for fields in the form of "field    :     uint_value"
 bool ReadProcSchedAndGetFieldAsUint64(pid_t pid,
                                       const std::string& field,
                                       uint64_t* result) {
   std::string sched_data;
@@ skipping 66 matching lines @@
 }
 
 // On linux, we return vsize.
 size_t ProcessMetrics::GetPagefileUsage() const {
   return internal::ReadProcStatsAndGetFieldAsSizeT(process_,
                                                    internal::VM_VSIZE);
 }
 
 // On linux, we return the high water mark of vsize.
 size_t ProcessMetrics::GetPeakPagefileUsage() const {
-  return ReadProcStatusAndGetFieldAsSizeT(process_, "VmPeak") * 1024;
+  size_t value = 0;
+  bool res = ReadProcStatusAndGetFieldAsSizeT(process_, "VmPeak", &value);
+  DCHECK(res);
+  return value * 1024;
 }
 
 // On linux, we return RSS.
 size_t ProcessMetrics::GetWorkingSetSize() const {
   return internal::ReadProcStatsAndGetFieldAsSizeT(process_, internal::VM_RSS) *
       getpagesize();
 }
 
 // On linux, we return the high water mark of RSS.
 size_t ProcessMetrics::GetPeakWorkingSetSize() const {
-  return ReadProcStatusAndGetFieldAsSizeT(process_, "VmHWM") * 1024;
+  size_t value = 0;

[Primiano Tucci (use gerrit), 2016/01/07 11:34:35]

Oooh I see, you still cannot have the DCHECK here.
Super apologies, didn't get this.
At this point I think your previous proposal (just remove the dcheck) was better
and more consistent. 
Sorry for having you go back and forth here.

[ssid, 2016/01/07 13:03:09]

Done.

+  ReadProcStatusAndGetFieldAsSizeT(process_, "VmHWM", &value);
+  return value * 1024;
 }
 
 bool ProcessMetrics::GetMemoryBytes(size_t* private_bytes,
                                     size_t* shared_bytes) {
   WorkingSetKBytes ws_usage;
   if (!GetWorkingSetKBytes(&ws_usage))
     return false;
 
   if (private_bytes)
     *private_bytes = ws_usage.priv * 1024;
@@ skipping 742 matching lines @@
 #if defined(OS_LINUX)
 int ProcessMetrics::GetIdleWakeupsPerSecond() {
   uint64_t wake_ups;
   const char kWakeupStat[] = "se.statistics.nr_wakeups";
   return ReadProcSchedAndGetFieldAsUint64(process_, kWakeupStat, &wake_ups) ?
       CalculateIdleWakeupsPerSecond(wake_ups) : 0;
 }
 #endif  // defined(OS_LINUX)
 
 }  // namespace base