Move the number conversions from string_util to a new file....

base/process_util_linux.cc

 // Copyright (c) 2009 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_util.h"
 
 #include <ctype.h>
 #include <dirent.h>
 #include <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <time.h>
 #include <unistd.h>
 
 #include "base/file_util.h"
 #include "base/logging.h"
+#include "base/string_number_conversions.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 
 namespace {
 
 enum ParsingState {
   KEY_NAME,
   KEY_VALUE
 };
 
 // Reads /proc/<pid>/stat and populates |proc_stats| with the values split by
 // spaces.
 void GetProcStats(pid_t pid, std::vector<std::string>* proc_stats) {
   FilePath stat_file("/proc");
-  stat_file = stat_file.Append(IntToString(pid));
+  stat_file = stat_file.Append(base::IntToString(pid));
   stat_file = stat_file.Append("stat");
   std::string mem_stats;
   if (!file_util::ReadFileToString(stat_file, &mem_stats))
     return;
   SplitString(mem_stats, ' ', proc_stats);
 }
 
 }  // namespace
 
 namespace base {
 
 ProcessId GetParentProcessId(ProcessHandle process) {
   FilePath stat_file("/proc");
-  stat_file = stat_file.Append(IntToString(process));
+  stat_file = stat_file.Append(base::IntToString(process));
   stat_file = stat_file.Append("status");
   std::string status;
   if (!file_util::ReadFileToString(stat_file, &status))
     return -1;
 
   StringTokenizer tokenizer(status, ":\n");
   ParsingState state = KEY_NAME;
   std::string last_key_name;
   while (tokenizer.GetNext()) {
     switch (state) {
       case KEY_NAME:
         last_key_name = tokenizer.token();
         state = KEY_VALUE;
         break;
       case KEY_VALUE:
         DCHECK(!last_key_name.empty());
         if (last_key_name == "PPid") {
-          pid_t ppid = StringToInt(tokenizer.token());
+          int ppid;
+          base::StringToInt(tokenizer.token(), &ppid);
           return ppid;
         }
         state = KEY_NAME;
         break;
     }
   }
   NOTREACHED();
   return -1;
 }
 
 FilePath GetProcessExecutablePath(ProcessHandle process) {
   FilePath stat_file("/proc");
-  stat_file = stat_file.Append(IntToString(process));
+  stat_file = stat_file.Append(base::IntToString(process));
   stat_file = stat_file.Append("exe");
   char exename[2048];
   ssize_t len = readlink(stat_file.value().c_str(), exename, sizeof(exename));
   if (len < 1) {
     // No such process.  Happens frequently in e.g. TerminateAllChromeProcesses
     return FilePath();
   }
   return FilePath(std::string(exename, len));
 }
 
@@ skipping 107 matching lines @@
 // static
 ProcessMetrics* ProcessMetrics::CreateProcessMetrics(ProcessHandle process) {
   return new ProcessMetrics(process);
 }
 
 // On linux, we return vsize.
 size_t ProcessMetrics::GetPagefileUsage() const {
   std::vector<std::string> proc_stats;
   GetProcStats(process_, &proc_stats);
   const size_t kVmSize = 22;
-  if (proc_stats.size() > kVmSize)
-    return static_cast<size_t>(StringToInt(proc_stats[kVmSize]));
+  if (proc_stats.size() > kVmSize) {
+    int vm_size;
+    base::StringToInt(proc_stats[kVmSize], &vm_size);
+    return static_cast<size_t>(vm_size);
+  }
   return 0;
 }
 
 // On linux, we return the high water mark of vsize.
 size_t ProcessMetrics::GetPeakPagefileUsage() const {
   std::vector<std::string> proc_stats;
   GetProcStats(process_, &proc_stats);
   const size_t kVmPeak = 21;
-  if (proc_stats.size() > kVmPeak)
-    return static_cast<size_t>(StringToInt(proc_stats[kVmPeak]));
+  if (proc_stats.size() > kVmPeak) {
+    int vm_peak;
+    if (base::StringToInt(proc_stats[kVmPeak], &vm_peak))
+      return vm_peak;
+  }
   return 0;
 }
 
 // On linux, we return RSS.
 size_t ProcessMetrics::GetWorkingSetSize() const {
   std::vector<std::string> proc_stats;
   GetProcStats(process_, &proc_stats);
   const size_t kVmRss = 23;
   if (proc_stats.size() > kVmRss) {
-    size_t num_pages = static_cast<size_t>(StringToInt(proc_stats[kVmRss]));
-    return num_pages * getpagesize();
+    int num_pages;
+    if (base::StringToInt(proc_stats[kVmRss], &num_pages))
+      return static_cast<size_t>(num_pages) * getpagesize();
   }
   return 0;
 }
 
 // On linux, we return the high water mark of RSS.
 size_t ProcessMetrics::GetPeakWorkingSetSize() const {
   std::vector<std::string> proc_stats;
   GetProcStats(process_, &proc_stats);
   const size_t kVmHwm = 23;
   if (proc_stats.size() > kVmHwm) {
-    size_t num_pages = static_cast<size_t>(StringToInt(proc_stats[kVmHwm]));
-    return num_pages * getpagesize();
+    int num_pages;
+    base::StringToInt(proc_stats[kVmHwm], &num_pages);
+    return static_cast<size_t>(num_pages) * getpagesize();
   }
   return 0;
 }
 
 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 << 10;
 
   if (shared_bytes)
     *shared_bytes = ws_usage.shared * 1024;
 
   return true;
 }
 
 // Private and Shared working set sizes are obtained from /proc/<pid>/smaps.
 // When that's not available, use the values from /proc<pid>/statm as a
 // close approximation.
 // See http://www.pixelbeat.org/scripts/ps_mem.py
 bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const {
   FilePath stat_file =
-    FilePath("/proc").Append(IntToString(process_)).Append("smaps");
+      FilePath("/proc").Append(base::IntToString(process_)).Append("smaps");
   std::string smaps;
   int private_kb = 0;
   int pss_kb = 0;
   bool have_pss = false;
   if (file_util::ReadFileToString(stat_file, &smaps) && smaps.length() > 0) {
     const std::string private_prefix = "Private_";
     const std::string pss_prefix = "Pss";
     StringTokenizer tokenizer(smaps, ":\n");
     StringPiece last_key_name;
     ParsingState state = KEY_NAME;
     while (tokenizer.GetNext()) {
       switch (state) {
         case KEY_NAME:
           last_key_name = tokenizer.token_piece();
           state = KEY_VALUE;
           break;
         case KEY_VALUE:
           if (last_key_name.empty()) {
             NOTREACHED();
             return false;
           }
           if (last_key_name.starts_with(private_prefix)) {
-            private_kb += StringToInt(tokenizer.token());
+            int cur;
+            base::StringToInt(tokenizer.token(), &cur);
+            private_kb += cur;
           } else if (last_key_name.starts_with(pss_prefix)) {
             have_pss = true;
-            pss_kb += StringToInt(tokenizer.token());
+            int cur;
+            base::StringToInt(tokenizer.token(), &cur);
+            pss_kb += cur;
           }
           state = KEY_NAME;
           break;
       }
     }
   } else {
     // Try statm if smaps is empty because of the SUID sandbox.
     // First we need to get the page size though.
     int page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024;
     if (page_size_kb <= 0)
       return false;
 
     stat_file =
-        FilePath("/proc").Append(IntToString(process_)).Append("statm");
+        FilePath("/proc").Append(base::IntToString(process_)).Append("statm");
     std::string statm;
     if (!file_util::ReadFileToString(stat_file, &statm) || 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.
-    private_kb = StringToInt(statm_vec[1]) - StringToInt(statm_vec[2]);
-    private_kb *= page_size_kb;
+
+    int statm1, statm2;
+    base::StringToInt(statm_vec[1], &statm1);
+    base::StringToInt(statm_vec[2], &statm2);
+    private_kb = (statm1 - statm2) * page_size_kb;
   }
   ws_usage->priv = private_kb;
   // Sharable is not calculated, as it does not provide interesting data.
   ws_usage->shareable = 0;
 
   ws_usage->shared = 0;
   if (have_pss)
     ws_usage->shared = pss_kb;
   return true;
 }
 
 // To have /proc/self/io file you must enable CONFIG_TASK_IO_ACCOUNTING
 // in your kernel configuration.
 bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const {
   std::string proc_io_contents;
   FilePath io_file("/proc");
-  io_file = io_file.Append(IntToString(process_));
+  io_file = io_file.Append(base::IntToString(process_));
   io_file = io_file.Append("io");
   if (!file_util::ReadFileToString(io_file, &proc_io_contents))
     return false;
 
   (*io_counters).OtherOperationCount = 0;
   (*io_counters).OtherTransferCount = 0;
 
   StringTokenizer tokenizer(proc_io_contents, ": \n");
   ParsingState state = KEY_NAME;
   std::string last_key_name;
   while (tokenizer.GetNext()) {
     switch (state) {
       case KEY_NAME:
         last_key_name = tokenizer.token();
         state = KEY_VALUE;
         break;
       case KEY_VALUE:
         DCHECK(!last_key_name.empty());
         if (last_key_name == "syscr") {
-          (*io_counters).ReadOperationCount = StringToInt64(tokenizer.token());
+          base::StringToInt64(tokenizer.token(),
+              reinterpret_cast<int64*>(&(*io_counters).ReadOperationCount));
         } else if (last_key_name == "syscw") {
-          (*io_counters).WriteOperationCount = StringToInt64(tokenizer.token());
+          base::StringToInt64(tokenizer.token(),
+              reinterpret_cast<int64*>(&(*io_counters).WriteOperationCount));
         } else if (last_key_name == "rchar") {
-          (*io_counters).ReadTransferCount = StringToInt64(tokenizer.token());
+          base::StringToInt64(tokenizer.token(),
+              reinterpret_cast<int64*>(&(*io_counters).ReadTransferCount));
         } else if (last_key_name == "wchar") {
-          (*io_counters).WriteTransferCount = StringToInt64(tokenizer.token());
+          base::StringToInt64(tokenizer.token(),
+              reinterpret_cast<int64*>(&(*io_counters).WriteTransferCount));
         }
         state = KEY_NAME;
         break;
     }
   }
   return true;
 }
 
 
 // Exposed for testing.
 int ParseProcStatCPU(const std::string& input) {
   // /proc/<pid>/stat contains the process name in parens.  In case the
   // process name itself contains parens, skip past them.
   std::string::size_type rparen = input.rfind(')');
   if (rparen == std::string::npos)
     return -1;
 
   // From here, we expect a bunch of space-separated fields, where the
   // 0-indexed 11th and 12th are utime and stime.  On two different machines
   // I found 42 and 39 fields, so let's just expect the ones we need.
   std::vector<std::string> fields;
   SplitString(input.substr(rparen + 2), ' ', &fields);
   if (fields.size() < 13)
     return -1;  // Output not in the format we expect.
 
-  return StringToInt(fields[11]) + StringToInt(fields[12]);
+  int fields11, fields12;
+  base::StringToInt(fields[11], &fields11);
+  base::StringToInt(fields[12], &fields12);
+  return fields11 + fields12;
 }
 
 // Get the total CPU of a single process.  Return value is number of jiffies
 // on success or -1 on error.
 static int GetProcessCPU(pid_t pid) {
   // Use /proc/<pid>/task to find all threads and parse their /stat file.
   FilePath path = FilePath(StringPrintf("/proc/%d/task/", pid));
 
   DIR* dir = opendir(path.value().c_str());
   if (!dir) {
@@ skipping 93 matching lines @@
     LOG(WARNING) << "Failed to parse /proc/meminfo.  Only found " <<
       meminfo_fields.size() << " fields.";
     return 0;
   }
 
   DCHECK_EQ(meminfo_fields[kMemTotalIndex-1], "MemTotal:");
   DCHECK_EQ(meminfo_fields[kMemFreeIndex-1], "MemFree:");
   DCHECK_EQ(meminfo_fields[kMemBuffersIndex-1], "Buffers:");
   DCHECK_EQ(meminfo_fields[kMemCacheIndex-1], "Cached:");
 
-  size_t result_in_kb;
-  result_in_kb = StringToInt(meminfo_fields[kMemTotalIndex]);
-  result_in_kb -= StringToInt(meminfo_fields[kMemFreeIndex]);
-  result_in_kb -= StringToInt(meminfo_fields[kMemBuffersIndex]);
-  result_in_kb -= StringToInt(meminfo_fields[kMemCacheIndex]);
+  int mem_total, mem_free, mem_buffers, mem_cache;
+  base::StringToInt(meminfo_fields[kMemTotalIndex], &mem_total);
+  base::StringToInt(meminfo_fields[kMemFreeIndex], &mem_free);
+  base::StringToInt(meminfo_fields[kMemBuffersIndex], &mem_buffers);
+  base::StringToInt(meminfo_fields[kMemCacheIndex], &mem_cache);
 
-  return result_in_kb;
+  return mem_total - mem_free - mem_buffers - mem_cache;
 }
 
 namespace {
 
 void OnNoMemorySize(size_t size) {
   if (size != 0)
     LOG(FATAL) << "Out of memory, size = " << size;
   LOG(FATAL) << "Out of memory.";
 }
 
@@ skipping 88 matching lines @@
   std::set_new_handler(&OnNoMemory);
   // If we're using glibc's allocator, the above functions will override
   // malloc and friends and make them die on out of memory.
 }
 
 bool AdjustOOMScore(ProcessId process, int score) {
   if (score < 0 || score > 15)
     return false;
 
   FilePath oom_adj("/proc");
-  oom_adj = oom_adj.Append(Int64ToString(process));
+  oom_adj = oom_adj.Append(base::Int64ToString(process));
   oom_adj = oom_adj.AppendASCII("oom_adj");
 
   if (!file_util::PathExists(oom_adj))
     return false;
 
-  std::string score_str = IntToString(score);
+  std::string score_str = base::IntToString(score);
   return (static_cast<int>(score_str.length()) ==
           file_util::WriteFile(oom_adj, score_str.c_str(), score_str.length()));
 }
 
 }  // namespace base