Remove base::WaitForExitCode*

base/process/kill_posix.cc

 // Copyright (c) 2013 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/kill.h"
 
 #include <signal.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
@@ skipping 32 matching lines @@
   // waitpid().  The amount of time we sleep starts out at 1 milliseconds, and
   // we double it every 4 sleep cycles.
   //
   // usleep() is speced to exit if a signal is received for which a handler
   // has been installed.  This means that when a SIGCHLD is sent, it will exit
   // depending on behavior external to this function.
   //
   // This function is used primarily for unit tests, if we want to use it in
   // the application itself it would probably be best to examine other routes.
 
-  if (wait.InMilliseconds() == base::kNoTimeout) {
+  if (wait.InMilliseconds() == base::internal::kNoTimeout) {
     return HANDLE_EINTR(waitpid(handle, status, 0)) > 0;
   }
 
   pid_t ret_pid = HANDLE_EINTR(waitpid(handle, status, WNOHANG));
   static const int64 kMaxSleepInMicroseconds = 1 << 18;  // ~256 milliseconds.
   int64 max_sleep_time_usecs = 1 << 10;  // ~1 milliseconds.
   int64 double_sleep_time = 0;
 
   // If the process hasn't exited yet, then sleep and try again.
   TimeTicks wakeup_time = TimeTicks::Now() + wait;
@@ skipping 21 matching lines @@
   return ret_pid > 0;
 }
 
 #if defined(OS_MACOSX)
 // Using kqueue on Mac so that we can wait on non-child processes.
 // We can't use kqueues on child processes because we need to reap
 // our own children using wait.
 static bool WaitForSingleNonChildProcess(ProcessHandle handle,
                                          TimeDelta wait) {
   DCHECK_GT(handle, 0);
-  DCHECK(wait.InMilliseconds() == kNoTimeout || wait > TimeDelta());
+  DCHECK(wait.InMilliseconds() == internal::kNoTimeout || wait > TimeDelta());
 
   ScopedFD kq(kqueue());
   if (!kq.is_valid()) {
     DPLOG(ERROR) << "kqueue";
     return false;
   }
 
   struct kevent change = {0};
   EV_SET(&change, handle, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, NULL);
   int result = HANDLE_EINTR(kevent(kq.get(), &change, 1, NULL, 0, NULL));
   if (result == -1) {
     if (errno == ESRCH) {
       // If the process wasn't found, it must be dead.
       return true;
     }
 
     DPLOG(ERROR) << "kevent (setup " << handle << ")";
     return false;
   }
 
   // Keep track of the elapsed time to be able to restart kevent if it's
   // interrupted.
-  bool wait_forever = wait.InMilliseconds() == kNoTimeout;
+  bool wait_forever = (wait.InMilliseconds() == internal::kNoTimeout);
   TimeDelta remaining_delta;
   TimeTicks deadline;
   if (!wait_forever) {
     remaining_delta = wait;
     deadline = TimeTicks::Now() + remaining_delta;
   }
 
   result = -1;
   struct kevent event = {0};
 
@@ skipping 166 matching lines @@
                                                 int* exit_code) {
   bool result = kill(handle, SIGKILL) == 0;
 
   if (!result)
     DPLOG(ERROR) << "Unable to terminate process " << handle;
 
   return GetTerminationStatusImpl(handle, true /* can_block */, exit_code);
 }
 
 #if !defined(OS_NACL_NONSFI)
-bool WaitForExitCode(ProcessHandle handle, int* exit_code) {
-  int status;
-  if (HANDLE_EINTR(waitpid(handle, &status, 0)) == -1) {
-    NOTREACHED();
-    return false;
-  }
-
-  if (WIFEXITED(status)) {
-    *exit_code = WEXITSTATUS(status);
-    return true;
-  }
-
-  // If it didn't exit cleanly, it must have been signaled.
-  DCHECK(WIFSIGNALED(status));
-  return false;
-}
-
-bool WaitForExitCodeWithTimeout(ProcessHandle handle,
-                                int* exit_code,
-                                TimeDelta timeout) {
+bool internal::WaitForExitCodeWithTimeout(ProcessHandle handle,
+                                          int* exit_code,
+                                          TimeDelta timeout) {
   ProcessHandle parent_pid = GetParentProcessId(handle);
   ProcessHandle our_pid = GetCurrentProcessHandle();
   if (parent_pid != our_pid) {
 #if defined(OS_MACOSX)
     // On Mac we can wait on non child processes.
     return WaitForSingleNonChildProcess(handle, timeout);
 #else
     // Currently on Linux we can't handle non child processes.
     NOTIMPLEMENTED();
 #endif  // OS_MACOSX
@@ skipping 137 matching lines @@
     return;
 
   BackgroundReaper* reaper = new BackgroundReaper(pid, 0);
   PlatformThread::CreateNonJoinable(0, reaper);
 }
 
 #endif  // !defined(OS_MACOSX)
 #endif  // !defined(OS_NACL_NONSFI)
 
 }  // namespace base