Move string tokenizer to base/strings.

base/process_util_linux.cc

 // Copyright (c) 2012 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 <dirent.h>
 #include <malloc.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
-#include "base/string_tokenizer.h"
 #include "base/string_util.h"
+#include "base/strings/string_tokenizer.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_restrictions.h"
 
+namespace base {
+
 namespace {
 
 enum ParsingState {
   KEY_NAME,
   KEY_VALUE
 };
 
 const char kProcDir[] = "/proc";
 const char kStatFile[] = "stat";
 
 // Returns a FilePath to "/proc/pid".
 FilePath GetProcPidDir(pid_t pid) {
-  return FilePath(kProcDir).Append(base::IntToString(pid));
+  return FilePath(kProcDir).Append(IntToString(pid));
 }
 
 // Fields from /proc/<pid>/stat, 0-based. See man 5 proc.
 // If the ordering ever changes, carefully review functions that use these
 // values.
 enum ProcStatsFields {
   VM_COMM           = 1,   // Filename of executable, without parentheses.
   VM_STATE          = 2,   // Letter indicating the state of the process.
   VM_PPID           = 3,   // PID of the parent.
   VM_PGRP           = 4,   // Process group id.
   VM_UTIME          = 13,  // Time scheduled in user mode in clock ticks.
   VM_STIME          = 14,  // Time scheduled in kernel mode in clock ticks.
   VM_VSIZE          = 22,  // Virtual memory size in bytes.
   VM_RSS            = 23,  // Resident Set Size in pages.
 };
 
 // Reads /proc/<pid>/stat into |buffer|. Returns true if the file can be read
 // and is non-empty.
 bool ReadProcStats(pid_t pid, std::string* buffer) {
   buffer->clear();
   // Synchronously reading files in /proc is safe.
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
+  ThreadRestrictions::ScopedAllowIO allow_io;
 
   FilePath stat_file = GetProcPidDir(pid).Append(kStatFile);
   if (!file_util::ReadFileToString(stat_file, buffer)) {
     DLOG(WARNING) << "Failed to get process stats.";
     return false;
   }
   return !buffer->empty();
 }
 
 // Takes |stats_data| and populates |proc_stats| with the values split by
@@ skipping 24 matching lines @@
   proc_stats->clear();
   // PID.
   proc_stats->push_back(stats_data.substr(0, open_parens_idx));
   // Process name without parentheses.
   proc_stats->push_back(
       stats_data.substr(open_parens_idx + 1,
                         close_parens_idx - (open_parens_idx + 1)));
 
   // Split the rest.
   std::vector<std::string> other_stats;
-  base::SplitString(stats_data.substr(close_parens_idx + 2), ' ', &other_stats);
+  SplitString(stats_data.substr(close_parens_idx + 2), ' ', &other_stats);
   for (size_t i = 0; i < other_stats.size(); ++i)
     proc_stats->push_back(other_stats[i]);
   return true;
 }
 
 // Reads the |field_num|th field from |proc_stats|. Returns 0 on failure.
 // This version does not handle the first 3 values, since the first value is
 // simply |pid|, and the next two values are strings.
 int GetProcStatsFieldAsInt(const std::vector<std::string>& proc_stats,
                            ProcStatsFields field_num) {
   DCHECK_GE(field_num, VM_PPID);
   CHECK_LT(static_cast<size_t>(field_num), proc_stats.size());
 
   int value;
-  return base::StringToInt(proc_stats[field_num], &value) ? value : 0;
+  return StringToInt(proc_stats[field_num], &value) ? value : 0;
 }
 
 // Same as GetProcStatsFieldAsInt(), but for size_t values.
 size_t GetProcStatsFieldAsSizeT(const std::vector<std::string>& proc_stats,
                                 ProcStatsFields field_num) {
   DCHECK_GE(field_num, VM_PPID);
   CHECK_LT(static_cast<size_t>(field_num), proc_stats.size());
 
   size_t value;
-  return base::StringToSizeT(proc_stats[field_num], &value) ? value : 0;
+  return StringToSizeT(proc_stats[field_num], &value) ? value : 0;
 }
 
 // Convenience wrapper around GetProcStatsFieldAsInt(), ParseProcStats() and
 // ReadProcStats(). See GetProcStatsFieldAsInt() for details.
 int ReadProcStatsAndGetFieldAsInt(pid_t pid, ProcStatsFields field_num) {
   std::string stats_data;
   if (!ReadProcStats(pid, &stats_data))
     return 0;
   std::vector<std::string> proc_stats;
   if (!ParseProcStats(stats_data, &proc_stats))
@@ skipping 31 matching lines @@
   return 0;
 }
 
 // Reads /proc/<pid>/cmdline and populates |proc_cmd_line_args| with the command
 // line arguments. Returns true if successful.
 // Note: /proc/<pid>/cmdline contains command line arguments separated by single
 // null characters. We tokenize it into a vector of strings using '\0' as a
 // delimiter.
 bool GetProcCmdline(pid_t pid, std::vector<std::string>* proc_cmd_line_args) {
   // Synchronously reading files in /proc is safe.
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
+  ThreadRestrictions::ScopedAllowIO allow_io;
 
   FilePath cmd_line_file = GetProcPidDir(pid).Append("cmdline");
   std::string cmd_line;
   if (!file_util::ReadFileToString(cmd_line_file, &cmd_line))
     return false;
   std::string delimiters;
   delimiters.push_back('\0');
   Tokenize(cmd_line, delimiters, proc_cmd_line_args);
   return true;
 }
 
 // Take a /proc directory entry named |d_name|, and if it is the directory for
 // a process, convert it to a pid_t.
 // Returns 0 on failure.
 // e.g. /proc/self/ will return 0, whereas /proc/1234 will return 1234.
 pid_t ProcDirSlotToPid(const char* d_name) {
   int i;
   for (i = 0; i < NAME_MAX && d_name[i]; ++i) {
     if (!IsAsciiDigit(d_name[i])) {
       return 0;
     }
   }
   if (i == NAME_MAX)
     return 0;
 
   // Read the process's command line.
   pid_t pid;
   std::string pid_string(d_name);
-  if (!base::StringToInt(pid_string, &pid)) {
+  if (!StringToInt(pid_string, &pid)) {
     NOTREACHED();
     return 0;
   }
   return pid;
 }
 
 // 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 = 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 = ProcDirSlotToPid(ent->d_name);
     if (!tid)
       continue;
 
     // Synchronously reading files in /proc is safe.
-    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    ThreadRestrictions::ScopedAllowIO allow_io;
 
     std::string stat;
     FilePath stat_path = task_path.Append(ent->d_name).Append(kStatFile);
     if (file_util::ReadFileToString(stat_path, &stat)) {
-      int cpu = base::ParseProcStatCPU(stat);
+      int cpu = ParseProcStatCPU(stat);
       if (cpu > 0)
         total_cpu += cpu;
     }
   }
   closedir(dir);
 
   return total_cpu;
 }
 
 // Read /proc/<pid>/status and returns 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) {
   FilePath stat_file = GetProcPidDir(pid).Append("status");
   std::string status;
   {
     // Synchronously reading files in /proc is safe.
-    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    ThreadRestrictions::ScopedAllowIO allow_io;
     if (!file_util::ReadFileToString(stat_file, &status))
       return 0;
   }
 
   StringTokenizer tokenizer(status, ":\n");
   ParsingState state = KEY_NAME;
