Move common code into process_util.cc

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_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.
@@ skipping 48 matching lines @@
   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));
 }
 
-NamedProcessIterator::NamedProcessIterator(const std::wstring& executable_name,
-                                           const ProcessFilter* filter)
-    : executable_name_(executable_name), filter_(filter) {
+ProcessIterator::ProcessIterator(const ProcessFilter* filter)
+    : filter_(filter) {
   procfs_dir_ = opendir("/proc");
 }
 
-NamedProcessIterator::~NamedProcessIterator() {
+ProcessIterator::~ProcessIterator() {
   if (procfs_dir_) {
     closedir(procfs_dir_);
     procfs_dir_ = NULL;
   }
 }
 
-const ProcessEntry* NamedProcessIterator::NextProcessEntry() {
-  bool result = false;
-  do {
-    result = CheckForNextProcess();
-  } while (result && !IncludeEntry());
-
-  if (result)
-    return &entry_;
-
-  return NULL;
-}
-
-bool NamedProcessIterator::CheckForNextProcess() {
+bool ProcessIterator::CheckForNextProcess() {
   // TODO(port): skip processes owned by different UID
 
   dirent* slot = 0;
   const char* openparen;
   const char* closeparen;
 
   // Arbitrarily guess that there will never be more than 200 non-process
   // files in /proc.  Hardy has 53.
   int skipped = 0;
   const int kSkipLimit = 200;
@@ skipping 22 matching lines @@
     sprintf(buf, "/proc/%s/stat", slot->d_name);
     FILE *fp = fopen(buf, "r");
     if (!fp)
       return false;
     const char* result = fgets(buf, sizeof(buf), fp);
     fclose(fp);
     if (!result)
       return false;
 
     // Parse the status.  It is formatted like this:
-    // %d (%s) %c %d ...
-    // pid (name) runstate ppid
+    // %d (%s) %c %d %d ...
+    // pid (name) runstate ppid gid
     // To avoid being fooled by names containing a closing paren, scan
     // backwards.
     openparen = strchr(buf, '(');
     closeparen = strrchr(buf, ')');
     if (!openparen || !closeparen)
       return false;
     char runstate = closeparen[2];
 
     // Is the process in 'Zombie' state, i.e. dead but waiting to be reaped?
     // Allowed values: D R S T Z
     if (runstate != 'Z')
       break;
 
     // Nope, it's a zombie; somebody isn't cleaning up after their children.
     // (e.g. WaitForProcessesToExit doesn't clean up after dead children yet.)
     // There could be a lot of zombies, can't really decrement i here.
   }
   if (skipped >= kSkipLimit) {
     NOTREACHED();
     return false;
   }
 
-  entry_.pid = atoi(slot->d_name);
-  entry_.ppid = atoi(closeparen + 3);
+  // This seems fragile.
+  entry_.pid_ = atoi(slot->d_name);
+  entry_.ppid_ = atoi(closeparen + 3);
+  entry_.gid_ = atoi(strchr(closeparen + 4, ' '));
 
   // TODO(port): read pid's commandline's $0, like killall does.  Using the
   // short name between openparen and closeparen won't work for long names!
   int len = closeparen - openparen - 1;
-  if (len > NAME_MAX)
-    len = NAME_MAX;
-  memcpy(entry_.szExeFile, openparen + 1, len);
-  entry_.szExeFile[len] = 0;
-
+  entry_.exe_file_.assign(openparen + 1, len);
   return true;
 }
 
 bool NamedProcessIterator::IncludeEntry() {
   // TODO(port): make this also work for non-ASCII filenames
-  if (WideToASCII(executable_name_) != entry_.szExeFile)
+  if (WideToASCII(executable_name_) != entry().exe_file())
     return false;
-  if (!filter_)
-    return true;
-  return filter_->Includes(entry_.pid, entry_.ppid);
+  return ProcessIterator::IncludeEntry();
+}
+
+
+ProcessMetrics::ProcessMetrics(ProcessHandle process)
+    : process_(process),
+      last_time_(0),
+      last_system_time_(0),
+      last_cpu_(0) {
+  processor_count_ = base::SysInfo::NumberOfProcessors();
+}
+
+// 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]));
   return 0;
@@ skipping 396 matching lines @@
 
   if (!file_util::PathExists(oom_adj))
     return false;
 
   std::string score_str = IntToString(score);
   return (static_cast<int>(score_str.length()) ==
           file_util::WriteFile(oom_adj, score_str.c_str(), score_str.length()));
 }
 
 }  // namespace base