Move common code into process_util.cc

base/process_util.h

 // Copyright (c) 2010 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.
 
 // This file/namespace contains utility functions for enumerating, ending and
 // computing statistics of processes.
 
 #ifndef BASE_PROCESS_UTIL_H_
 #define BASE_PROCESS_UTIL_H_
 
 #include "base/basictypes.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <tlhelp32.h>
 #elif defined(OS_MACOSX)
 // kinfo_proc is defined in <sys/sysctl.h>, but this forward declaration
 // is sufficient for the vector<kinfo_proc> below.
 struct kinfo_proc;
 #include <mach/mach.h>
 #elif defined(OS_POSIX)
 #include <dirent.h>
 #include <limits.h>
 #include <sys/types.h>
 #endif
 
+#include <list>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_descriptor_shuffle.h"
 #include "base/file_path.h"
 #include "base/process.h"
 
 #ifndef NAME_MAX  // Solaris and some BSDs have no NAME_MAX
 #ifdef MAXNAMLEN
 #define NAME_MAX MAXNAMLEN
 #else
 #define NAME_MAX 256
 #endif
 #endif
 
 namespace base {
 
 #if defined(OS_WIN)
 
 struct ProcessEntry : public PROCESSENTRY32 {
+  ProcessId pid() const { return th32ProcessID; }
+  ProcessId parent_pid() const { return th32ParentProcessID; }
+  const wchar_t* exe_file() const { return szExeFile; }
 };
+
 struct IoCounters : public IO_COUNTERS {
 };
 
 #elif defined(OS_POSIX)
 
 struct ProcessEntry {
-  base::ProcessId pid;
-  base::ProcessId ppid;
-  char szExeFile[NAME_MAX + 1];
+  ProcessId pid_;
+  ProcessId ppid_;
+  ProcessId gid_;
+  std::string exe_file_;
+
+  ProcessId pid() const { return pid_; }
+  ProcessId parent_pid() const { return ppid_; }
+  const char* exe_file() const { return exe_file_.c_str(); }
 };
 
 struct IoCounters {
   uint64_t ReadOperationCount;
   uint64_t WriteOperationCount;
   uint64_t OtherOperationCount;
   uint64_t ReadTransferCount;
   uint64_t WriteTransferCount;
   uint64_t OtherTransferCount;
 };
@@ skipping 50 matching lines @@
 // This adjusts /proc/process/oom_adj so the Linux OOM killer will prefer
 // certain process types over others. The range for the adjustment is
 // [-17,15], with [0,15] being user accessible.
 bool AdjustOOMScore(ProcessId process, int score);
 #endif
 
 #if defined(OS_POSIX)
 // Close all file descriptors, expect those which are a destination in the
 // given multimap. Only call this function in a child process where you know
 // that there aren't any other threads.
-void CloseSuperfluousFds(const base::InjectiveMultimap& saved_map);
+void CloseSuperfluousFds(const InjectiveMultimap& saved_map);
 #endif
 
 #if defined(OS_WIN)
 // Runs the given application name with the given command line. Normally, the
 // first command line argument should be the path to the process, and don't
 // forget to quote it.
 //
 // If wait is true, it will block and wait for the other process to finish,
 // otherwise, it will just continue asynchronously.
 //
@@ skipping 92 matching lines @@
 // for the command.
 bool GetAppOutputRestricted(const CommandLine& cl,
                             std::string* output, size_t max_output);
 #endif
 
 // Used to filter processes by process ID.
 class ProcessFilter {
  public:
   // Returns true to indicate set-inclusion and false otherwise.  This method
   // should not have side-effects and should be idempotent.
-  virtual bool Includes(ProcessId pid, ProcessId parent_pid) const = 0;
+  virtual bool Includes(const ProcessEntry& entry) const = 0;
 };
 
 // Returns the number of processes on the machine that are running from the
 // given executable name.  If filter is non-null, then only processes selected
 // by the filter will be counted.
 int GetProcessCount(const std::wstring& executable_name,
                     const ProcessFilter* filter);
 
 // Attempts to kill all the processes on the current machine that were launched
 // from the given executable name, ending them with the given exit code.  If
@@ skipping 52 matching lines @@
 // executable name to exit, then kills off any of them that are still around.
 // If filter is non-null, then only processes selected by the filter are waited
 // on.  Killed processes are ended with the given exit code.  Returns false if
 // any processes needed to be killed, true if they all exited cleanly within
 // the wait_milliseconds delay.
 bool CleanupProcesses(const std::wstring& executable_name,
                       int64 wait_milliseconds,
                       int exit_code,
                       const ProcessFilter* filter);
 
-// This class provides a way to iterate through the list of processes
-// on the current machine that were started from the given executable
-// name.  To use, create an instance and then call NextProcessEntry()
-// until it returns false.
-class NamedProcessIterator {
+// This class provides a way to iterate through a list of processes on the
+// current machine with a specified filter.
+// To use, create an instance and then call NextProcessEntry() until it returns
+// false.
+class ProcessIterator {
  public:
-  NamedProcessIterator(const std::wstring& executable_name,
-                       const ProcessFilter* filter);
-  ~NamedProcessIterator();
+  explicit ProcessIterator(const ProcessFilter* filter);
+  virtual ~ProcessIterator();
 
   // If there's another process that matches the given executable name,
   // returns a const pointer to the corresponding PROCESSENTRY32.
   // If there are no more matching processes, returns NULL.
   // The returned pointer will remain valid until NextProcessEntry()
   // is called again or this NamedProcessIterator goes out of scope.
   const ProcessEntry* NextProcessEntry();
 
+  // Takes a snapshot of all the ProcessEntry found.
+  std::list<ProcessEntry> Snapshot();
+
+ protected:
+  virtual bool IncludeEntry();
+  const ProcessEntry& entry() { return entry_; }
+
  private:
   // Determines whether there's another process (regardless of executable)
   // left in the list of all processes.  Returns true and sets entry_ to
   // that process's info if there is one, false otherwise.
   bool CheckForNextProcess();
 
-  bool IncludeEntry();
-
   // Initializes a PROCESSENTRY32 data structure so that it's ready for
   // use with Process32First/Process32Next.
   void InitProcessEntry(ProcessEntry* entry);
 
-  std::wstring executable_name_;
-
 #if defined(OS_WIN)
   HANDLE snapshot_;
   bool started_iteration_;
 #elif defined(OS_MACOSX)
   std::vector<kinfo_proc> kinfo_procs_;
   size_t index_of_kinfo_proc_;
 #elif defined(OS_POSIX)
   DIR *procfs_dir_;
 #endif
   ProcessEntry entry_;
   const ProcessFilter* filter_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(NamedProcessIterator);
+  DISALLOW_COPY_AND_ASSIGN(ProcessIterator);
+};
+
+// This class provides a way to iterate through the list of processes
+// on the current machine that were started from the given executable
+// name.  To use, create an instance and then call NextProcessEntry()
+// until it returns false.
+class NamedProcessIterator : public ProcessIterator {
+ public:
+  NamedProcessIterator(const std::wstring& executable_name,
+                       const ProcessFilter* filter);
+  virtual ~NamedProcessIterator();
+
+ protected:
+  virtual bool IncludeEntry();
+
+ private:
+  std::wstring executable_name_;
+
+  DISALLOW_COPY_AND_ASSIGN(NamedProcessIterator);
 };
 
 // Working Set (resident) memory usage broken down by
 //
 // On Windows:
 // priv (private): These pages (kbytes) cannot be shared with any other process.
 // shareable:      These pages (kbytes) can be shared with other processes under
 //                 the right circumstances.
 // shared :        These pages (kbytes) are currently shared with at least one
 //                 other process.
@@ skipping 59 matching lines @@
     // metrics on OS X (except for the current process, which always gets
     // metrics).
     virtual mach_port_t TaskForPid(ProcessHandle process) const = 0;
   };
 
   // The port provider needs to outlive the ProcessMetrics object returned by
   // this function. If NULL is passed as provider, the returned object
   // only returns valid metrics if |process| is the current process.
   static ProcessMetrics* CreateProcessMetrics(ProcessHandle process,
                                               PortProvider* port_provider);
-#endif
+#endif  // !defined(OS_MACOSX)
 
   ~ProcessMetrics();
 
   // Returns the current space allocated for the pagefile, in bytes (these pages
   // may or may not be in memory).  On Linux, this returns the total virtual
   // memory size.
   size_t GetPagefileUsage() const;
   // Returns the peak space allocated for the pagefile, in bytes.
   size_t GetPeakPagefileUsage() const;
   // Returns the current working set size, in bytes.  On Linux, this returns
@@ skipping 31 matching lines @@
   // If IO information is retrieved successfully, the function returns true
   // and fills in the IO_COUNTERS passed in. The function returns false
   // otherwise.
   bool GetIOCounters(IoCounters* io_counters) const;
 
  private:
 #if !defined(OS_MACOSX)
   explicit ProcessMetrics(ProcessHandle process);
 #else
   ProcessMetrics(ProcessHandle process, PortProvider* port_provider);
-#endif
+#endif  // !defined(OS_MACOSX)
 
   ProcessHandle process_;
 
   int processor_count_;
 
   // Used to store the previous times and CPU usage counts so we can
   // compute the CPU usage between calls.
   int64 last_time_;
   int64 last_system_time_;
 
 #if defined(OS_MACOSX)
   // Queries the port provider if it's set.
   mach_port_t TaskForPid(ProcessHandle process) const;
 
   PortProvider* port_provider_;
 #elif defined(OS_POSIX)
   // Jiffie count at the last_time_ we updated.
   int last_cpu_;
-#endif
+#endif  // defined(OS_MACOSX)
 
-  DISALLOW_EVIL_CONSTRUCTORS(ProcessMetrics);
+  DISALLOW_COPY_AND_ASSIGN(ProcessMetrics);
 };
 
 // Returns the memory commited by the system in KBytes.
 // Returns 0 if it can't compute the commit charge.
 size_t GetSystemCommitCharge();
 
 // Enables low fragmentation heap (LFH) for every heaps of this process. This
 // won't have any effect on heaps created after this function call. It will not
 // modify data allocated in the heaps before calling this function. So it is
 // better to call this function early in initialization and again before
@@ skipping 24 matching lines @@
 
 #if defined(OS_MACOSX)
 // Restore the default exception handler, setting it to Apple Crash Reporter
 // (ReportCrash).  When forking and execing a new process, the child will
 // inherit the parent's exception ports, which may be set to the Breakpad
 // instance running inside the parent.  The parent's Breakpad instance should
 // not handle the child's exceptions.  Calling RestoreDefaultExceptionHandler
 // in the child after forking will restore the standard exception handler.
 // See http://crbug.com/20371/ for more details.
 void RestoreDefaultExceptionHandler();
-#endif
+#endif  // defined(OS_MACOSX)
 
 }  // namespace base
 
 #endif  // BASE_PROCESS_UTIL_H_