[NOT TO COMMIT YET] Using proc/pid/status file contents to get process metrics in linux.

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 <sys/stat.h>
 #include <sys/time.h>
@@ skipping 41 matching lines @@
 // Only works for fields in the form of "Field: value kB".
 size_t ReadProcStatusAndGetFieldAsSizeT(pid_t pid, const std::string& field) {
   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;
   }
-
-  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;
-      }
-      size_t value;
-      if (!StringToSizeT(split_value_str[0], &value)) {
-        NOTREACHED();
-        return 0;
-      }
-      return value;
-    }
-  }
-  NOTREACHED();
-  return 0;
+  size_t value;
+  CHECK(ParseProcStatusAndGetField(status, field, &value));

[Lei Zhang, 2015/10/07 16:10:54]

CHECK() is a bit strong. Any project that uses this code will crash if a
/proc/<pid>/status file is ever malformed.

[ssid, 2015/10/07 17:11:34]

Sorry I beleived NOTREACHED was CHECK. Just realized it is DCHECK. fixed it.

+  return value;
 }
 
 #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* result) {
   std::string sched_data;
@@ skipping 329 matching lines @@
       if (sscanf(&input.data()[i], "%d %d", &utime, &stime) != 2)
         return -1;
 
       return utime + stime;
     }
   }
 
   return -1;
 }
 
+bool ParseProcStatusAndGetField(const std::string& proc_status_contents,
+                                const std::string& field,
+                                size_t* value) {
+  StringPairs pairs;
+  SplitStringIntoKeyValuePairs(proc_status_contents, ':', '\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") {
+        return false;
+      }
+      if (StringToSizeT(split_value_str[0], value)) {
+        *value *= 1024;
+        return true;
+      }
+      return false;
+    }
+  }
+  return false;
+}
+
 const char kProcSelfExe[] = "/proc/self/exe";
 
 int GetNumberOfThreads(ProcessHandle process) {
   return internal::ReadProcStatsAndGetFieldAsInt64(process,
                                                    internal::VM_NUMTHREADS);
 }
 
 namespace {
 
 // The format of /proc/diskstats is:
@@ skipping 459 matching lines @@
 #if defined(OS_LINUX)
 int ProcessMetrics::GetIdleWakeupsPerSecond() {
   uint64 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