-  base::StringPiece last_key_name;
+  StringPiece last_key_name;
   while (tokenizer.GetNext()) {
     switch (state) {
       case KEY_NAME:
         last_key_name = tokenizer.token_piece();
         state = KEY_VALUE;
         break;
       case KEY_VALUE:
         DCHECK(!last_key_name.empty());
         if (last_key_name == field) {
           std::string value_str;
           tokenizer.token_piece().CopyToString(&value_str);
           std::string value_str_trimmed;
           TrimWhitespaceASCII(value_str, TRIM_ALL, &value_str_trimmed);
           std::vector<std::string> split_value_str;
-          base::SplitString(value_str_trimmed, ' ', &split_value_str);
+          SplitString(value_str_trimmed, ' ', &split_value_str);
           if (split_value_str.size() != 2 || split_value_str[1] != "kB") {
             NOTREACHED();
             return 0;
           }
           size_t value;
-          if (!base::StringToSizeT(split_value_str[0], &value)) {
+          if (!StringToSizeT(split_value_str[0], &value)) {
             NOTREACHED();
             return 0;
           }
           return value;
         }
         state = KEY_NAME;
         break;
     }
   }
   NOTREACHED();
   return 0;
 }
 
 }  // namespace
 
-namespace base {
-
 #if defined(USE_LINUX_BREAKPAD)
 size_t g_oom_size = 0U;
 #endif
 
 const char kProcSelfExe[] = "/proc/self/exe";
 
 ProcessId GetParentProcessId(ProcessHandle process) {
   ProcessId pid = ReadProcStatsAndGetFieldAsInt(process, VM_PPID);
   if (pid)
     return pid;
@@ skipping 142 matching lines @@
   // 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 = GetProcPidDir(process_).Append("statm");
     // Synchronously reading files in /proc is safe.
-    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    ThreadRestrictions::ScopedAllowIO allow_io;
     bool ret = file_util::ReadFileToString(statm_file, &statm);
     if (!ret || statm.length() == 0)
       return false;
   }
 
   std::vector<std::string> statm_vec;
-  base::SplitString(statm, ' ', &statm_vec);
+  SplitString(statm, ' ', &statm_vec);
   if (statm_vec.size() != 7)
     return false;  // Not the format we expect.
 
   int statm_rss, statm_shared;
-  base::StringToInt(statm_vec[1], &statm_rss);
-  base::StringToInt(statm_vec[2], &statm_shared);
+  StringToInt(statm_vec[1], &statm_rss);
+  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;
 
   return true;
 }
 
