Make CrashAwareSleep more accurate on POSIX (checking if the process exists).

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>
@@ skipping 166 matching lines @@
     return true;
   }
 
   // If it didn't exit cleanly, it must have been signaled.
   DCHECK(WIFSIGNALED(status));
   return false;
 }
 
 namespace {
 
-int WaitpidWithTimeout(ProcessHandle handle, int wait_milliseconds) {
+int WaitpidWithTimeout(ProcessHandle handle, int wait_milliseconds,
+                       bool* success) {
   // This POSIX version of this function only guarantees that we wait no less
   // than |wait_milliseconds| for the proces to exit.  The child process may
   // exit sometime before the timeout has ended but we may still block for
   // up to 0.25 seconds 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.
@@ skipping 25 matching lines @@
     if (sleep_time_usecs > kQuarterSecondInMicroseconds) {
       sleep_time_usecs = kQuarterSecondInMicroseconds;
     }
 
     // usleep() will return 0 and set errno to EINTR on receipt of a signal
     // such as SIGCHLD.
     usleep(sleep_time_usecs);
     ret_pid = waitpid(handle, &status, WNOHANG);
   }
 
+  if (success)
+    *success = (ret_pid != -1);
+
   return status;
 }
 
 }  // namespace
 
 bool WaitForSingleProcess(ProcessHandle handle, int wait_milliseconds) {
-  int status = WaitpidWithTimeout(handle, wait_milliseconds);
-  if (status != -1)
+  bool waitpid_success;
+  int status = WaitpidWithTimeout(handle, wait_milliseconds, &waitpid_success);
+  if (status != -1) {
+    DCHECK(waitpid_success);
     return WIFEXITED(status);
-  else
+  } else {
     return false;
+  }
 }
 
 bool CrashAwareSleep(ProcessHandle handle, int wait_milliseconds) {
-  int status = WaitpidWithTimeout(handle, wait_milliseconds);
-  if (status != -1)
+  bool waitpid_success;
+  int status = WaitpidWithTimeout(handle, wait_milliseconds, &waitpid_success);
+  if (status != -1) {
+    DCHECK(waitpid_success);
     return !(WIFEXITED(status) || WIFSIGNALED(status));
-  else
-    return true;
+  } else {
+    // If waitpid returned with an error, then the process doesn't exist
+    // (which most probably means it didn't exist before our call).
+    return waitpid_success;
+  }
 }
 
 namespace {
 
 int64 TimeValToMicroseconds(const struct timeval& tv) {
   return tv.tv_sec * kMicrosecondsPerSecond + tv.tv_usec;
 }
 
 }
 
@@ skipping 86 matching lines @@
                       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