base: Move SplitString functions into the base namespace and update the callers.

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>
@@ skipping 21 matching lines @@
 
 // Reads /proc/<pid>/stat and populates |proc_stats| with the values split by
 // spaces. Returns true if successful.
 bool GetProcStats(pid_t pid, std::vector<std::string>* proc_stats) {
   FilePath stat_file("/proc");
   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 false;
-  SplitString(mem_stats, ' ', proc_stats);
+  base::SplitString(mem_stats, ' ', proc_stats);
   return true;
 }
 
 // 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) {
   FilePath cmd_line_file("/proc");
@@ skipping 298 matching lines @@
     if (page_size_kb <= 0)
       return false;
 
     stat_file =
         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);
+    base::SplitString(statm, ' ', &statm_vec);
     if (statm_vec.size() != 7)
       return false;  // Not the format we expect.
 
     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.
@@ skipping 55 matching lines @@
   // /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);
+  base::SplitString(input.substr(rparen + 2), ' ', &fields);
   if (fields.size() < 13)
     return -1;  // Output not in the format we expect.
 
   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
@@ skipping 227 matching lines @@
 
   if (!file_util::PathExists(oom_adj))
     return false;
 
   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