Cleanup WaitpidWithTimeout

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>
 
 #include "base/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/process/process_iterator.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/platform_thread.h"
 
 namespace base {
 
 namespace {
 
-int WaitpidWithTimeout(ProcessHandle handle,
-                       int64 wait_milliseconds,
-                       bool* success) {
+bool WaitpidWithTimeout(ProcessHandle handle,
+                        int* status,
+                        base::TimeDelta wait) {
   // This POSIX version of this function only guarantees that we wait no less
-  // than |wait_milliseconds| for the process to exit.  The child process may
+  // than |wait| for the process to exit.  The child process may
   // exit sometime before the timeout has ended but we may still block for up
   // to 256 milliseconds after the fact.
   //
   // waitpid() has no direct support on POSIX for specifying a timeout, you can
   // either ask it to block indefinitely or return immediately (WNOHANG).
   // When a child process terminates a SIGCHLD signal is sent to the parent.
   // Catching this signal would involve installing a signal handler which may
   // affect other parts of the application and would be difficult to debug.
   //
   // Our strategy is to call waitpid() once up front to check if the process
-  // has already exited, otherwise to loop for wait_milliseconds, sleeping for
+  // has already exited, otherwise to loop for |wait|, sleeping for
   // at most 256 milliseconds each time using usleep() and then calling
   // 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.
-  int status = -1;
-  pid_t ret_pid = HANDLE_EINTR(waitpid(handle, &status, WNOHANG));
+
+  if (wait.InMilliseconds() == base::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() +
-      TimeDelta::FromMilliseconds(wait_milliseconds);
+  TimeTicks wakeup_time = TimeTicks::Now() + wait;
   while (ret_pid == 0) {
     TimeTicks now = TimeTicks::Now();
     if (now > wakeup_time)
       break;
     // Guaranteed to be non-negative!
     int64 sleep_time_usecs = (wakeup_time - now).InMicroseconds();
     // Sleep for a bit while we wait for the process to finish.
     if (sleep_time_usecs > max_sleep_time_usecs)
       sleep_time_usecs = max_sleep_time_usecs;
 
     // usleep() will return 0 and set errno to EINTR on receipt of a signal
     // such as SIGCHLD.
     usleep(sleep_time_usecs);
-    ret_pid = HANDLE_EINTR(waitpid(handle, &status, WNOHANG));
+    ret_pid = HANDLE_EINTR(waitpid(handle, status, WNOHANG));
 
     if ((max_sleep_time_usecs < kMaxSleepInMicroseconds) &&
         (double_sleep_time++ % 4 == 0)) {
       max_sleep_time_usecs *= 2;
     }
   }
 
-  if (success)
-    *success = (ret_pid != -1);
-
-  return status;
+  return ret_pid > 0;
 }
 
 TerminationStatus GetTerminationStatusImpl(ProcessHandle handle,
                                            bool can_block,
                                            int* exit_code) {
   int status = 0;
   const pid_t result = HANDLE_EINTR(waitpid(handle, &status,
                                             can_block ? 0 : WNOHANG));
   if (result == -1) {
     DPLOG(ERROR) << "waitpid(" << handle << ")";
@@ skipping 124 matching lines @@
   }
 
   // If it didn't exit cleanly, it must have been signaled.
   DCHECK(WIFSIGNALED(status));
   return false;
 }
 
 bool WaitForExitCodeWithTimeout(ProcessHandle handle,
                                 int* exit_code,
                                 base::TimeDelta timeout) {
-  bool waitpid_success = false;
-  int status = WaitpidWithTimeout(handle, timeout.InMilliseconds(),
-                                  &waitpid_success);
-  if (status == -1)
-    return false;
-  if (!waitpid_success)
+  int status;
+  if (!WaitpidWithTimeout(handle, &status, timeout))
     return false;
   if (WIFSIGNALED(status)) {
     *exit_code = -1;
     return true;
   }
   if (WIFEXITED(status)) {
     *exit_code = WEXITSTATUS(status);
     return true;
   }
   return false;
@@ skipping 117 matching lines @@
   if (parent_pid != our_pid) {
 #if defined(OS_MACOSX)
     // On Mac we can wait on non child processes.
     return WaitForSingleNonChildProcess(handle, wait);
 #else
     // Currently on Linux we can't handle non child processes.
     NOTIMPLEMENTED();
 #endif  // OS_MACOSX
   }
 
-  bool waitpid_success;
-  int status = -1;
-  if (wait.InMilliseconds() == base::kNoTimeout) {
-    waitpid_success = (HANDLE_EINTR(waitpid(handle, &status, 0)) != -1);
-  } else {
-    status = WaitpidWithTimeout(
-        handle, wait.InMilliseconds(), &waitpid_success);
-  }
-
-  if (status != -1) {
-    DCHECK(waitpid_success);
-    return WIFEXITED(status);
-  } else {
+  int status;
+  if (!WaitpidWithTimeout(handle, &status, wait))
     return false;
-  }
+  return WIFEXITED(status);
 }
 
 bool CleanupProcesses(const FilePath::StringType& executable_name,
                       base::TimeDelta wait,
                       int exit_code,
                       const ProcessFilter* filter) {
   bool exited_cleanly = WaitForProcessesToExit(executable_name, wait, filter);
   if (!exited_cleanly)
     KillProcesses(executable_name, exit_code, filter);
   return exited_cleanly;
@@ skipping 91 matching lines @@
   if (IsChildDead(process))
     return;
 
   BackgroundReaper* reaper = new BackgroundReaper(process, 0);
   PlatformThread::CreateNonJoinable(0, reaper);
 }
 
 #endif  // !defined(OS_MACOSX)
 
 }  // namespace base