Move base to DEPS

base/process/process_metrics_linux.cc

Index: base/process/process_metrics_linux.cc
diff --git a/base/process/process_metrics_linux.cc b/base/process/process_metrics_linux.cc
deleted file mode 100644
index 0da1ec3e1adb3003e0617729dcefcf1e1cad2075..0000000000000000000000000000000000000000
--- a/base/process/process_metrics_linux.cc
+++ /dev/null
@@ -1,912 +0,0 @@
-// 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>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include "base/files/file_util.h"
-#include "base/logging.h"
-#include "base/process/internal_linux.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_tokenizer.h"
-#include "base/strings/string_util.h"
-#include "base/sys_info.h"
-#include "base/threading/thread_restrictions.h"
-
-namespace base {
-
-namespace {
-
-void TrimKeyValuePairs(StringPairs* pairs) {
-  DCHECK(pairs);
-  StringPairs& p_ref = *pairs;
-  for (size_t i = 0; i < p_ref.size(); ++i) {
-    TrimWhitespaceASCII(p_ref[i].first, TRIM_ALL, &p_ref[i].first);
-    TrimWhitespaceASCII(p_ref[i].second, TRIM_ALL, &p_ref[i].second);
-  }
-}
-
-#if defined(OS_CHROMEOS)
-// Read a file with a single number string and return the number as a uint64.
-static uint64 ReadFileToUint64(const FilePath file) {
-  std::string file_as_string;
-  if (!ReadFileToString(file, &file_as_string))
-    return 0;
-  TrimWhitespaceASCII(file_as_string, TRIM_ALL, &file_as_string);
-  uint64 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) {
-  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<std::string> split_value_str;
-      SplitString(value_str, ' ', &split_value_str);
-      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;
-}
-
-#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;
-  {
-    // Synchronously reading files in /proc does not hit the disk.
-    ThreadRestrictions::ScopedAllowIO allow_io;
-    FilePath sched_file = internal::GetProcPidDir(pid).Append("sched");
-    if (!ReadFileToString(sched_file, &sched_data))
-      return false;
-  }
-
-  StringPairs pairs;
-  SplitStringIntoKeyValuePairs(sched_data, ':', '\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) {
-      uint64 value;
-      if (!StringToUint64(value_str, &value))
-        return false;
-      *result = value;
-      return true;
-    }
-  }
-  return false;
-}
-#endif  // defined(OS_LINUX)
-
-// Get the total CPU of a single process.  Return value is number of jiffies
-// on success or -1 on error.
-int GetProcessCPU(pid_t pid) {
-  // Use /proc/<pid>/task to find all threads and parse their /stat file.
-  FilePath task_path = internal::GetProcPidDir(pid).Append("task");
-
-  DIR* dir = opendir(task_path.value().c_str());
-  if (!dir) {
-    DPLOG(ERROR) << "opendir(" << task_path.value() << ")";
-    return -1;
-  }
-
-  int total_cpu = 0;
-  while (struct dirent* ent = readdir(dir)) {
-    pid_t tid = internal::ProcDirSlotToPid(ent->d_name);
-    if (!tid)
-      continue;
-
-    // Synchronously reading files in /proc does not hit the disk.
-    ThreadRestrictions::ScopedAllowIO allow_io;
-
-    std::string stat;
-    FilePath stat_path =
-        task_path.Append(ent->d_name).Append(internal::kStatFile);
-    if (ReadFileToString(stat_path, &stat)) {
-      int cpu = ParseProcStatCPU(stat);
-      if (cpu > 0)
-        total_cpu += cpu;
-    }
-  }
-  closedir(dir);
-
-  return total_cpu;
-}
-
-}  // namespace
-
-// static
-ProcessMetrics* ProcessMetrics::CreateProcessMetrics(ProcessHandle process) {
-  return new ProcessMetrics(process);
-}
-
-// 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;
-}
-
-// 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;
-}
-
-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;
-
-  if (shared_bytes)
-    *shared_bytes = ws_usage.shared * 1024;
-
-  return true;
-}
-
-bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const {
-#if defined(OS_CHROMEOS)
-  if (GetWorkingSetKBytesTotmaps(ws_usage))
-    return true;
-#endif
-  return GetWorkingSetKBytesStatm(ws_usage);
-}
-
-double ProcessMetrics::GetCPUUsage() {
-  TimeTicks time = TimeTicks::Now();
-
-  if (last_cpu_ == 0) {
-    // First call, just set the last values.
-    last_cpu_time_ = time;
-    last_cpu_ = GetProcessCPU(process_);
-    return 0;
-  }
-
-  int64 time_delta = (time - last_cpu_time_).InMicroseconds();
-  DCHECK_NE(time_delta, 0);
-  if (time_delta == 0)
-    return 0;
-
-  int cpu = GetProcessCPU(process_);
-
-  // We have the number of jiffies in the time period.  Convert to percentage.
-  // Note this means we will go *over* 100 in the case where multiple threads
-  // are together adding to more than one CPU's worth.
-  TimeDelta cpu_time = internal::ClockTicksToTimeDelta(cpu);
-  TimeDelta last_cpu_time = internal::ClockTicksToTimeDelta(last_cpu_);
-  double percentage = 100.0 * (cpu_time - last_cpu_time).InSecondsF() /
-      TimeDelta::FromMicroseconds(time_delta).InSecondsF();
-
-  last_cpu_time_ = time;
-  last_cpu_ = cpu;
-
-  return percentage;
-}
-
-// To have /proc/self/io file you must enable CONFIG_TASK_IO_ACCOUNTING
-// in your kernel configuration.
-bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const {
-  // Synchronously reading files in /proc does not hit the disk.
-  ThreadRestrictions::ScopedAllowIO allow_io;
-
-  std::string proc_io_contents;
-  FilePath io_file = internal::GetProcPidDir(process_).Append("io");
-  if (!ReadFileToString(io_file, &proc_io_contents))
-    return false;
-
-  io_counters->OtherOperationCount = 0;
-  io_counters->OtherTransferCount = 0;
-
-  StringPairs pairs;
-  SplitStringIntoKeyValuePairs(proc_io_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;
-    uint64* target_counter = NULL;
-    if (key == "syscr")
-      target_counter = &io_counters->ReadOperationCount;
-    else if (key == "syscw")
-      target_counter = &io_counters->WriteOperationCount;
-    else if (key == "rchar")
-      target_counter = &io_counters->ReadTransferCount;
-    else if (key == "wchar")
-      target_counter = &io_counters->WriteTransferCount;
-    if (!target_counter)
-      continue;
-    bool converted = StringToUint64(value_str, target_counter);
-    DCHECK(converted);
-  }
-  return true;
-}
-
-ProcessMetrics::ProcessMetrics(ProcessHandle process)
-    : process_(process),
-      last_system_time_(0),
-#if defined(OS_LINUX)
-      last_absolute_idle_wakeups_(0),
-#endif
-      last_cpu_(0) {
-  processor_count_ = SysInfo::NumberOfProcessors();
-}
-
-#if defined(OS_CHROMEOS)
-// Private, Shared and Proportional working set sizes are obtained from
-// /proc/<pid>/totmaps
-bool ProcessMetrics::GetWorkingSetKBytesTotmaps(WorkingSetKBytes *ws_usage)
-  const {
-  // The format of /proc/<pid>/totmaps is:
-  //
-  // Rss:                6120 kB
-  // Pss:                3335 kB
-  // Shared_Clean:       1008 kB
-  // Shared_Dirty:       4012 kB
-  // Private_Clean:         4 kB
-  // Private_Dirty:      1096 kB
-  // Referenced:          XXX kB
-  // Anonymous:           XXX kB
-  // AnonHugePages:       XXX kB
-  // Swap:                XXX kB
-  // Locked:              XXX kB
-  const size_t kPssIndex = (1 * 3) + 1;
-  const size_t kPrivate_CleanIndex = (4 * 3) + 1;
-  const size_t kPrivate_DirtyIndex = (5 * 3) + 1;
-  const size_t kSwapIndex = (9 * 3) + 1;
-
-  std::string totmaps_data;
-  {
-    FilePath totmaps_file = internal::GetProcPidDir(process_).Append("totmaps");
-    ThreadRestrictions::ScopedAllowIO allow_io;
-    bool ret = ReadFileToString(totmaps_file, &totmaps_data);
-    if (!ret || totmaps_data.length() == 0)
-      return false;
-  }
-
-  std::vector<std::string> totmaps_fields;
-  SplitStringAlongWhitespace(totmaps_data, &totmaps_fields);
-
-  DCHECK_EQ("Pss:", totmaps_fields[kPssIndex-1]);
-  DCHECK_EQ("Private_Clean:", totmaps_fields[kPrivate_CleanIndex - 1]);
-  DCHECK_EQ("Private_Dirty:", totmaps_fields[kPrivate_DirtyIndex - 1]);
-  DCHECK_EQ("Swap:", totmaps_fields[kSwapIndex-1]);
-
-  int pss = 0;
-  int private_clean = 0;
-  int private_dirty = 0;
-  int swap = 0;
-  bool ret = true;
-  ret &= StringToInt(totmaps_fields[kPssIndex], &pss);
-  ret &= StringToInt(totmaps_fields[kPrivate_CleanIndex], &private_clean);
-  ret &= StringToInt(totmaps_fields[kPrivate_DirtyIndex], &private_dirty);
-  ret &= StringToInt(totmaps_fields[kSwapIndex], &swap);
-
-  // On ChromeOS swap is to zram. We count this as private / shared, as
-  // increased swap decreases available RAM to user processes, which would
-  // otherwise create surprising results.
-  ws_usage->priv = private_clean + private_dirty + swap;
-  ws_usage->shared = pss + swap;
-  ws_usage->shareable = 0;
-  ws_usage->swapped = swap;
-  return ret;
-}
-#endif
-
-// Private and Shared working set sizes are obtained from /proc/<pid>/statm.
-bool ProcessMetrics::GetWorkingSetKBytesStatm(WorkingSetKBytes* ws_usage)
-    const {
-  // Use statm instead of smaps because smaps is:
-  // a) Large and slow to parse.
-  // b) Unavailable in the SUID sandbox.
-
-  // First we need to get the page size, since everything is measured in pages.
-  // For details, see: man 5 proc.
-  const int page_size_kb = getpagesize() / 1024;
-  if (page_size_kb <= 0)
-    return false;
-
-  std::string statm;
-  {
-    FilePath statm_file = internal::GetProcPidDir(process_).Append("statm");
-    // Synchronously reading files in /proc does not hit the disk.
-    ThreadRestrictions::ScopedAllowIO allow_io;
-    bool ret = ReadFileToString(statm_file, &statm);
-    if (!ret || statm.length() == 0)
-      return false;
-  }
-
-  std::vector<std::string> statm_vec;
-  SplitString(statm, ' ', &statm_vec);
-  if (statm_vec.size() != 7)
-    return false;  // Not the format we expect.
-
-  int statm_rss, statm_shared;
-  bool ret = true;
-  ret &= StringToInt(statm_vec[1], &statm_rss);
-  ret &= StringToInt(statm_vec[2], &statm_shared);
-
-  ws_usage->priv = (statm_rss - statm_shared) * page_size_kb;
-  ws_usage->shared = statm_shared * page_size_kb;
-
-  // Sharable is not calculated, as it does not provide interesting data.
-  ws_usage->shareable = 0;
-
-#if defined(OS_CHROMEOS)
-  // Can't get swapped memory from statm.
-  ws_usage->swapped = 0;
-#endif
-
-  return ret;
-}
-
-size_t GetSystemCommitCharge() {
-  SystemMemoryInfoKB meminfo;
-  if (!GetSystemMemoryInfo(&meminfo))
-    return 0;
-  return meminfo.total - meminfo.free - meminfo.buffers - meminfo.cached;
-}
-
-int ParseProcStatCPU(const std::string& input) {
-  // |input| may be empty if the process disappeared somehow.
-  // e.g. http://crbug.com/145811.
-  if (input.empty())
-    return -1;
-
-  size_t start = input.find_last_of(')');
-  if (start == input.npos)
-    return -1;
-
-  // Number of spaces remaining until reaching utime's index starting after the
-  // last ')'.
-  int num_spaces_remaining = internal::VM_UTIME - 1;
-
-  size_t i = start;
-  while ((i = input.find(' ', i + 1)) != input.npos) {
-    // Validate the assumption that there aren't any contiguous spaces
-    // in |input| before utime.
-    DCHECK_NE(input[i - 1], ' ');
-    if (--num_spaces_remaining == 0) {
-      int utime = 0;
-      int stime = 0;
-      if (sscanf(&input.data()[i], "%d %d", &utime, &stime) != 2)
-        return -1;
-
-      return utime + stime;
-    }
-  }
-
-  return -1;
-}
-
-const char kProcSelfExe[] = "/proc/self/exe";
-
-int GetNumberOfThreads(ProcessHandle process) {
-  return internal::ReadProcStatsAndGetFieldAsInt64(process,
-                                                   internal::VM_NUMTHREADS);
-}
-
-namespace {
-
-// The format of /proc/diskstats is:
-//  Device major number
-//  Device minor number
-//  Device name
-//  Field  1 -- # of reads completed
-//      This is the total number of reads completed successfully.
-//  Field  2 -- # of reads merged, field 6 -- # of writes merged
-//      Reads and writes which are adjacent to each other may be merged for
-//      efficiency.  Thus two 4K reads may become one 8K read before it is
-//      ultimately handed to the disk, and so it will be counted (and queued)
-//      as only one I/O.  This field lets you know how often this was done.
-//  Field  3 -- # of sectors read
-//      This is the total number of sectors read successfully.
-//  Field  4 -- # of milliseconds spent reading
-//      This is the total number of milliseconds spent by all reads (as
-//      measured from __make_request() to end_that_request_last()).
-//  Field  5 -- # of writes completed
-//      This is the total number of writes completed successfully.
-//  Field  6 -- # of writes merged
-//      See the description of field 2.
-//  Field  7 -- # of sectors written
-//      This is the total number of sectors written successfully.
-//  Field  8 -- # of milliseconds spent writing
-//      This is the total number of milliseconds spent by all writes (as
-//      measured from __make_request() to end_that_request_last()).
-//  Field  9 -- # of I/Os currently in progress
-//      The only field that should go to zero. Incremented as requests are
-//      given to appropriate struct request_queue and decremented as they
-//      finish.
-//  Field 10 -- # of milliseconds spent doing I/Os
-//      This field increases so long as field 9 is nonzero.
-//  Field 11 -- weighted # of milliseconds spent doing I/Os
-//      This field is incremented at each I/O start, I/O completion, I/O
-//      merge, or read of these stats by the number of I/Os in progress
-//      (field 9) times the number of milliseconds spent doing I/O since the
-//      last update of this field.  This can provide an easy measure of both
-//      I/O completion time and the backlog that may be accumulating.
-
-const size_t kDiskDriveName = 2;
-const size_t kDiskReads = 3;
-const size_t kDiskReadsMerged = 4;
-const size_t kDiskSectorsRead = 5;
-const size_t kDiskReadTime = 6;
-const size_t kDiskWrites = 7;
-const size_t kDiskWritesMerged = 8;
-const size_t kDiskSectorsWritten = 9;
-const size_t kDiskWriteTime = 10;
-const size_t kDiskIO = 11;
-const size_t kDiskIOTime = 12;
-const size_t kDiskWeightedIOTime = 13;
-
-}  // namespace
-
-SystemMemoryInfoKB::SystemMemoryInfoKB() {
-  total = 0;
-  free = 0;
-  buffers = 0;
-  cached = 0;
-  active_anon = 0;
-  inactive_anon = 0;
-  active_file = 0;
-  inactive_file = 0;
-  swap_total = 0;
-  swap_free = 0;
-  dirty = 0;
-
-  pswpin = 0;
-  pswpout = 0;
-  pgmajfault = 0;
-
-#ifdef OS_CHROMEOS
-  shmem = 0;
-  slab = 0;
-  gem_objects = -1;
-  gem_size = -1;
-#endif
-}
-
-scoped_ptr<Value> SystemMemoryInfoKB::ToValue() const {
-  scoped_ptr<DictionaryValue> res(new DictionaryValue());
-
-  res->SetInteger("total", total);
-  res->SetInteger("free", free);
-  res->SetInteger("buffers", buffers);
-  res->SetInteger("cached", cached);
-  res->SetInteger("active_anon", active_anon);
-  res->SetInteger("inactive_anon", inactive_anon);
-  res->SetInteger("active_file", active_file);
-  res->SetInteger("inactive_file", inactive_file);
-  res->SetInteger("swap_total", swap_total);
-  res->SetInteger("swap_free", swap_free);
-  res->SetInteger("swap_used", swap_total - swap_free);
-  res->SetInteger("dirty", dirty);
-  res->SetInteger("pswpin", pswpin);
-  res->SetInteger("pswpout", pswpout);
-  res->SetInteger("pgmajfault", pgmajfault);
-#ifdef OS_CHROMEOS
-  res->SetInteger("shmem", shmem);
-  res->SetInteger("slab", slab);
-  res->SetInteger("gem_objects", gem_objects);
-  res->SetInteger("gem_size", gem_size);
-#endif
-
-  return res.Pass();
-}
-
-// exposed for testing
-bool ParseProcMeminfo(const std::string& meminfo_data,
-                      SystemMemoryInfoKB* meminfo) {
-  // The format of /proc/meminfo is:
-  //
-  // MemTotal:      8235324 kB
-  // MemFree:       1628304 kB
-  // Buffers:        429596 kB
-  // Cached:        4728232 kB
-  // ...
-  // There is no guarantee on the ordering or position
-  // though it doesn't appear to change very often
-
-  // As a basic sanity check, let's make sure we at least get non-zero
-  // MemTotal value
-  meminfo->total = 0;
-
-  for (const StringPiece& line : SplitStringPiece(
-           meminfo_data, "\n", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY)) {
-    std::vector<StringPiece> tokens = SplitStringPiece(
-        line, kWhitespaceASCII, TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
-    // HugePages_* only has a number and no suffix so we can't rely on
-    // there being exactly 3 tokens.
-    if (tokens.size() <= 1) {
-      DLOG(WARNING) << "meminfo: tokens: " << tokens.size()
-                    << " malformed line: " << line.as_string();
-      continue;
-    }
-
-    int* target = NULL;
-    if (tokens[0] == "MemTotal:")
-      target = &meminfo->total;
-    else if (tokens[0] == "MemFree:")
-      target = &meminfo->free;
-    else if (tokens[0] == "Buffers:")
-      target = &meminfo->buffers;
-    else if (tokens[0] == "Cached:")
-      target = &meminfo->cached;
-    else if (tokens[0] == "Active(anon):")
-      target = &meminfo->active_anon;
-    else if (tokens[0] == "Inactive(anon):")
-      target = &meminfo->inactive_anon;
-    else if (tokens[0] == "Active(file):")
-      target = &meminfo->active_file;
-    else if (tokens[0] == "Inactive(file):")
-      target = &meminfo->inactive_file;
-    else if (tokens[0] == "SwapTotal:")
-      target = &meminfo->swap_total;
-    else if (tokens[0] == "SwapFree:")
-      target = &meminfo->swap_free;
-    else if (tokens[0] == "Dirty:")
-      target = &meminfo->dirty;
-#if defined(OS_CHROMEOS)
-    // Chrome OS has a tweaked kernel that allows us to query Shmem, which is
-    // usually video memory otherwise invisible to the OS.
-    else if (tokens[0] == "Shmem:")
-      target = &meminfo->shmem;
-    else if (tokens[0] == "Slab:")
-      target = &meminfo->slab;
-#endif
-    if (target)
-      StringToInt(tokens[1], target);
-  }
-
-  // Make sure we got a valid MemTotal.
-  return meminfo->total > 0;
-}
-
-// exposed for testing
-bool ParseProcVmstat(const std::string& vmstat_data,
-                     SystemMemoryInfoKB* meminfo) {
-  // The format of /proc/vmstat is:
-  //
-  // nr_free_pages 299878
-  // nr_inactive_anon 239863
-  // nr_active_anon 1318966
-  // nr_inactive_file 2015629
-  // ...
-  //
-  // We iterate through the whole file because the position of the
-  // fields are dependent on the kernel version and configuration.
-
-  for (const StringPiece& line : SplitStringPiece(
-           vmstat_data, "\n", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY)) {
-    std::vector<StringPiece> tokens =
-        SplitStringPiece(line, " ", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
-    if (tokens.size() != 2)
-      continue;
-
-    if (tokens[0] == "pswpin") {
-      StringToInt(tokens[1], &meminfo->pswpin);
-    } else if (tokens[0] == "pswpout") {
-      StringToInt(tokens[1], &meminfo->pswpout);
-    } else if (tokens[0] == "pgmajfault") {
-      StringToInt(tokens[1], &meminfo->pgmajfault);
-    }
-  }
-
-  return true;
-}
-
-bool GetSystemMemoryInfo(SystemMemoryInfoKB* meminfo) {
-  // Synchronously reading files in /proc and /sys are safe.
-  ThreadRestrictions::ScopedAllowIO allow_io;
-
-  // Used memory is: total - free - buffers - caches
-  FilePath meminfo_file("/proc/meminfo");
-  std::string meminfo_data;
-  if (!ReadFileToString(meminfo_file, &meminfo_data)) {
-    DLOG(WARNING) << "Failed to open " << meminfo_file.value();
-    return false;
-  }
-
-  if (!ParseProcMeminfo(meminfo_data, meminfo)) {
-    DLOG(WARNING) << "Failed to parse " << meminfo_file.value();
-    return false;
-  }
-
-#if defined(OS_CHROMEOS)
-  // Report on Chrome OS GEM object graphics memory. /run/debugfs_gpu is a
-  // bind mount into /sys/kernel/debug and synchronously reading the in-memory
-  // files in /sys is fast.
-#if defined(ARCH_CPU_ARM_FAMILY)
-  FilePath geminfo_file("/run/debugfs_gpu/exynos_gem_objects");
-#else
-  FilePath geminfo_file("/run/debugfs_gpu/i915_gem_objects");
-#endif
-  std::string geminfo_data;
-  meminfo->gem_objects = -1;
-  meminfo->gem_size = -1;
-  if (ReadFileToString(geminfo_file, &geminfo_data)) {
-    int gem_objects = -1;
-    long long gem_size = -1;
-    int num_res = sscanf(geminfo_data.c_str(),
-                         "%d objects, %lld bytes",
-                         &gem_objects, &gem_size);
-    if (num_res == 2) {
-      meminfo->gem_objects = gem_objects;
-      meminfo->gem_size = gem_size;
-    }
-  }
-
-#if defined(ARCH_CPU_ARM_FAMILY)
-  // Incorporate Mali graphics memory if present.
-  FilePath mali_memory_file("/sys/class/misc/mali0/device/memory");
-  std::string mali_memory_data;
-  if (ReadFileToString(mali_memory_file, &mali_memory_data)) {
-    long long mali_size = -1;
-    int num_res = sscanf(mali_memory_data.c_str(), "%lld bytes", &mali_size);
-    if (num_res == 1)
-      meminfo->gem_size += mali_size;
-  }
-#endif  // defined(ARCH_CPU_ARM_FAMILY)
-#endif  // defined(OS_CHROMEOS)
-
-  FilePath vmstat_file("/proc/vmstat");
-  std::string vmstat_data;
-  if (!ReadFileToString(vmstat_file, &vmstat_data)) {
-    DLOG(WARNING) << "Failed to open " << vmstat_file.value();
-    return false;
-  }
-  if (!ParseProcVmstat(vmstat_data, meminfo)) {
-    DLOG(WARNING) << "Failed to parse " << vmstat_file.value();
-    return false;
-  }
-
-  return true;
-}
-
-SystemDiskInfo::SystemDiskInfo() {
-  reads = 0;
-  reads_merged = 0;
-  sectors_read = 0;
-  read_time = 0;
-  writes = 0;
-  writes_merged = 0;
-  sectors_written = 0;
-  write_time = 0;
-  io = 0;
-  io_time = 0;
-  weighted_io_time = 0;
-}
-
-scoped_ptr<Value> SystemDiskInfo::ToValue() const {
-  scoped_ptr<DictionaryValue> res(new DictionaryValue());
-
-  // Write out uint64 variables as doubles.
-  // Note: this may discard some precision, but for JS there's no other option.
-  res->SetDouble("reads", static_cast<double>(reads));
-  res->SetDouble("reads_merged", static_cast<double>(reads_merged));
-  res->SetDouble("sectors_read", static_cast<double>(sectors_read));
-  res->SetDouble("read_time", static_cast<double>(read_time));
-  res->SetDouble("writes", static_cast<double>(writes));
-  res->SetDouble("writes_merged", static_cast<double>(writes_merged));
-  res->SetDouble("sectors_written", static_cast<double>(sectors_written));
-  res->SetDouble("write_time", static_cast<double>(write_time));
-  res->SetDouble("io", static_cast<double>(io));
-  res->SetDouble("io_time", static_cast<double>(io_time));
-  res->SetDouble("weighted_io_time", static_cast<double>(weighted_io_time));
-
-  return res.Pass();
-}
-
-bool IsValidDiskName(const std::string& candidate) {
-  if (candidate.length() < 3)
-    return false;
-  if (candidate[1] == 'd' &&
-      (candidate[0] == 'h' || candidate[0] == 's' || candidate[0] == 'v')) {
-    // [hsv]d[a-z]+ case
-    for (size_t i = 2; i < candidate.length(); ++i) {
-      if (!islower(candidate[i]))
-        return false;
-    }
-    return true;
-  }
-
-  const char kMMCName[] = "mmcblk";
-  const size_t kMMCNameLen = strlen(kMMCName);
-  if (candidate.length() < kMMCNameLen + 1)
-    return false;
-  if (candidate.compare(0, kMMCNameLen, kMMCName) != 0)
-    return false;
-
-  // mmcblk[0-9]+ case
-  for (size_t i = kMMCNameLen; i < candidate.length(); ++i) {
-    if (!isdigit(candidate[i]))
-      return false;
-  }
-  return true;
-}
-
-bool GetSystemDiskInfo(SystemDiskInfo* diskinfo) {
-  // Synchronously reading files in /proc does not hit the disk.
-  ThreadRestrictions::ScopedAllowIO allow_io;
-
-  FilePath diskinfo_file("/proc/diskstats");
-  std::string diskinfo_data;
-  if (!ReadFileToString(diskinfo_file, &diskinfo_data)) {
-    DLOG(WARNING) << "Failed to open " << diskinfo_file.value();
-    return false;
-  }
-
-  std::vector<StringPiece> diskinfo_lines = SplitStringPiece(
-      diskinfo_data, "\n", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
-  if (diskinfo_lines.size() == 0) {
-    DLOG(WARNING) << "No lines found";
-    return false;
-  }
-
-  diskinfo->reads = 0;
-  diskinfo->reads_merged = 0;
-  diskinfo->sectors_read = 0;
-  diskinfo->read_time = 0;
-  diskinfo->writes = 0;
-  diskinfo->writes_merged = 0;
-  diskinfo->sectors_written = 0;
-  diskinfo->write_time = 0;
-  diskinfo->io = 0;
-  diskinfo->io_time = 0;
-  diskinfo->weighted_io_time = 0;
-
-  uint64 reads = 0;
-  uint64 reads_merged = 0;
-  uint64 sectors_read = 0;
-  uint64 read_time = 0;
-  uint64 writes = 0;
-  uint64 writes_merged = 0;
-  uint64 sectors_written = 0;
-  uint64 write_time = 0;
-  uint64 io = 0;
-  uint64 io_time = 0;
-  uint64 weighted_io_time = 0;
-
-  for (const StringPiece& line : diskinfo_lines) {
-    std::vector<StringPiece> disk_fields = SplitStringPiece(
-        line, kWhitespaceASCII, TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
-
-    // Fields may have overflowed and reset to zero.
-    if (IsValidDiskName(disk_fields[kDiskDriveName].as_string())) {
-      StringToUint64(disk_fields[kDiskReads], &reads);
-      StringToUint64(disk_fields[kDiskReadsMerged], &reads_merged);
-      StringToUint64(disk_fields[kDiskSectorsRead], &sectors_read);
-      StringToUint64(disk_fields[kDiskReadTime], &read_time);
-      StringToUint64(disk_fields[kDiskWrites], &writes);
-      StringToUint64(disk_fields[kDiskWritesMerged], &writes_merged);
-      StringToUint64(disk_fields[kDiskSectorsWritten], &sectors_written);
-      StringToUint64(disk_fields[kDiskWriteTime], &write_time);
-      StringToUint64(disk_fields[kDiskIO], &io);
-      StringToUint64(disk_fields[kDiskIOTime], &io_time);
-      StringToUint64(disk_fields[kDiskWeightedIOTime], &weighted_io_time);
-
-      diskinfo->reads += reads;
-      diskinfo->reads_merged += reads_merged;
-      diskinfo->sectors_read += sectors_read;
-      diskinfo->read_time += read_time;
-      diskinfo->writes += writes;
-      diskinfo->writes_merged += writes_merged;
-      diskinfo->sectors_written += sectors_written;
-      diskinfo->write_time += write_time;
-      diskinfo->io += io;
-      diskinfo->io_time += io_time;
-      diskinfo->weighted_io_time += weighted_io_time;
-    }
-  }
-
-  return true;
-}
-
-#if defined(OS_CHROMEOS)
-scoped_ptr<Value> SwapInfo::ToValue() const {
-  scoped_ptr<DictionaryValue> res(new DictionaryValue());
-
-  // Write out uint64 variables as doubles.
-  // Note: this may discard some precision, but for JS there's no other option.
-  res->SetDouble("num_reads", static_cast<double>(num_reads));
-  res->SetDouble("num_writes", static_cast<double>(num_writes));
-  res->SetDouble("orig_data_size", static_cast<double>(orig_data_size));
-  res->SetDouble("compr_data_size", static_cast<double>(compr_data_size));
-  res->SetDouble("mem_used_total", static_cast<double>(mem_used_total));
-  if (compr_data_size > 0)
-    res->SetDouble("compression_ratio", static_cast<double>(orig_data_size) /
-                                        static_cast<double>(compr_data_size));
-  else
-    res->SetDouble("compression_ratio", 0);
-
-  return res.Pass();
-}
-
-void GetSwapInfo(SwapInfo* swap_info) {
-  // Synchronously reading files in /sys/block/zram0 does not hit the disk.
-  ThreadRestrictions::ScopedAllowIO allow_io;
-
-  FilePath zram_path("/sys/block/zram0");
-  uint64 orig_data_size = ReadFileToUint64(zram_path.Append("orig_data_size"));
-  if (orig_data_size <= 4096) {
-    // A single page is compressed at startup, and has a high compression
-    // ratio. We ignore this as it doesn't indicate any real swapping.
-    swap_info->orig_data_size = 0;
-    swap_info->num_reads = 0;
-    swap_info->num_writes = 0;
-    swap_info->compr_data_size = 0;
-    swap_info->mem_used_total = 0;
-    return;
-  }
-  swap_info->orig_data_size = orig_data_size;
-  swap_info->num_reads = ReadFileToUint64(zram_path.Append("num_reads"));
-  swap_info->num_writes = ReadFileToUint64(zram_path.Append("num_writes"));
-  swap_info->compr_data_size =
-      ReadFileToUint64(zram_path.Append("compr_data_size"));
-  swap_info->mem_used_total =
-      ReadFileToUint64(zram_path.Append("mem_used_total"));
-}
-#endif  // defined(OS_CHROMEOS)
-
-#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