Non-SFI Mode: Build base/ library by PNaCL toolchain for nacl_helper_nonsfi.

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/files/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 {
 
+#if !defined(__native_client_nonsfi__)
 bool WaitpidWithTimeout(ProcessHandle handle,
                         int* status,
                         base::TimeDelta wait) {
   // This POSIX version of this function only guarantees that we wait no less
   // 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).
@@ skipping 41 matching lines @@
     ret_pid = HANDLE_EINTR(waitpid(handle, status, WNOHANG));
 
     if ((max_sleep_time_usecs < kMaxSleepInMicroseconds) &&
         (double_sleep_time++ % 4 == 0)) {
       max_sleep_time_usecs *= 2;
     }
   }
 
   return ret_pid > 0;
 }
+#endif  // !defined(__native_client_nonsfi__)
 
 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 << ")";
     if (exit_code)
@@ skipping 27 matching lines @@
   }
 
   if (WIFEXITED(status) && WEXITSTATUS(status) != 0)
     return TERMINATION_STATUS_ABNORMAL_TERMINATION;
 
   return TERMINATION_STATUS_NORMAL_TERMINATION;
 }
 
 }  // namespace
 
+#if !defined(__native_client_nonsfi__)
 // Attempts to kill the process identified by the given process
 // entry structure.  Ignores specified exit_code; posix can't force that.
 // Returns true if this is successful, false otherwise.
 bool KillProcess(ProcessHandle process_id, int exit_code, bool wait) {
   DCHECK_GT(process_id, 1) << " tried to kill invalid process_id";
   if (process_id <= 1)
     return false;
   bool result = kill(process_id, SIGTERM) == 0;
   if (result && wait) {
     int tries = 60;
@@ skipping 41 matching lines @@
 
   return result;
 }
 
 bool KillProcessGroup(ProcessHandle process_group_id) {
   bool result = kill(-1 * process_group_id, SIGKILL) == 0;
   if (!result)
     DPLOG(ERROR) << "Unable to terminate process group " << process_group_id;
   return result;
 }
+#endif  // !defined(__native_client_nonsfi__)
 
 TerminationStatus GetTerminationStatus(ProcessHandle handle, int* exit_code) {
   return GetTerminationStatusImpl(handle, false /* can_block */, exit_code);
 }
 
 TerminationStatus GetKnownDeadTerminationStatus(ProcessHandle handle,
                                                 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(__native_client_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;
@@ skipping 252 matching lines @@
 void EnsureProcessGetsReaped(ProcessHandle process) {
   // If the child is already dead, then there's nothing to do.
   if (IsChildDead(process))
     return;
 
   BackgroundReaper* reaper = new BackgroundReaper(process, 0);
   PlatformThread::CreateNonJoinable(0, reaper);
 }
 
 #endif  // !defined(OS_MACOSX)
+#endif  // !defined(__native_client_nonsfi__)
 
 }  // namespace base