Implemented process_util_mac.mm because net_unittests requires those function...

base/process_util_linux.cc

 // Copyright (c) 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 "base/process_util.h"
 
 #include <ctype.h>
 #include <dirent.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <string>
 #include <sys/types.h>
 #include <sys/wait.h>
 
 #include "base/file_util.h"
 #include "base/logging.h"
-#include "base/platform_thread.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/time.h"
 
 namespace {
 
 enum ParsingState {
   KEY_NAME,
   KEY_VALUE
 };
@@ skipping 167 matching lines @@
 
 bool NamedProcessIterator::IncludeEntry() {
   // TODO(port): make this also work for non-ASCII filenames
   if (WideToASCII(executable_name_) != entry_.szExeFile)
     return false;
   if (!filter_)
     return true;
   return filter_->Includes(entry_.pid, entry_.ppid);
 }
 
-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;
-}
-
 // To have /proc/self/io file you must enable CONFIG_TASK_IO_ACCOUNTING
 // in your kernel configuration.
 bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) {
   std::string proc_io_contents;
   if (!file_util::ReadFileToString(L"/proc/self/io", &proc_io_contents))
     return false;
 
   (*io_counters).OtherOperationCount = 0;
   (*io_counters).OtherTransferCount = 0;
 
@@ skipping 18 matching lines @@
           (*io_counters).WriteTransferCount = StringToInt64(tokenizer.token());
         }
         state = KEY_NAME;
         break;
     }
   }
   return true;
 }
 
 }  // namespace base