@@ skipping 37 matching lines @@
   last_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 is safe.
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
+  ThreadRestrictions::ScopedAllowIO allow_io;
 
   std::string proc_io_contents;
   FilePath io_file = GetProcPidDir(process_).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;
   StringPiece last_key_name;
   while (tokenizer.GetNext()) {
     switch (state) {
       case KEY_NAME:
         last_key_name = tokenizer.token_piece();
         state = KEY_VALUE;
         break;
       case KEY_VALUE:
         DCHECK(!last_key_name.empty());
         if (last_key_name == "syscr") {
-          base::StringToInt64(tokenizer.token_piece(),
+          StringToInt64(tokenizer.token_piece(),
               reinterpret_cast<int64*>(&(*io_counters).ReadOperationCount));
         } else if (last_key_name == "syscw") {
-          base::StringToInt64(tokenizer.token_piece(),
+          StringToInt64(tokenizer.token_piece(),
               reinterpret_cast<int64*>(&(*io_counters).WriteOperationCount));
         } else if (last_key_name == "rchar") {
-          base::StringToInt64(tokenizer.token_piece(),
+          StringToInt64(tokenizer.token_piece(),
               reinterpret_cast<int64*>(&(*io_counters).ReadTransferCount));
         } else if (last_key_name == "wchar") {
-          base::StringToInt64(tokenizer.token_piece(),
+          StringToInt64(tokenizer.token_piece(),
               reinterpret_cast<int64*>(&(*io_counters).WriteTransferCount));
         }
         state = KEY_NAME;
         break;
     }
   }
   return true;
 }
 
 ProcessMetrics::ProcessMetrics(ProcessHandle process)
     : process_(process),
       last_time_(0),
       last_system_time_(0),
       last_cpu_(0) {
-  processor_count_ = base::SysInfo::NumberOfProcessors();
+  processor_count_ = SysInfo::NumberOfProcessors();
 }
 
 
 // Exposed for testing.
 int ParseProcStatCPU(const std::string& input) {
   std::vector<std::string> proc_stats;
   if (!ParseProcStats(input, &proc_stats))
     return -1;
 
   if (proc_stats.size() <= VM_STIME)
@@ skipping 32 matching lines @@
       inactive_anon(0),
       active_file(0),
       inactive_file(0),
       shmem(0),
       gem_objects(-1),
       gem_size(-1) {
 }
 
 bool GetSystemMemoryInfo(SystemMemoryInfoKB* meminfo) {
   // Synchronously reading files in /proc is safe.
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
+  ThreadRestrictions::ScopedAllowIO allow_io;
 
   // Used memory is: total - free - buffers - caches
   FilePath meminfo_file("/proc/meminfo");
   std::string meminfo_data;
   if (!file_util::ReadFileToString(meminfo_file, &meminfo_data)) {
     DLOG(WARNING) << "Failed to open " << meminfo_file.value();
     return false;
   }
   std::vector<std::string> meminfo_fields;
   SplitStringAlongWhitespace(meminfo_data, &meminfo_fields);
 
   if (meminfo_fields.size() < kMemCachedIndex) {
     DLOG(WARNING) << "Failed to parse " << meminfo_file.value()
                   << ".  Only found " << meminfo_fields.size() << " fields.";
     return false;
   }
 
   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[kMemCachedIndex-1], "Cached:");
   DCHECK_EQ(meminfo_fields[kMemActiveAnonIndex-1], "Active(anon):");
   DCHECK_EQ(meminfo_fields[kMemInactiveAnonIndex-1], "Inactive(anon):");
   DCHECK_EQ(meminfo_fields[kMemActiveFileIndex-1], "Active(file):");
   DCHECK_EQ(meminfo_fields[kMemInactiveFileIndex-1], "Inactive(file):");
 
-  base::StringToInt(meminfo_fields[kMemTotalIndex], &meminfo->total);
-  base::StringToInt(meminfo_fields[kMemFreeIndex], &meminfo->free);
-  base::StringToInt(meminfo_fields[kMemBuffersIndex], &meminfo->buffers);
-  base::StringToInt(meminfo_fields[kMemCachedIndex], &meminfo->cached);
-  base::StringToInt(meminfo_fields[kMemActiveAnonIndex], &meminfo->active_anon);
-  base::StringToInt(meminfo_fields[kMemInactiveAnonIndex],
+  StringToInt(meminfo_fields[kMemTotalIndex], &meminfo->total);
+  StringToInt(meminfo_fields[kMemFreeIndex], &meminfo->free);
+  StringToInt(meminfo_fields[kMemBuffersIndex], &meminfo->buffers);
+  StringToInt(meminfo_fields[kMemCachedIndex], &meminfo->cached);
+  StringToInt(meminfo_fields[kMemActiveAnonIndex], &meminfo->active_anon);
+  StringToInt(meminfo_fields[kMemInactiveAnonIndex],
                     &meminfo->inactive_anon);
-  base::StringToInt(meminfo_fields[kMemActiveFileIndex], &meminfo->active_file);
-  base::StringToInt(meminfo_fields[kMemInactiveFileIndex],
+  StringToInt(meminfo_fields[kMemActiveFileIndex], &meminfo->active_file);
+  StringToInt(meminfo_fields[kMemInactiveFileIndex],
                     &meminfo->inactive_file);
 #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.  Unfortunately, the
   // meminfo format varies on different hardware so we have to search for the
   // string.  It always appears after "Cached:".
   for (size_t i = kMemCachedIndex+2; i < meminfo_fields.size(); i += 3) {
     if (meminfo_fields[i] == "Shmem:") {
-      base::StringToInt(meminfo_fields[i+1], &meminfo->shmem);
+      StringToInt(meminfo_fields[i+1], &meminfo->shmem);
       break;
     }
   }
 #endif
 
   // Check for graphics memory data and report if present. Synchronously
   // reading files in /sys is fast.
 #if defined(ARCH_CPU_ARM_FAMILY)
   FilePath geminfo_file("/sys/kernel/debug/dri/0/exynos_gem_objects");
 #else
@@ skipping 159 matching lines @@
 // also has its own C version.
 bool AdjustOOMScore(ProcessId process, int score) {
   if (score < 0 || score > kMaxOomScore)
     return false;
 
   FilePath oom_path(GetProcPidDir(process));
 
   // Attempt to write the newer oom_score_adj file first.
   FilePath oom_file = oom_path.AppendASCII("oom_score_adj");
   if (file_util::PathExists(oom_file)) {
-    std::string score_str = base::IntToString(score);
+    std::string score_str = IntToString(score);
     DVLOG(1) << "Adjusting oom_score_adj of " << process << " to "
              << score_str;
     int score_len = static_cast<int>(score_str.length());
     return (score_len == file_util::WriteFile(oom_file,
                                               score_str.c_str(),
                                               score_len));
   }
 
   // If the oom_score_adj file doesn't exist, then we write the old
   // style file and translate the oom_adj score to the range 0-15.
   oom_file = oom_path.AppendASCII("oom_adj");
   if (file_util::PathExists(oom_file)) {
     // Max score for the old oom_adj range.  Used for conversion of new
     // values to old values.
     const int kMaxOldOomScore = 15;
 
     int converted_score = score * kMaxOldOomScore / kMaxOomScore;
-    std::string score_str = base::IntToString(converted_score);
+    std::string score_str = IntToString(converted_score);
     DVLOG(1) << "Adjusting oom_adj of " << process << " to " << score_str;
     int score_len = static_cast<int>(score_str.length());
     return (score_len == file_util::WriteFile(oom_file,
                                               score_str.c_str(),
                                               score_len));
   }
 
   return false;
 }
 
 }  // namespace base