Implement NamedProcessIterator in base/process_util_mac.mm. Patch by Naoki...

base/process_util_posix.cc

 // Copyright (c) 2006-2008 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 <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/resource.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/platform_thread.h"
 #include "base/process_util.h"
 #include "base/sys_info.h"
 #include "base/time.h"
 
 const int kMicrosecondsPerSecond = 1000000;
 
 namespace base {
 
 int GetCurrentProcId() {
   return getpid();
@@ skipping 233 matching lines @@
   // We add time_delta / 2 so the result is rounded.
   int cpu = static_cast<int>((system_time_delta * 100 + time_delta / 2) /
                              time_delta);
 
   last_system_time_ = system_time;
   last_time_ = time;
 
   return cpu;
 }
 
+int GetProcessCount(const std::wstring& executable_name,
+                    const ProcessFilter* filter) {
+  int count = 0;
+
+  NamedProcessIterator iter(executable_name, filter);
+  while (iter.NextProcessEntry())
+    ++count;
+  return count;
+}
+
+bool KillProcesses(const std::wstring& executable_name, int exit_code,
+                   const ProcessFilter* filter) {
+  bool result = true;
+  const ProcessEntry* entry;
+
+  NamedProcessIterator iter(executable_name, filter);
+  while ((entry = iter.NextProcessEntry()) != NULL)
+    result = KillProcess((*entry).pid, exit_code, true) && result;
+
+  return result;
+}
+
+bool WaitForProcessesToExit(const std::wstring& executable_name,
+                            int wait_milliseconds,
+                            const ProcessFilter* filter) {
+  bool result = false;
+
+  // TODO(port): This is inefficient, but works if there are multiple procs.
+  // TODO(port): use waitpid to avoid leaving zombies around
+
+  base::Time end_time = base::Time::Now() +
+      base::TimeDelta::FromMilliseconds(wait_milliseconds);
+  do {
+    NamedProcessIterator iter(executable_name, filter);
+    if (!iter.NextProcessEntry()) {
+      result = true;
+      break;
+    }
+    PlatformThread::Sleep(100);
+  } while ((base::Time::Now() - end_time) > base::TimeDelta());
+
+  return result;
+}
+
+bool CleanupProcesses(const std::wstring& executable_name,
+                      int wait_milliseconds,
+                      int exit_code,
+                      const ProcessFilter* filter) {
+  bool exited_cleanly =
+      WaitForProcessesToExit(executable_name, wait_milliseconds,
+                           filter);
+  if (!exited_cleanly)
+    KillProcesses(executable_name, exit_code, filter);
+  return exited_cleanly;
+}
+
 }  // namespace base